Como posso definir o valor padrão no ActiveRecord?

Eu vejo uma postagem do Pratik que descreve um pedaço feio e complicado de código: http://m.onkey.org/2007/7/24/how-to-set-default-values-in-your-model

class Item < ActiveRecord::Base  
  def initialize_with_defaults(attrs = nil, &block)
    initialize_without_defaults(attrs) do
      setter = lambda { |key, value| self.send("#{key.to_s}=", value) unless
        !attrs.nil? && attrs.keys.map(&:to_s).include?(key.to_s) }
      setter.call('scheduler_type', 'hotseat')
      yield self if block_given?
    end
  end
  alias_method_chain :initialize, :defaults
end

Vi os seguintes exemplos pesquisando no Google:

  def initialize 
    super
    self.status = ACTIVE unless self.status
  end

e

  def after_initialize 
    return unless new_record?
    self.status = ACTIVE
  end

Também vi pessoas colocarem isso em sua migração, mas prefiro vê-lo definido no código do modelo.

Existe uma maneira canônica de definir o valor padrão para os campos no modelo ActiveRecord?

Existem vários problemas com cada um dos métodos disponíveis, mas acredito que definir um after_initializeretorno de chamada é o caminho a seguir pelos seguintes motivos:

1. default_scopeinicializará valores para novos modelos, mas esse será o escopo no qual você encontra o modelo. Se você deseja inicializar alguns números para 0, isso não é que você deseja.
2. Definir padrões na sua migração também funciona parte do tempo ... Como já foi mencionado, isso não será funcionará quando você apenas chamar Model.new.
3. Substituir initializepode funcionar, mas não se esqueça de ligar parasuper !
4. Usar um plugin como o phusion está ficando um pouco ridículo. Isso é ruby, precisamos mesmo de um plugin apenas para inicializar alguns valores padrão?
5. A substituição after_initialize está obsoleta a partir do Rails 3. Quando eu substituo after_initializeno Rails 3.0.3, recebo o seguinte aviso no console:

AVISO DE DEPRECÇÃO: A base # after_initialize foi descontinuada, use o método Base.after_initialize:. (chamado de / Users / me / myapp / app / models / my_model: 15)

Portanto, eu diria para escrever um after_initializeretorno de chamada, que permite atributos padrão , além de definir padrões em associações como:

  class Person < ActiveRecord::Base
    has_one :address
    after_initialize :init

    def init
      self.number  ||= 0.0           #will set the default value only if it's nil
      self.address ||= build_address #let's you set a default association
    end
  end    

Agora você tem apenas um lugar para procurar a inicialização de seus modelos. Estou usando esse método até que alguém crie um melhor.

Ressalvas:

1. Para campos booleanos, faça:

   self.bool_field = true if self.bool_field.nil?

   Veja o comentário de Paul Russell nesta resposta para obter mais detalhes

2. Se você estiver selecionando apenas um subconjunto de colunas para um modelo (por exemplo, usando selectuma consulta como Person.select(:firstname, :lastname).all), receberá um MissingAttributeErrorse o seu initmétodo acessar uma coluna que não foi incluída na selectcláusula. Você pode se proteger contra esse caso da seguinte maneira:

   self.number ||= 0.0 if self.has_attribute? :number

   e para uma coluna booleana ...

   self.bool_field = true if (self.has_attribute? :bool_value) && self.bool_field.nil?

   Observe também que a sintaxe é diferente antes do Rails 3.2 (veja o comentário de Cliff Darling abaixo)

Rails 5+

Você pode usar o método de atributo em seus modelos, por exemplo:

class Account < ApplicationRecord
  attribute :locale, :string, default: 'en'
end

Você também pode passar uma lambda para o defaultparâmetro Exemplo:

attribute :uuid, UuidType.new, default: -> { SecureRandom.uuid }

Colocamos os valores padrão no banco de dados através de migrações (especificando o :default opção em cada definição de coluna) e permitimos que o Active Record use esses valores para definir o padrão para cada atributo.

IMHO, essa abordagem está alinhada com os princípios da AR: convenção sobre configuração, DRY, a definição da tabela impulsiona o modelo, e não o contrário.

Observe que os padrões ainda estão no código do aplicativo (Ruby), embora não no modelo, mas nas migrações.

Alguns casos simples podem ser tratados com a definição de um padrão no esquema do banco de dados, mas isso não lida com vários casos mais complicados, incluindo valores calculados e chaves de outros modelos. Para esses casos, faço o seguinte:

after_initialize :defaults

