मैं ActiveRecord कॉलबैक चलाने से कैसे बच सकता हूं?

Question 1

मेरे पास कुछ मॉडल हैं जिनके पास बाद में कॉलबैक है। आमतौर पर यह ठीक है, लेकिन कुछ स्थितियों में, जैसे विकास डेटा बनाते समय, मैं कॉलबैक चलाने के बिना मॉडल को सहेजना चाहता हूं। क्या ऐसा करने का एक सरल तरीका है? कुछ के समान ...

Person#save( :run_callbacks => false )

या

Person#save_without_callbacks

मैंने रेल डॉक्स में देखा और कुछ भी नहीं पाया। हालांकि मेरे अनुभव में रेल डॉक्स हमेशा पूरी कहानी नहीं बताते हैं।

अपडेट करें

मुझे एक ब्लॉग पोस्ट मिली जो बताती है कि आप इस तरह से एक मॉडल से कॉलबैक कैसे निकाल सकते हैं:

Foo.after_save.clear

मुझे नहीं पता था कि वह तरीका कहाँ से प्रलेखित है लेकिन यह काम करने लगता है।

Question 2

यह समाधान केवल रेल 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)

यह निश्चित रूप से कुछ है जो आप केवल कंसोल में उपयोग करना चाहते हैं या कुछ यादृच्छिक परीक्षण कर रहे हैं। उम्मीद है की यह मदद करेगा!

Question 3

का प्रयोग करें update_column(रेल> = v3.1) या update_columns(रेल> = 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

Question 4

अपडेट किया गया:

@ विक्रांत चौधरी का हल बेहतर लगता है:

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

मेरा मूल उत्तर:

इस लिंक को देखें: ActiveRecord कॉलबैक कैसे छोड़ें?

रेल 3 में,

मान लें कि हमारे पास एक वर्ग परिभाषा है:

class User < ActiveRecord::Base
  after_save :generate_nick_name
end

Approach1:

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

दृष्टिकोण: जब आप उन्हें अपनी rspec फ़ाइलों या जो कुछ भी छोड़ना चाहते हैं, यह कोशिश करें:

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

नोट: एक बार ऐसा करने के बाद, यदि आप rspec वातावरण में नहीं हैं, तो आपको कॉलबैक रीसेट करना चाहिए:

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

3.0.5 रेल पर मेरे लिए ठीक काम करता है

Question 5

यदि लक्ष्य केवल कॉलबैक या सत्यापन के बिना एक रिकॉर्ड सम्मिलित करना है, और आप इसे अतिरिक्त रत्नों का सहारा लिए बिना करना चाहते हैं, सशर्त जांचों को जोड़ते हुए, रॉ एसक्यूएल का उपयोग करते हुए, या किसी भी तरह से अपने बाहर निकलने वाले कोड के साथ फ्यूजनिंग करें, तो "छाया" का उपयोग करने पर विचार करें ऑब्जेक्ट "आपके मौजूदा db टेबल की ओर इशारा करते हुए। इस तरह:

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

यह रेल के हर संस्करण के साथ काम करता है, थ्रेडसेफ़ है, और आपके मौजूदा कोड में कोई संशोधन नहीं होने के साथ सभी मान्यताओं और कॉलबैक को पूरी तरह से समाप्त कर देता है। आप अपने वास्तविक आयात से ठीक पहले उस वर्ग की घोषणा को टॉस कर सकते हैं, और आपको जाने के लिए अच्छा होना चाहिए। ऑब्जेक्ट डालने के लिए अपने नए वर्ग का उपयोग करना याद रखें, जैसे:

ImportedPerson.new( person_attributes )

Question 6

रेल 3:

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

Question 7

आप अपने व्यक्तिगत मॉडल में कुछ इस तरह की कोशिश कर सकते हैं:

after_save :something_cool, :unless => :skip_callbacks

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

संपादित करें: after_save एक प्रतीक नहीं है, लेकिन यह कम से कम 1,000 वीं बार मैंने इसे बनाने की कोशिश की है।

Question 8

आप उपयोग कर सकते हैं update_columns :

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

किसी ऑब्जेक्ट की दी गई विशेषताओं को अपडेट करता है, बिना कॉल सेव किए, इसलिए सत्यापन और कॉलबैक को छोड़ देता है।

Question 9

सभी 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

Question 10

रेल 2.3 में इसे हैंडल करने का एक तरीका दिखता है (चूंकि update_without_callbacks चला गया है, आदि), अद्यतन update_all का उपयोग करना होगा, जो कि उन तरीकों में से एक है जो कॉलबैक के खंड 12 के अनुसार मान्यताओं और कॉलबैक के लिए गाइड करता है। ।

यह भी ध्यान दें कि यदि आप अपने after_ callback में कुछ कर रहे हैं, तो यह कई संघों पर आधारित एक गणना करता है (यानी has_many assoc, जहाँ आप भी स्वीकार करते हैं_nested_attributes_for), आपको सहेज के भाग के रूप में, एसोसिएशन को पुनः लोड करना होगा। , इसके सदस्यों में से एक को हटा दिया गया था।

Question 11

सबसे अधिक up-voted जवाब कुछ मामलों में भ्रामक लग सकता है।

ifयदि आप कॉलबैक को छोड़ना चाहते हैं, तो आप बस एक साधारण जांच का उपयोग कर सकते हैं :

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

Question 12

https://gist.github.com/576546

बस इस बंदर-पैच को config / initializers / Skip_callbacks.rb में डंप करें

फिर

Project.skip_callbacks { @project.save }

या जैसे।

लेखक को सभी श्रेय

Question 13

एक समाधान है कि एक मणि या प्लगइन के उपयोग के बिना रेल के सभी संस्करणों में काम करना चाहिए सीधे अद्यतन बयान जारी करने के लिए है। जैसे

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

यह इस बात पर निर्भर करता है कि (या हो सकता है) आपका विकल्प कितना जटिल है। इस से एक रिकार्ड पर जैसे को अपडेट करने में झंडे के लिए अच्छी तरह से काम के भीतर (कॉलबैक retriggering के बिना) एक after_save कॉलबैक।

Question 14

मुझे रेल 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)

