Question

I have this object:

class MessageSetting
  include Mongoid::Document
  include Mongoid::Timestamps::Created

  #relationships
  embedded_in :user
  field :when_new_order, :type => Boolean, :default => "true"
  field :when_cancel_order, :type => Boolean, :default => "true"
  field :when_expire_order, :type => Boolean, :default => "true"
  field :when_reject_order, :type => Boolean, :default => "true"
  field :when_accept_order, :type => Boolean, :default => "true"
  field :when_in_progress_overtime, :type => Boolean, :default => "true"
  field :when_is_canceled_due_overtime, :type => Boolean, :default => "true"
  field :when_deliver_order, :type => Boolean, :default => "true"
  field :when_order_complete, :type => Boolean, :default => "true"
  field :when_open_dispute, :type => Boolean, :default => "true"
  field :when_buyer_request_refund, :type => Boolean, :default => "true"
  field :when_seller_made_refund, :type => Boolean, :default => "true"
  field :when_seller_made_dispute_response, :type => Boolean, :default => "true"
  field :when_buyer_made_dispute_response, :type => Boolean, :default => "true"

  attr_accessible :when_new_order, :when_cancel_order, :when_expire_order, :when_reject_order,
                  :when_accept_order, :when_in_progress_overtime, :when_is_canceled_due_overtime,
                  :when_deliver_order, :when_deliver_order, :when_order_complete, :when_open_dispute,
                  :when_buyer_request_refund, :when_seller_made_refund, :when_seller_made_dispute_response, :when_buyer_made_dispute_response

  def active_new_order?
   when_new_order?
  end

  def active_when_cancel_order?
   when_cancel_order?
  end

  def active_when_expire_order?
   when_expire_order?
  end

  def active_when_reject_order?
   when_reject_order?
  end

  def active_when_accept_order?
   when_accept_order?
  end

  def active_when_in_progress_overtime?
   when_in_progress_overtime?
  end

  def active_when_is_canceled_due_overtime?
   when_is_canceled_due_overtime?
  end

  def active_when_deliver_order?
   when_deliver_order?
  end

  def active_when_order_complete?
   when_order_complete?
  end

  def active_when_open_dispute?
   when_open_dispute?
  end

  def active_when_buyer_request_refund?
   when_buyer_request_refund?
  end

  def active_when_seller_made_refund?
   when_seller_made_refund?
  end

  def active_when_seller_made_dispute_response?
   when_seller_made_dispute_response?
  end

  def active_when_buyer_made_dispute_response?
   when_buyer_made_dispute_response?
  end

end

I know that I can make “serialize” with mongoid with:

field :status_message_setting, type: Hash

then I can:

m = MessageSetting.new
m.status_message_setting = {:when_new_order => true, :when_cancel_order => false, ...}
m.save

I need to know referring to performance, best practices and resources available, it is better to “serialize” with a hash this model?

Answer 1

Not all Ruby classes can be serialized out of the box, but lucky for you, Hashes are one of the classes that can be. Therefore there is no reason to write your own serialization for them. But if you do and there is an increase in speed, it will be minimal. Serialization is used primarily for persisting fields with custom datatypes.

It wouldn’t speed up your database, but if you really wanted to save space, you could create a custom type for an all-boolean hash and serialize your hash into bitcode. You would create the custom class and define a mongoize instance method, and mongoize,demongoize, and evolve class methods according to how you want to serialize the data. Yes, this is definatly possible. In practice however, it’s a hassle to implement and wouldn’t save you that much space unless your hashes are huge compared to the rest of the data in the model.

For your situation, a much easier way to save space would be to shorten all your field names like this:

field :wno, as: :when_new_order, :type => Boolean, :default => "true"
field :wco, as: :when_cancel_order, :type => Boolean, :default => "true" ...

Since the field name is repeated in the database for every document that is stored, long field names will begin to take up a lot of extra space. Since you pass an alias, e.g. :when_new_order, then your model will act exactly like it did before.