def defaults
   unless persisted?
    self.extras||={}
    self.other_stuff||="This stuff"
    self.assoc = [OtherModel.find_by_name('special')]
  end
end

Decidi usar o after_initialize, mas não quero que ele seja aplicado a objetos que são encontrados apenas aqueles novos ou criados. Eu acho que é quase chocante que um retorno de chamada after_new não seja fornecido para este caso de uso óbvio, mas fiz isso confirmando se o objeto já está persistindo, indicando que não é novo.

Tendo visto a resposta de Brad Murray, isso é ainda mais limpo se a condição for movida para a solicitação de retorno de chamada:

after_initialize :defaults, unless: :persisted?
              # ":if => :new_record?" is equivalent in this context

def defaults
  self.extras||={}
  self.other_stuff||="This stuff"
  self.assoc = [OtherModel.find_by_name('special')]
end

O padrão de retorno de chamada after_initialize pode ser aprimorado simplesmente fazendo o seguinte

after_initialize :some_method_goes_here, :if => :new_record?

Isso tem um benefício não trivial se o seu código de inicialização precisar lidar com associações, pois o código a seguir aciona um n + 1 sutil se você ler o registro inicial sem incluir o associado.

class Account

  has_one :config
  after_initialize :init_config

  def init_config
    self.config ||= build_config
  end

end

Os caras do Phusion têm um plugin interessante para isso.

Uma maneira potencial ainda melhor / mais limpa do que as respostas propostas é substituir o acessador, assim:

def status
  self['status'] || ACTIVE
end

Consulte "Substituindo acessadores padrão" na documentação do ActiveRecord :: Base e muito mais no StackOverflow ao usar self .

Eu uso a attribute-defaultsgema

Na documentação: execute sudo gem install attribute-defaultse adicione require 'attribute_defaults'ao seu aplicativo.

class Foo < ActiveRecord::Base
  attr_default :age, 18
  attr_default :last_seen do
    Time.now
  end
end

Foo.new()           # => age: 18, last_seen => "2014-10-17 09:44:27"
Foo.new(:age => 25) # => age: 25, last_seen => "2014-10-17 09:44:28"

Perguntas semelhantes, mas todas possuem um contexto um pouco diferente: - Como crio um valor padrão para atributos no modelo de registro ativo do Rails?

Melhor resposta: depende do que você quer!

Se você deseja que cada objeto comece com um valor: useafter_initialize :init

Deseja que o new.htmlformulário tenha um valor padrão ao abrir a página? use https://stackoverflow.com/a/5127684/1536309

class Person < ActiveRecord::Base
  has_one :address
  after_initialize :init

  def init
    self.number  ||= 0.0           #will set the default value only if it's nil
    self.address ||= build_address #let's you set a default association
  end
  ...
end 

Se você deseja que cada objeto tenha um valor calculado a partir da entrada do usuário: usebefore_save :default_values Deseja que o usuário insiraXe, em seguidaY = X+'foo'? usar:

class Task < ActiveRecord::Base
  before_save :default_values
  def default_values
    self.status ||= 'P'
  end
end

É para isso que os construtores servem! Substitua o initializemétodo do modelo .

Use o after_initializemétodo

Sup galera, acabei fazendo o seguinte:

def after_initialize 
 self.extras||={}
 self.other_stuff||="This stuff"
end

Funciona como um encanto!

Isso foi respondido por um longo tempo, mas preciso dos valores padrão com frequência e prefiro não colocá-los no banco de dados. Eu crio uma DefaultValuespreocupação:

module DefaultValues
  extend ActiveSupport::Concern

  class_methods do
    def defaults(attr, to: nil, on: :initialize)
      method_name = "set_default_#{attr}"
      send "after_#{on}", method_name.to_sym

      define_method(method_name) do
        if send(attr)
          send(attr)
        else
          value = to.is_a?(Proc) ? to.call : to
          send("#{attr}=", value)
        end
      end

      private method_name
    end
  end
end

E depois usá-lo nos meus modelos da seguinte forma:

class Widget < ApplicationRecord
  include DefaultValues

  defaults :category, to: 'uncategorized'
  defaults :token, to: -> { SecureRandom.uuid }
end

Também vi pessoas colocarem isso em sua migração, mas prefiro vê-lo definido no código do modelo.

Existe uma maneira canônica de definir o valor padrão para os campos no modelo ActiveRecord?

O caminho canônico do Rails, antes do Rails 5, era realmente configurá-lo na migração e apenas olhar no db/schema.rb sempre que desejar ver quais valores padrão estão sendo definidos pelo DB para qualquer modelo.

