Làm cách nào để tránh chạy lại cuộc gọi lại ActiveRecord?

Tôi có một số mô hình có các cuộc gọi lại after_save. Thông thường thì không sao, nhưng trong một số trường hợp, như khi tạo dữ liệu phát triển, tôi muốn lưu các mô hình mà không cần phải gọi lại. Có một cách đơn giản để làm điều đó? Một cái gì đó giống với ...

Person#save( :run_callbacks => false )

hoặc là

Person#save_without_callbacks

Tôi đã xem tài liệu Rails và không tìm thấy gì. Tuy nhiên, theo kinh nghiệm của tôi, các tài liệu Rails không phải lúc nào cũng kể toàn bộ câu chuyện.

CẬP NHẬT

Tôi đã tìm thấy một bài đăng trên blog giải thích cách bạn có thể xóa các cuộc gọi lại từ một mô hình như thế này:

Foo.after_save.clear

Tôi không thể tìm thấy nơi mà phương pháp đó được ghi lại nhưng nó dường như hoạt động.

Giải pháp này chỉ là Rails 2.

Tôi chỉ điều tra điều này và tôi nghĩ rằng tôi có một giải pháp. Có hai phương thức riêng tư ActiveRecord mà bạn có thể sử dụng:

update_without_callbacks
create_without_callbacks

Bạn sẽ phải sử dụng gửi để gọi các phương thức này. ví dụ:

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

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

Đây chắc chắn là thứ mà bạn chỉ thực sự muốn sử dụng trong bảng điều khiển hoặc trong khi thực hiện một số thử nghiệm ngẫu nhiên. Hi vọng điêu nay co ich!

Sử dụng update_column (Rails> = v3.1) hoặc update_columns(Rails> = 4.0) để bỏ qua các cuộc gọi lại và xác nhận. Ngoài ra với phương pháp này, updated_atlà không được cập nhật.

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

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

# 2: Bỏ qua các cuộc gọi lại cũng hoạt động trong khi tạo một đối tượng

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

Cập nhật:

Giải pháp của @Vikrant Chaudhary có vẻ tốt hơn:

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

Câu trả lời ban đầu của tôi:

xem liên kết này: Làm thế nào để bỏ qua các cuộc gọi lại ActiveRecord?

trong Rails3,

giả sử chúng ta có một định nghĩa lớp:

class User < ActiveRecord::Base
  after_save :generate_nick_name
end 

Cách tiếp cận1:

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

Cách tiếp cận2: Khi bạn muốn bỏ qua chúng trong các tệp rspec của bạn hoặc bất cứ điều gì, hãy thử điều này:

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

LƯU Ý: một khi điều này được thực hiện, nếu bạn không ở trong môi trường rspec, bạn nên đặt lại các cuộc gọi lại:

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

hoạt động tốt với tôi trên đường ray 3.0.5

đường ray 3:

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

Nếu mục tiêu chỉ đơn giản là chèn một bản ghi mà không cần gọi lại hoặc xác nhận hợp lệ và bạn muốn thực hiện nó mà không cần dùng đến đá quý bổ sung, thêm kiểm tra có điều kiện, sử dụng RAW SQL hoặc chuyển tiếp với mã thoát của bạn theo bất kỳ cách nào, hãy xem xét sử dụng "bóng" đối tượng "trỏ đến bảng db hiện tại của bạn. Thích như vậy:

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

Điều này hoạt động với mọi phiên bản của Rails, là chủ đề an toàn và loại bỏ hoàn toàn tất cả các xác nhận và gọi lại mà không sửa đổi mã hiện tại của bạn. Bạn chỉ có thể ném khai báo lớp đó ngay trước khi nhập thực tế của bạn và bạn nên đi. Chỉ cần nhớ sử dụng lớp mới của bạn để chèn đối tượng, như:

ImportedPerson.new( person_attributes )

Bạn có thể thử một cái gì đó như thế này trong mô hình Người của bạn:

after_save :something_cool, :unless => :skip_callbacks

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

EDIT: after_save không phải là một biểu tượng, nhưng đó ít nhất là lần thứ 1.000 tôi đã cố gắng biến nó thành một biểu tượng.

Bạn có thể sử dụng update_columns:

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

Cập nhật các thuộc tính đã cho của một đối tượng, mà không gọi lưu, do đó bỏ qua các xác nhận và gọi lại.

Cách duy nhất để ngăn chặn tất cả các cuộc gọi lại after_save là có lần đầu tiên trả về false.

Có lẽ bạn có thể thử một cái gì đó như (chưa được kiểm tra):

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

Có vẻ như một cách để xử lý việc này trong Rails 2.3 (vì update_without_callbacks đã biến mất, v.v.), sẽ sử dụng update_all, một trong những phương pháp bỏ qua các cuộc gọi lại theo phần 12 của Hướng dẫn Rails để xác thực và gọi lại .

Ngoài ra, lưu ý rằng nếu bạn đang thực hiện một thao tác nào đó trong cuộc gọi lại after_ của mình, thì đó là một phép tính dựa trên nhiều liên kết (ví dụ: PGS has_many, trong đó bạn cũng thực hiện ac accept_nested_attribut_for), bạn sẽ cần phải tải lại liên kết, trong trường hợp là một phần của lưu , một trong những thành viên của nó đã bị xóa.

https://gist.github.com/576546

