Come posso evitare di eseguire callback ActiveRecord?

Ho alcuni modelli che hanno richiamate after_save. Di solito va bene, ma in alcune situazioni, come quando si creano dati di sviluppo, voglio salvare i modelli senza far funzionare i callback. C'è un modo semplice per farlo? Qualcosa di simile a ...

Person#save( :run_callbacks => false )

o

Person#save_without_callbacks

Ho cercato nei documenti di Rails e non ho trovato nulla. Tuttavia, nella mia esperienza, i documenti di Rails non raccontano sempre l'intera storia.

AGGIORNARE

Ho trovato un post sul blog che spiega come rimuovere i callback da un modello come questo:

Foo.after_save.clear

Non sono riuscito a trovare dove sia documentato quel metodo ma sembra funzionare.

Questa soluzione è solo Rails 2.

Ho appena indagato su questo e penso di avere una soluzione. Esistono due metodi privati ​​di ActiveRecord che è possibile utilizzare:

update_without_callbacks
create_without_callbacks

Dovrai utilizzare send per chiamare questi metodi. esempi:

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

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

Questo è sicuramente qualcosa che vorresti davvero usare solo nella console o durante alcuni test casuali. Spero che questo ti aiuti!

Utilizzare update_column(Rails> = v3.1) o update_columns(Rails> = 4.0) per saltare callback e validazioni. Anche con questi metodi, nonupdated_at viene aggiornato.

#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: saltare i callback che funzionano anche durante la creazione di un oggetto

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

aggiornato:

La soluzione di @Vikrant Chaudhary sembra migliore:

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

La mia risposta originale:

vedi questo link: Come saltare i callback di ActiveRecord?

in Rails3,

supponiamo di avere una definizione di classe:

class User < ActiveRecord::Base
  after_save :generate_nick_name
end 

Approach1:

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

Approach2: quando vuoi saltarli nei tuoi file rspec o altro, prova questo:

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

NOTA: una volta fatto ciò, se non ci si trova nell'ambiente rspec, è necessario ripristinare i callback:

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

funziona bene per me su rotaie 3.0.5

rotaie 3:

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

Se l'obiettivo è semplicemente inserire un record senza richiamate o convalide e si desidera farlo senza ricorrere a gemme aggiuntive, aggiungere controlli condizionali, utilizzare RAW SQL o inavvertirsi con il codice in uscita in alcun modo, considerare l'utilizzo di un "ombra oggetto "che punta alla tabella db esistente. Così:

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

Funziona con ogni versione di Rails, è thread-safe ed elimina completamente tutte le convalide e le richiamate senza alcuna modifica al codice esistente. Puoi semplicemente lanciare quella dichiarazione di classe proprio prima dell'importazione effettiva e dovresti essere pronto per partire. Ricorda solo di usare la tua nuova classe per inserire l'oggetto, come:

ImportedPerson.new( person_attributes )

Potresti provare qualcosa del genere nel tuo modello Person:

after_save :something_cool, :unless => :skip_callbacks

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

EDIT: after_save non è un simbolo, ma questa è almeno la millesima volta che ho provato a farne uno.

Puoi usare update_columns:

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

Aggiorna gli attributi dati di un oggetto, senza chiamare save, saltando quindi convalide e callback.

L'unico modo per impedire tutti i callback after_save è avere il primo a restituire false.

Forse potresti provare qualcosa del genere (non testato):

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

Sembra un modo per gestirlo in Rails 2.3 (dato che update_without_callbacks è sparito, ecc.), Sarebbe usare update_all, che è uno dei metodi che salta i callback secondo la sezione 12 della Guida di Rails per convalide e callback .

Inoltre, tieni presente che se stai facendo qualcosa nel tuo callback after_, che fa un calcolo basato su molte associazioni (cioè un has_many assoc, dove fai anche accettare_nested_attributes_for), dovrai ricaricare l'associazione, nel caso facesse parte del salvataggio , uno dei suoi membri è stato eliminato.

https://gist.github.com/576546

basta scaricare questa patch scimmia in config / initializer / skip_callbacks.rb

poi

Project.skip_callbacks { @project.save }

o simili.

tutto merito all'autore

La maggior parte delle up-votedrisposte potrebbe sembrare confusa in alcuni casi.

