ActiveRecord geri çağrılarını çalıştırmayı nasıl önleyebilirim?

After_save geri çağrıları olan bazı modellerim var. Genellikle bu iyidir, ancak bazı durumlarda, geliştirme verileri oluştururken olduğu gibi, geri çağrıları çalıştırmadan modelleri kaydetmek istiyorum. Bunu yapmanın basit bir yolu var mı? Benzer bir şey ...

Person#save( :run_callbacks => false )

veya

Person#save_without_callbacks

Rails belgelerine baktım ve hiçbir şey bulamadım. Ancak deneyimlerime göre Rails belgeleri her zaman tüm hikayeyi anlatmıyor.

GÜNCELLEME

Böyle bir modelden geri aramaları nasıl kaldırabileceğinizi açıklayan bir blog yazısı buldum :

Foo.after_save.clear

Bu yöntemin nerede belgelendiğini bulamadım ama işe yarıyor gibi görünüyor.

Bu çözüm yalnızca Rails 2'dir.

Sadece araştırdım ve bir çözüm bulduğumu düşünüyorum. Kullanabileceğiniz iki ActiveRecord özel yöntemi vardır:

update_without_callbacks
create_without_callbacks

Bu yöntemleri çağırmak için send'i kullanmanız gerekecek. örnekler:

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

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

Bu kesinlikle sadece konsolda veya bazı rastgele testler yaparken kullanmak isteyeceğiniz bir şeydir. Bu yardımcı olur umarım!

Geri aramaları ve doğrulamaları atlamak için update_column(Rails> = v3.1) veya update_columns(Rails> = 4.0) tuşlarını kullanın . Ayrıca bu yöntemlerle, updated_atbir değil güncellendi.

#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: Nesne oluştururken de çalışan geri çağrıları atlama

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

Güncellenmiş:

@Vikrant Chaudhary'nin çözümü daha iyi görünüyor:

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

Orijinal cevabım:

bu bağlantıya bakın: ActiveRecord geri çağrılarını nasıl atlayabilirim?

Rails3'te,

bir sınıf tanımımız olduğunu varsayalım:

class User < ActiveRecord::Base
  after_save :generate_nick_name
end 

Approach1:

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

Yaklaşım2: rspec dosyalarınızda veya başka bir şeyde atlamak istediğinizde şunu deneyin:

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

NOT: bu yapıldıktan sonra, rspec ortamında değilseniz, geri çağrıları sıfırlamanız gerekir:

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

raylar üzerinde benim için iyi çalışıyor 3.0.5

raylar 3:

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

Amaç geri arama veya doğrulama olmadan bir kayıt eklemekse ve ek taşlara başvurmadan, koşullu kontroller eklemeden, RAW SQL kullanarak veya herhangi bir şekilde çıkış kodunuzla fütür etmeden yapmak istiyorsanız, "gölge" mevcut db tablonuzu gösterecektir. Şöyle ki:

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

Bu, Rails'in her sürümü ile çalışır, threadsafe'tir ve mevcut kodunuzda değişiklik yapılmadan tüm doğrulama ve geri çağrıları tamamen ortadan kaldırır. Bu sınıf bildirimini gerçek içe aktarmanızdan hemen önce atabilirsiniz ve gitmek için iyi olmalısınız. Nesneyi eklemek için yeni sınıfınızı kullanmayı unutmayın, örneğin:

ImportedPerson.new( person_attributes )

Kişi modelinizde böyle bir şey deneyebilirsiniz:

after_save :something_cool, :unless => :skip_callbacks

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

DÜZENLEME: after_save bir sembol değil, ama en azından 1000'inci kez yapmaya çalıştım.

Şunları kullanabilirsiniz update_columns:

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

Bir nesnenin verilen özniteliklerini, kaydet çağrısı yapmadan günceller, böylece doğrulamaları ve geri aramaları atlar.

Tüm after_save geri çağrılarını engellemenin tek yolu, ilki yanlış döndürmektir.

Belki (denenmemiş) gibi bir şey deneyebilirsiniz:

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

Bunu Rails 2.3'te ele almanın bir yolu gibi görünüyor (update_without_callbacks gittiğinden, vb.), Doğrulamalar ve geri aramalar için Rails Rehberinin 12. bölümüne göre geri çağrıları atlayan yöntemlerden biri olan update_all kullanmak olacaktır .

Ayrıca, after_ geri çağrınızda bir şey yapıyorsanız, bunun birçok ilişkilendirmeye (yani has_many assoc, burada kabul etmeyi kabul ettiğiniz_veya_atışmalar_for) dayalı bir hesaplama yaparsa, kaydetmenin bir parçası olması durumunda ilişkilendirmeyi yeniden yüklemeniz gerektiğini unutmayın , üyelerinden biri silindi.

https://gist.github.com/576546

bu maymun yamasını config / initializers / skip_callbacks.rb dosyasına atmanız yeterli

sonra

Project.skip_callbacks { @project.save }

veya benzeri.