Ao contrário do que afirma a resposta de @Jeff Perrin (que é um pouco antiga), a abordagem de migração aplicará o padrão ao usar Model.new , devido a alguma mágica do Rails. Trabalho verificado no Rails 4.1.16.

A coisa mais simples é geralmente a melhor. Menos dívida de conhecimento e possíveis pontos de confusão na base de código. E 'simplesmente funciona'.

class AddStatusToItem < ActiveRecord::Migration
  def change
    add_column :items, :scheduler_type, :string, { null: false, default: "hotseat" }
  end
end

Ou, para alterar a coluna sem criar uma nova, faça o seguinte:

class AddStatusToItem < ActiveRecord::Migration
  def change
    change_column_default :items, :scheduler_type, "hotseat"
  end
end

Ou talvez até melhor:

class AddStatusToItem < ActiveRecord::Migration
  def change
    change_column :items, :scheduler_type, :string, default: "hotseat"
  end
end

Consulte o guia oficial do RoR para obter opções nos métodos de alteração de coluna.

o null: false desaprova valores NULL no banco de dados e, como um benefício adicionado, também é atualizado para que todos os registros de banco de dados preexistentes anteriormente nulos sejam definidos com o valor padrão também para este campo. Você pode excluir esse parâmetro na migração, se desejar, mas achei muito útil!

A maneira canônica no Rails 5+ é, como @Lucas Caton disse:

class Item < ActiveRecord::Base
  attribute :scheduler_type, :string, default: 'hotseat'
end

O problema com as soluções after_initialize é que você precisa adicionar um after_initialize a todos os objetos que você procura do banco de dados, independentemente de acessar ou não esse atributo. Sugiro uma abordagem preguiçosa.

Os métodos de atributo (getters) são obviamente métodos próprios, portanto você pode substituí-los e fornecer um padrão. Algo como:

Class Foo < ActiveRecord::Base
  # has a DB column/field atttribute called 'status'
  def status
    (val = read_attribute(:status)).nil? ? 'ACTIVE' : val
  end
end

A menos que, como alguém apontou, você precise executar Foo.find_by_status ('ACTIVE'). Nesse caso, acho que você realmente precisará definir o padrão nas restrições de seu banco de dados, se o banco de dados o suportar.

Corri para problemas com after_initializedando ActiveModel::MissingAttributeErrorerros ao fazer descobertas complexas:

por exemplo:

@bottles = Bottle.includes(:supplier, :substance).where(search).order("suppliers.name ASC").paginate(:page => page_no)

"search" no .wherehash de condições

Então, acabei fazendo isso substituindo a inicialização desta maneira:

def initialize
  super
  default_values
end

private
 def default_values
     self.date_received ||= Date.current
 end

A superchamada é necessária para garantir que o objeto seja inicializado corretamente ActiveRecord::Baseantes de executar meu código de personalização, ou seja: default_values

class Item < ActiveRecord::Base
  def status
    self[:status] or ACTIVE
  end

  before_save{ self.status ||= ACTIVE }
end

Embora fazer isso para definir valores padrão seja confuso e complicado na maioria dos casos, você também pode usá-lo :default_scope. Confira o comentário do squil aqui .

O método after_initialize foi descontinuado, use o retorno de chamada.

after_initialize :defaults

def defaults
  self.extras||={}
  self.other_stuff||="This stuff"
end

no entanto, usar : default em suas migrações ainda é a maneira mais limpa.

Descobri que o uso de um método de validação fornece muito controle sobre a configuração de padrões. Você pode até definir padrões (ou falhar na validação) para atualizações. Você ainda define um valor padrão diferente para inserções versus atualizações, se realmente quiser. Observe que o padrão não será definido até #valid? é chamado.

class MyModel
  validate :init_defaults

  private
  def init_defaults
    if new_record?
      self.some_int ||= 1
    elsif some_int.nil?
      errors.add(:some_int, "can't be blank on update")
    end
  end
end

Em relação à definição de um método after_initialize, pode haver problemas de desempenho porque o after_initialize também é chamado por cada objeto retornado por: find: http://guides.rubyonrails.org/active_record_validations_callbacks.html#after_initialize-and-after_find

Se a coluna for do tipo 'status' e seu modelo se presta ao uso de máquinas de estado, considere usar a gema aasm , após a qual você pode simplesmente fazer

  aasm column: "status" do
    state :available, initial: true
    state :used
    # transitions
  end