Question 15

# 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

Question 16

इन बिंदुओं में से कोई भी 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 रेल्स 2.x के साथ काम करती है

Question 17

मैंने एक प्लगइन लिखा है जो RAIL 3 में update_without_callbacks को लागू करता है:

http://github.com/dball/skip_activerecord_callbacks

सही समाधान, मुझे लगता है, पहली बार में कॉलबैक से बचने के लिए अपने मॉडल को फिर से लिखना है, लेकिन अगर यह निकट अवधि में अव्यावहारिक है, तो यह प्लगइन मदद कर सकता है।

Question 18

यदि आप रेल का उपयोग कर रहे हैं 2. आप कॉलबैक और सत्यापन को चलाए बिना अपने कॉलम को अपडेट करने के लिए SQL क्वेरी का उपयोग कर सकते हैं।

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

मुझे लगता है कि इसे किसी भी रेल संस्करण में काम करना चाहिए।

Question 19

जब मुझे कॉलबैक पर पूर्ण नियंत्रण की आवश्यकता होती है, तो मैं एक और विशेषता बनाता हूं जिसका उपयोग स्विच के रूप में किया जाता है। सरल और प्रभावी:

नमूना:

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

Question 20

रेल में परीक्षण डेटा बनाने के लिए आप इस हैक का उपयोग करते हैं:

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

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

Question 21

आप डरपोक-बचाओ रत्न का उपयोग कर सकते हैं: https://rubygems.org/gems/sneaky-save ।

ध्यान दें कि यह बिना मान्यता के संघों को बचाने में मदद नहीं कर सकता है। यह 'create_at null नहीं हो सकता' त्रुटि को फेंकता है क्योंकि यह सीधे मॉडल के विपरीत sql क्वेरी को सम्मिलित करता है। इसे लागू करने के लिए, हमें db के सभी ऑटो जनरेट किए गए कॉलम को अपडेट करना होगा।

