One neat feature of Rails’ ActiveRecord objects is the #serialize method which will allow you to store an object in the database as YAML. This means, for example, you could have a User and a Profile. The Profile could be a hash containing a bunch of values that you want to manage, but that don’t necessarily need their own database table.


  class User < ActiveRecord::Base
  
    serialize :profile
  end
 
  u = User.find 1
  u.profile = {"url" => "http://www.rubyonrails.com", :nickname =>"Ninja master"}
  u.save
 
  u = User.find 1
  u.profile.class
  => Hash
 


The magic of the #serialize method takes the given object, serializes it to YAML, stores the YAML in the database, and then unserializes it when you retrieve the data.

This is all well and good, and I thought I would take advantage of this to help me easily cache some data. I have a system in which I have tasks, and a task belongs to a Service which contains the rate we charge for the task. Now, I really want to be able to store the service name and rate on the task when it’s assigned so that the task won’t be affected when I change my rates in the future.

“Aha!” I thought,”I can just use serialize and store the Service object right on the task!” I created a migration that added a service_data field to my database


./script/generate migration AddServiceDataToTasks



 
class AddServiceDataToTasks< ActiveRecord::Migration
  def self.up
    add_column :tasks, :service_data, :text
  end
 
  def self.down
    remove_column :tasks, :service_data
  end
end
 


I wrote a quick unit test which I knew would come in handy later.


   def test_saves_service_when_task_is_created
      @service = Service.find_by_name "Rails development"
      task = Task.create :name=>"Create user registration site", :esthours => 5, :service => @service
      t = Task.find task.id
      assert_not_nil t.service_data
      assert_kind_of Service, t.service_data
  
   end


Then I modified my Task model


  class Task < ActiveRecord::Base
    belongs_to :service
    serialize :service_data
 
    after_create  :sync_service_data!
  
    def sync_service_data!
       self.service_data = self.service
       self.save!
    end
  end


That seemed simple enough. However, when I tried it, I got a nasty surprise…


 
  t = Task.find 1
  t.service_data
  => nil
 


No matter what i tried, the service data always came back empty.

Running my unit test proved that something was definitely wrong, as I kept seeing “nil expected to not be nil”.

After searching and playing, I decided that #serialize was just not capable of serializing ActiveRecord objects. To get around this, I simply changed my code slightly. I knew that #serialize can handle Hashes so I stored just the attributes hash. Then I redefined #service_data “getter” method to create a new instance of Service from that hash.


  class Task < ActiveRecord::Base
    belongs_to :service
    serialize :service_data
 
    def sync_service_data!
       self.service_data = self.service.attributes
       self.save!
    end
 
    def service_data
      Service.new(self.attributes["service_data"]
    end
end


A quick run of the tests showed that I was now getting what I wanted.

Shortly after I discovered this solution, Jon Garvin offered a much cleaner solution…. don’t use Serialize. He found that Serialize does some strange magical things that often get in the way of our intended results. He proposed that I try

  class Task < ActiveRecord::Base
    belongs_to :service
 
    after_create  :sync_service_data!
  
    def sync_service_data!
       self.service_data = self.service
       self.save!
    end
 
    def service_data
     self[:service_data] ? Marshal.load(self[:service_data]) : nil
    end
 
    def service_data=(service)
      self[:service_data] = Marshal.dump(service)
    end
 
  end


This method simply creates a setter that manually marshals the data to the database column, and a getter that retrieves it again. This method works great, and I thank Jon for his quick solution!