È possibile utilizzare solo un semplice ifcontrollo se si desidera saltare una richiamata, in questo modo:

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

Una soluzione che dovrebbe funzionare su tutte le versioni di Rails senza l'uso di una gemma o di un plugin è semplicemente quella di rilasciare direttamente le dichiarazioni di aggiornamento. per esempio

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

Questa potrebbe (o meno) essere un'opzione in base alla complessità dell'aggiornamento. Questo funziona bene per esempio bandiere di aggiornamento su un record da all'interno di un callback after_save (senza riarmo il callback).

# 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

Nessuno di questi punti indica un without_callbacksplug-in che fa esattamente ciò di cui hai bisogno ...

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 funziona con Rails 2.x

Ho scritto un plugin che implementa update_without_callbacks in Rails 3:

http://github.com/dball/skip_activerecord_callbacks

La soluzione giusta, penso, è quella di riscrivere i tuoi modelli per evitare i callback, ma se questo non è pratico nel breve termine, questo plugin può aiutare.

Se si utilizza Rails 2. È possibile utilizzare la query SQL per aggiornare la colonna senza eseguire callback e convalide.

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

Penso che dovrebbe funzionare in tutte le versioni di binari.

Quando ho bisogno del controllo completo sul callback, creo un altro attributo che viene utilizzato come switch. Semplice ed efficace:

Modello:

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

Test:

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

Per creare dati di test in Rails usi questo hack:

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

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

Puoi usare la gemma subdolo: https://rubygems.org/gems/sneaky-save .

Nota che questo non può aiutare a salvare le associazioni senza convalide. Genera errore "create_at non può essere nullo" poiché inserisce direttamente la query sql a differenza di un modello. Per implementare questo, dobbiamo aggiornare tutte le colonne generate automaticamente di db.

Avevo bisogno di una soluzione per Rails 4, quindi ho pensato a questo:

app / modelli / preoccupazioni / 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

in qualsiasi modello:

include SaveWithoutCallbacks

allora puoi:

record.save_without_callbacks

o

Model::WithoutCallbacks.create(attributes)

Perché vorresti essere in grado di farlo nello sviluppo? Sicuramente questo significherà che stai costruendo la tua applicazione con dati non validi e come tale si comporterà in modo strano e non come ti aspetti dalla produzione.

Se vuoi popolare il tuo db di sviluppo con i dati, un approccio migliore sarebbe quello di costruire un'attività di rake che usasse la gemma falsa per costruire dati validi e importarli nel db creando tutti i record che desideri, ma se sei il tallone piegati su di esso e hai una buona ragione immagino che update_without_callbacks e create_without_callbacks funzioneranno bene, ma quando stai cercando di piegare le rotaie alla tua volontà, chiediti di avere una buona ragione e se quello che stai facendo è davvero una buona idea.

Un'opzione è quella di avere un modello separato per tali manipolazioni, usando la stessa tabella:

class NoCallbacksModel < ActiveRecord::Base
  set_table_name 'table_name_of_model_that_has_callbacks'

  include CommonModelMethods # if there are
  :
  :

end

(Lo stesso approccio potrebbe semplificare le cose per bypassare le convalide)

Stephan

Un altro modo sarebbe quello di utilizzare gli hook di validazione anziché i callback. Per esempio:

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

In questo modo puoi ottenere do_something per impostazione predefinita, ma puoi facilmente sostituirlo con:

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

Qualcosa che dovrebbe funzionare con tutte le versioni di ActiveRecordsenza dipendere da opzioni o metodi activerecord che potrebbero esistere o meno.

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: utilizzare un "modello activerecord diverso" sulla stessa tabella

Per richiamate personalizzate, utilizzare un attr_accessore ununless nel callback.

Definisci il tuo modello come segue:

class Person << ActiveRecord::Base

  attr_accessor :skip_after_save_callbacks

  after_save :do_something, unless: :skip_after_save_callbacks

end

Quindi, se è necessario salvare il record senza colpire i after_savecallback definiti, impostare l' skip_after_save_callbacksattributo virtuale su 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.

Non è il modo più pulito, ma è possibile racchiudere il codice di richiamata in una condizione che controlla l'ambiente Rails.

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