Rails: Ignorando gli attributi inesistenti passati per creare()

Question

Ho il seguente modello Rails:

class CreateFoo < ActiveRecord::Migration 
    def self.up 
    create_table :foo do |t| 
     t.string :a 
     t.string :b 
     t.string :c 
     t.timestamps 
    end 
    end 

    def self.down 
    drop_table :foo 
    end 
end 

Se provo e creare un nuovo record con un attributo aggiuntivo inesistente, questo produce un errore:

Foo.create(a: 'some', b: 'string', c: 'foo', d: 'bar') 
ActiveRecord::UnknownAttributeError: unknown attribute: d 

C'è un modo per ottenere create() per ignorare attributi che non esistono nel modello? In alternativa, qual è il modo migliore per rimuovere gli attributi inesistenti prima di creare il nuovo record?

Molte grazie

Answer 1

Cercando pensare a un modo potenzialmente più efficiente, ma per ora:

hash = { :a => 'some', :b => 'string', :c => 'foo', :d => 'bar' } 
@something = Something.new 
@something.attributes = hash.reject{|k,v| !@something.attributes.keys.member?(k.to_s) } 
@something.save 

Answer 2

Re: C'è un modo per ottenere create() per ignorare gli attributi che non esistono nel modello? - No, e questo è di progettazione.

È possibile creare un attr_setter che verrà utilizzato dal create -

attr_setter :a # will silently absorb additional parameter 'a' from the form. 

Re: In alternativa, qual è il modo migliore per rimuovere gli attributi inesistenti prima di creare il nuovo record?

È possibile rimuovere esplicitamente:

params[:Foo].delete(:a) # delete the extra param :a 

Ma il migliore è di non metterli lì, in primo luogo. Modifica il tuo modulo per ometterli.

Aggiunto:

Dato l'informazioni aggiornate (dati in entrata), penso che mi piacerebbe creare un nuovo hash:

incoming_data_array.each{|rec| 
    Foo.create {:a => rec['a'], :b => rec['b'], :c => rec['c']} # create new 
                   # rec from specific 
                   # fields 
} 

aggiunto più

# Another way: 
keepers = ['a', 'b', 'c'] # fields used by the Foo class. 

incoming_data_array.each{|rec| 
    Foo.create rec.delete_if{|key, value| !keepers.include?(key)} # create new rec 
}                # from kept 
                   # fields 

Answer 3

penso che utilizzando il metodo di attr_accessiblenella classe modello per Foo potrebbe ottenere quello che vuoi, ad esempio ,:

class Foo < ActiveRecord::Base 

    attr_accessible :a, :b, :c 

    ... 
end 

Ciò consentirebbe la creazione/aggiornamento dei soli attributi elencati con attr_accessible.

Answer 4

Ho appena avuto questo esatto aggiornamento problema a Rails 3.2, quando ho impostato:

config.active_record.mass_assignment_sanitizer = :strict 

ha causato alcuni dei miei creare! chiama per fallire, dal momento che i campi precedentemente ignorati causano errori di assegnazione di massa.Ho lavorato intorno ad esso fingendo i campi nel modello come segue:

attr_accessor :field_to_exclude 
attr_accessible :field_to_exclude 

Answer 5

Io lo uso spesso (semplificato):

params.select!{|x| Model.attribute_names.index(x)} 
Model.update_attributes(params) 

Answer 6

mi si avvicinò con una soluzione che assomiglia a questo, si potrebbe trovare utile:

def self.create_from_hash(hash) 
    hash.select! {|k, v| self.column_names.include? k } 
    self.create(hash) 
end 

Questa è stata una soluzione ideale per me, perché nel mio caso hash era venuta da una fonte di dati ideale che rispecchiava il mio schema (tranne che c'erano campi aggiuntivi).

Answer 7

Ho trovato una soluzione che funziona abbastanza bene, ed è in definitiva una combinazione delle opzioni di cui sopra. Permette di passare (e ignorare) parametri non validi, mentre quelli validi sono mappati correttamente all'oggetto.

def self.initialize(params={}) 
    User.new(params.reject { |k| !User.attribute_method?(k) }) 
end 

Ora invece di chiamare User.new(), chiamano User.initialize(). Questo "filtrerà" i parametri corretti in modo abbastanza elegante.

Answer 8

È possibile utilizzare il metodo Hash#slice e column_names anche come metodo di classe.

hash = {a: 'some', b: 'string', c: 'foo', d: 'bar'} 
Foo.create(hash.slice(*Foo.column_names.map(&:to_sym)))