Question 22

आप विकास में ऐसा क्यों कर पाएंगे? निश्चित रूप से इसका मतलब होगा कि आप अवैध डेटा के साथ अपने एप्लिकेशन का निर्माण कर रहे हैं और इस तरह यह अजीब व्यवहार करेगा और उत्पादन में अपेक्षा के अनुरूप नहीं होगा।

यदि आप डेटा के साथ अपने देव डीबी को आबाद करना चाहते हैं तो एक बेहतर कार्य एक रेक कार्य का निर्माण होगा जो मान्य डेटा के निर्माण के लिए फ़ेकर मणि का उपयोग करता है और इसे अपनी इच्छानुसार कई या कुछ रिकॉर्ड बनाते हुए db में आयात करता है, लेकिन यदि आप एड़ी हैं इस पर झुकें और मेरे पास एक अच्छा कारण है कि मुझे लगता है कि update_without_callbacks और create_without_callbacks ठीक काम करेंगे, लेकिन जब आप अपनी इच्छा से रेल को मोड़ने की कोशिश कर रहे हों, तो अपने आप से पूछें कि आपके पास एक अच्छा कारण है और यदि आप जो कर रहे हैं वह वास्तव में एक अच्छा विचार है।

Question 23

एक विकल्प में इस तरह की जोड़तोड़ के लिए एक अलग मॉडल है, एक ही तालिका का उपयोग कर:

class NoCallbacksModel < ActiveRecord::Base
  set_table_name 'table_name_of_model_that_has_callbacks'

  include CommonModelMethods # if there are
  :
  :

end

(एक ही दृष्टिकोण मान्यताओं को दरकिनार करने से चीजें आसान हो सकती हैं)

स्टीफ़न

Question 24

कॉलबैक के बजाय सत्यापन हुक का उपयोग करने का एक और तरीका होगा। उदाहरण के लिए:

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)

Question 25

ऐसा कुछ जो 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: एक ही टेबल पर "अलग-अलग एक्टिवरकार्ड मॉडल" का उपयोग करें

Question 26

कस्टम कॉलबैक के लिए, a `attr_accessor`और a का उपयोग करें`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.

Question 27

मुझे उसी समस्या का सामना करना पड़ा, जब मैं एक रेक टास्क चलाना चाहता था, लेकिन हर रिकॉर्ड के लिए कॉलबैक को चलाए बिना मैं बचत कर रहा था। यह मेरे लिए काम किया (रेल 5), और यह रेल के लगभग हर संस्करण के लिए काम करना चाहिए:

class MyModel < ApplicationRecord
  attr_accessor :skip_callbacks
  before_create :callback1
  before_update :callback2
  before_destroy :callback3

  private
  def callback1
    return true if @skip_callbacks
    puts "Runs callback1"
    # Your code
  end
  def callback2
    return true if @skip_callbacks
    puts "Runs callback2"
    # Your code
  end
  # Same for callback3 and so on....
end

जिस तरह से यह काम करता है वह यह है कि यह स्किप करने की विधि की पहली पंक्ति में सही है। यह सच है, इसलिए यह विधि के बाकी कोड को नहीं चलाता है। कॉलबैक को छोड़ने के लिए आपको बस स्किप करने की जरूरत है, बचत करने से पहले, इसे नष्ट करने से पहले, इसे नष्ट करना:

rec = MyModel.new() # Or Mymodel.find()
rec.skip_callbacks = true
rec.save

Question 28

सबसे साफ तरीका नहीं है, लेकिन आप कॉलबैक कोड को ऐसी स्थिति में लपेट सकते हैं जो रेल के वातावरण की जांच करता है।

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

मैं ActiveRecord कॉलबैक चलाने से कैसे बच सकता हूं?

कस्टम कॉलबैक के लिए, a attr_accessorऔर a का उपयोग करेंunless ।

कस्टम कॉलबैक के लिए, a `attr_accessor`और a का उपयोग करें`unless` ।