Ele ainda não inicializa o valor para registros não salvos, mas é um pouco mais limpo do que criar o seu próprio initou qualquer outra coisa, e você colhe os outros benefícios do aasm, como escopos para todos os seus status.

https://github.com/keithrowell/rails_default_value

class Task < ActiveRecord::Base
  default :status => 'active'
end

Eu sugiro fortemente o uso da gema "default_value_for": https://github.com/FooBarWidget/default_value_for

Existem alguns cenários complicados que praticamente exigem a substituição do método de inicialização, o que essa gema exige.

Exemplos:

Seu padrão de banco de dados é NULL, seu modelo / padrão definido em ruby ​​é "alguma string", mas você realmente deseja definir o valor como nulo por qualquer motivo:MyModel.new(my_attr: nil)

A maioria das soluções aqui falhará em definir o valor como nulo e, em vez disso, o definirá como o padrão.

OK, então, em vez de usar a ||=abordagem, você muda para my_attr_changed?...

Mas agora imagine que o padrão do banco de dados é "alguma string", o padrão definido pelo modelo / ruby ​​é "alguma outra string", mas em um determinado cenário, você deseja definir o valor como "alguma string" (o padrão do banco de dados):MyModel.new(my_attr: 'some_string')

Isto irá resultar em my_attr_changed?ser falsa porque o valor corresponde ao db padrão, que por sua vez irá disparar seu código padrão definido pelo rubi e defina o valor para "alguma outra string" - mais uma vez, não o que você desejar.

Por esses motivos, não acho que isso possa ser realizado adequadamente com apenas um gancho after_initialize.

Mais uma vez, acho que a gema "default_value_for" está adotando a abordagem correta: https://github.com/FooBarWidget/default_value_for

Aqui está uma solução que eu usei que fiquei um pouco surpresa ainda não foi adicionada.

Existem duas partes nele. A primeira parte é definir o padrão na migração real e a segunda parte é adicionar uma validação no modelo, garantindo que a presença seja verdadeira.

add_column :teams, :new_team_signature, :string, default: 'Welcome to the Team'

Então você verá aqui que o padrão já está definido. Agora, na validação, você deseja garantir que sempre haja um valor para a sequência, então faça

 validates :new_team_signature, presence: true

O que isso fará é definir o valor padrão para você. (para mim eu tenho "Bem-vindo à equipe"), e depois darei um passo adiante e garantirá que sempre exista um valor presente para esse objeto.

Espero que ajude!

# db/schema.rb
create_table :store_listings, force: true do |t|
  t.string :my_string, default: "original default"
end

StoreListing.new.my_string # => "original default"

# app/models/store_listing.rb
class StoreListing < ActiveRecord::Base
  attribute :my_string, :string, default: "new default"
end

StoreListing.new.my_string # => "new default"

class Product < ActiveRecord::Base
  attribute :my_default_proc, :datetime, default: -> { Time.now }
end

Product.new.my_default_proc # => 2015-05-30 11:04:48 -0600
sleep 1
Product.new.my_default_proc # => 2015-05-30 11:04:49 -0600

use default_scope nos trilhos 3

api doc

O ActiveRecord obscurece a diferença entre o padrão definido no banco de dados (esquema) e o padrão feito no aplicativo (modelo). Durante a inicialização, ele analisa o esquema do banco de dados e anota quaisquer valores padrão especificados lá. Mais tarde, ao criar objetos, ele atribui esses valores padrão especificados no esquema sem tocar no banco de dados.

discussão

Nos documentos da API http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html Use o before_validationmétodo em seu modelo, ele oferece as opções de criação de inicialização específica para chamadas de criação e atualização, por exemplo, neste exemplo (novamente código usado do exemplo da API api), o campo numérico é inicializado para um cartão de crédito. Você pode facilmente adaptar isso para definir os valores desejados

class CreditCard < ActiveRecord::Base
  # Strip everything but digits, so the user can specify "555 234 34" or
  # "5552-3434" or both will mean "55523434"
  before_validation(:on => :create) do
    self.number = number.gsub(%r[^0-9]/, "") if attribute_present?("number")
  end
end

class Subscription < ActiveRecord::Base
  before_create :record_signup

  private
    def record_signup
      self.signed_up_on = Date.today
    end
end

class Firm < ActiveRecord::Base
  # Destroys the associated clients and people when the firm is destroyed
  before_destroy { |record| Person.destroy_all "firm_id = #{record.id}"   }
  before_destroy { |record| Client.destroy_all "client_of = #{record.id}" }
end

Surpreso que o dele não tenha sido sugerido aqui