chỉ cần kết xuất bản vá khỉ này vào cấu hình / bộ khởi tạo / Skip_callbacks.rb

sau đó

Project.skip_callbacks { @project.save }

hoặc tương tự.

tất cả tín dụng cho tác giả

Nhất up-votedCâu trả lời có vẻ khó hiểu trong một số trường hợp.

Bạn có thể sử dụng chỉ một ifkiểm tra đơn giản nếu bạn muốn bỏ qua một cuộc gọi lại, như thế này:

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

Một giải pháp hoạt động trên tất cả các phiên bản Rails mà không cần sử dụng gem hay plugin chỉ đơn giản là phát hành các bản cập nhật trực tiếp. ví dụ

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

Điều này có thể (hoặc có thể không) là một tùy chọn tùy thuộc vào mức độ phức tạp của bản cập nhật của bạn. Điều này hoạt động tốt cho ví dụ cập nhật cờ trên một bản ghi từ trong một cuộc gọi lại after_save (mà không cần gọi lại cuộc gọi lại).

# 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

Không có điểm nào trong số các without_callbacksplugin này chỉ làm những gì bạn cần ...

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 hoạt động với Rails 2.x

Tôi đã viết một plugin thực hiện update_without_callbacks trong Rails 3:

http://github.com/dball/skip_activerecord_callbacks

Tôi nghĩ rằng giải pháp phù hợp là viết lại các mô hình của bạn để tránh các cuộc gọi lại ngay từ đầu, nhưng nếu điều đó không thực tế trong thời gian tới, plugin này có thể giúp ích.

Nếu bạn đang sử dụng Rails 2. Bạn có thể sử dụng truy vấn SQL để cập nhật cột của mình mà không cần chạy lại và xác nhận hợp lệ.

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

Tôi nghĩ rằng nó nên hoạt động trong bất kỳ phiên bản đường ray.

Khi tôi cần toàn quyền kiểm soát cuộc gọi lại, tôi tạo một thuộc tính khác được sử dụng làm công tắc. Đơn giản và hiệu quả:

Mô hình:

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

Kiểm tra:

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

Để tạo dữ liệu thử nghiệm trong Rails, bạn sử dụng bản hack này:

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

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

Bạn có thể sử dụng đá quý lưu lén: https://rubygems.org/gems/sneaky-save .

Lưu ý điều này không thể giúp lưu các hiệp hội cùng mà không có xác nhận. Nó đưa ra lỗi 'created_at không thể null' vì nó trực tiếp chèn truy vấn sql không giống như một mô hình. Để thực hiện điều này, chúng ta cần cập nhật tất cả các cột db được tạo tự động.

Tôi cần một giải pháp cho Rails 4, vì vậy tôi đã đưa ra điều này:

ứng dụng / mô hình / mối quan tâm / 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

trong bất kỳ mô hình nào:

include SaveWithoutCallbacks

sau đó bạn có thể:

record.save_without_callbacks

hoặc là

Model::WithoutCallbacks.create(attributes)

Tại sao bạn muốn có thể làm điều này trong phát triển? Chắc chắn điều này có nghĩa là bạn đang xây dựng ứng dụng của mình với dữ liệu không hợp lệ và như vậy nó sẽ hoạt động kỳ lạ và không như bạn mong đợi trong sản xuất.

Nếu bạn muốn tạo dữ liệu dev db của mình với dữ liệu, cách tiếp cận tốt hơn là xây dựng một tác vụ cào sử dụng đá quý giả để xây dựng dữ liệu hợp lệ và nhập nó vào db tạo ra nhiều hoặc ít bản ghi như bạn muốn, nhưng nếu bạn là gót chân dựa vào nó và có một lý do chính đáng

Một tùy chọn là có một mô hình riêng cho các thao tác đó, sử dụng cùng một bảng:

class NoCallbacksModel < ActiveRecord::Base
  set_table_name 'table_name_of_model_that_has_callbacks'

  include CommonModelMethods # if there are
  :
  :

end

(Cách tiếp cận tương tự có thể làm cho mọi thứ dễ dàng hơn để bỏ qua xác nhận)

Stephan

Một cách khác là sử dụng móc xác nhận thay vì gọi lại. Ví dụ:

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

Bằng cách đó, bạn có thể lấy do_s Something theo mặc định, nhưng bạn có thể dễ dàng ghi đè lên nó bằng:

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

Một cái gì đó nên hoạt động với tất cả các phiên bản ActiveRecordmà không phụ thuộc vào các tùy chọn hoặc phương thức activerecord có thể tồn tại hoặc không tồn tại.

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: sử dụng "mô hình Activerecord khác" trên cùng một bảng

Đối với các cuộc gọi lại tùy chỉnh, sử dụng một attr_accessorvà một unlesstrong cuộc gọi lại.

Xác định mô hình của bạn như sau:

class Person << ActiveRecord::Base

  attr_accessor :skip_after_save_callbacks

  after_save :do_something, unless: :skip_after_save_callbacks

end

Và sau đó nếu bạn cần lưu bản ghi mà không cần nhấn các after_savecuộc gọi lại mà bạn đã xác định, hãy đặt skip_after_save_callbacksthuộc tính ảo thành 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.

Không phải là cách sạch nhất, nhưng bạn có thể bọc mã gọi lại trong điều kiện kiểm tra môi trường Rails.

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