yazara verilen tüm krediler

En çok up-votedcevap bazı durumlarda kafa karıştırıcı görünebilir.

ifBir geri aramayı atlamak istiyorsanız, basit bir kontrolü kullanabilirsiniz , örneğin:

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

Bir mücevher veya eklenti kullanmadan Rails'in tüm sürümlerinde çalışması gereken bir çözüm, doğrudan güncelleme bildirimlerini yayınlamaktır. Örneğin

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

Bu, güncellemenizin ne kadar karmaşık olduğuna bağlı olarak bir seçenek olabilir (veya olmayabilir). Bu, örneğin bir kayıt sonrası geri çağrının içinden (geri çağrıyı geri almadan) bayrakların güncellenmesi için iyi çalışır .

# 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

Bu noktaların hiçbiri without_callbackssadece ihtiyacınız olanı yapan eklentiye işaret ediyor ...

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 ile çalışır

Rails 3'te update_without_callbacks uygulayan bir eklenti yazdım:

http://github.com/dball/skip_activerecord_callbacks

Doğru çözüm, bence, ilk başta geri aramalardan kaçınmak için modellerinizi yeniden yazmaktır, ancak yakın vadede pratik değilse, bu eklenti yardımcı olabilir.

Rails 2 kullanıyorsanız. Geri arama ve doğrulama çalıştırmadan sütununuzu güncellemek için SQL sorgusunu kullanabilirsiniz.

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

Ray sürümlerinde çalışması gerektiğini düşünüyorum.

Geri arama üzerinde tam kontrole ihtiyaç duyduğumda, anahtar olarak kullanılan başka bir özellik oluşturuyorum. Basit ve etkili:

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

Ölçek:

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'te test verileri oluşturmak için bu hack'i kullanırsınız:

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

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

Sinsi tasarruflu taş kullanabilirsiniz: https://rubygems.org/gems/sneaky-save .

Bunun, doğrulama olmadan ilişkilendirmelerin kaydedilmesine yardımcı olamayacağını unutmayın. Bir modelden farklı olarak sql sorgusunu doğrudan eklediğinden 'created_at null olamaz' hatası veriyor. Bunu uygulamak için tüm otomatik oluşturulan db sütunlarını güncellememiz gerekir.

Rails 4 için bir çözüme ihtiyacım vardı, bu yüzden bunu buldum:

Uygulamanın / modeller / kaygılar / 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

herhangi bir modelde:

include SaveWithoutCallbacks

o zaman yapabilirsin:

record.save_without_callbacks

veya

Model::WithoutCallbacks.create(attributes)

Bunu neden geliştirme aşamasında yapmak istesin ki? Elbette bu, uygulamanızı geçersiz verilerle oluşturduğunuz anlamına gelir ve bu nedenle, üretimde beklediğiniz gibi değil, garip davranacaktır.

Dev db'nizi verilerle doldurmak istiyorsanız, daha iyi bir yaklaşım, geçerli verileri oluşturmak ve istediğiniz kadar çok veya az kayıt oluşturarak db'ye aktarmak için faker gem'i kullanan bir komisyon görevi oluşturmak olacaktır. üzerinde eğildi ve iyi bir neden var Ben update_without_callbacks ve create_without_callbacks iyi çalışacağını tahmin, ama irade rayları bükmek için çalışırken, kendinize iyi bir neden var ve gerçekten iyi bir fikir olup olmadığını sormak.

Bir seçenek, aynı tabloyu kullanarak bu tür manipülasyonlar için ayrı bir modele sahip olmaktır:

class NoCallbacksModel < ActiveRecord::Base
  set_table_name 'table_name_of_model_that_has_callbacks'

  include CommonModelMethods # if there are
  :
  :

end

(Aynı yaklaşım, onaylamaları atlamak için işleri kolaylaştırabilir)

Stephan

Başka bir yol, geri aramalar yerine doğrulama kancalarını kullanmak olabilir. Örneğin:

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

Bu şekilde do_something'i varsayılan olarak alabilirsiniz, ancak aşağıdakilerle kolayca geçersiz kılabilirsiniz:

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

Var olan ActiveRecordveya bulunmayan seçeneklere veya etkin kayıt yöntemlerine bağlı kalmadan tüm sürümleriyle çalışması gereken bir şey .

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: aynı tablo üzerinde "farklı bir aktüatör modeli" kullanın

Özel geri aramalar için a attr_accessorve anunless geri arama.

Modelinizi aşağıdaki gibi tanımlayın:

class Person << ActiveRecord::Base

  attr_accessor :skip_after_save_callbacks

  after_save :do_something, unless: :skip_after_save_callbacks

end

Ardından after_save, tanımladığınız geri aramalara basmadan kaydı kaydetmeniz gerekiyorsa , skip_after_save_callbackssanal özelliği olarak ayarlayın 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.

En temiz yol değil, ancak geri arama kodunu Rails ortamını kontrol eden bir koşulda sarabilirsiniz.

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