Acts As Fast But Very Inaccurate Counter

Introduction

If you have chosen the InnoDB MySQL engine over MyISAM for its support of transactions, foreign keys and other niceties, you might be aware of its limitations, like much slower count(*). Our DBAs are in a constant lookout for slow queries in production and the ways to keep DBs happy so they recommended that we should try to fix count(). They suggested to check SHOW TABLE STATUS for an approximate count of rows in a table. This morning I wrote acts_as_fast_counter which proved that the speed is indeed improved but the accuracy might be not acceptable. The rest of the post just records details of the exercise.

The approach

I created a model per engine and seeded each with 100K records. Then I run count on each model for a thousand times and measured the results.

The code:

module ActiveRecord; module Acts; end; end 

module ActiveRecord::Acts::ActsAsFastCounter
  
  def self.included(base)
    base.extend(ClassMethods)
  end
  
  module ClassMethods
    
    def acts_as_fast_counter
      self.extend(FastCounterOverrides)
    end
    
    module FastCounterOverrides
      
      def count(*args)
        if args.empty?
          connection.select_one("SHOW TABLE STATUS LIKE '#{ table_name }'")['Rows'].to_i
        else
          super(*args)
        end
      end

    end
    
  end
  
end

ActiveRecord::Base.send(:include, ActiveRecord::Acts::ActsAsFastCounter)

# create_table :myisams, :options => 'engine=MyISAM'  do |t|
#   t.column :name, :string
# end
# 100_000.times { Myisam.create(:name => Time.now.to_s) }
# 
# create_table :innodbs, :options => 'engine=InnoDB' do |t|
#   t.column :name, :string
# end
# 100_000.times { Innodb.create(:name => Time.now.to_s) }

class Bench
  
  require 'benchmark'
  require 'acts_as_fast_counter'

  def self.run
    measure
    show_count
    convert_to_fast_counter
    show_count
    add_records
    show_count
    destroy_records
    show_count
    measure
  end

  def self.measure
    puts "* Benchhmarks:"
    n = 1_000
    Benchmark.bm(12) do |x|
      x.report('MyISAM') { n.times { Myisam.count } }
      x.report('InnoDB') { n.times { Innodb.count } }
    end
  end
  
  def self.convert_to_fast_counter
    Innodb.send(:acts_as_fast_counter)
    puts "* Converted Innodb to fast counter"
  end
  
  def self.add_records
    @myisam = Myisam.create(:name => 'One more')
    @innodb = Innodb.create(:name => 'One more')
    puts "* Added records"
  end
    
  def self.destroy_records
    @myisam.destroy
    @innodb.destroy
    puts "* Destroyed records"
  end
  
  def self.show_count
    puts "* Record count:"
    puts "    MyISAM: #{ Myisam.count }"
    puts "    InnoDB: #{ Innodb.count }"
  end
  
end

The results:

* Benchhmarks:
                  user     system      total        real
MyISAM        0.180000   0.040000   0.220000 (  0.289983)
InnoDB        0.430000   0.070000   0.500000 ( 35.102496)
* Record count:
    MyISAM: 100000
    InnoDB: 100000
* Converted Innodb to fast counter
* Record count:
    MyISAM: 100000
    InnoDB: 100345
* Added records
* Record count:
    MyISAM: 100001
    InnoDB: 100345
* Destroyed records
* Record count:
    MyISAM: 100000
    InnoDB: 100345
* Benchhmarks:
                  user     system      total        real
MyISAM        0.250000   0.030000   0.280000 (  0.350673)
InnoDB        0.250000   0.040000   0.290000 (  0.977711)

Final thoughts

The MySQL manual has a clear warning about inaccuracy of the amount of rows in the SHOW TABLE STATUS results:

Rows - The number of rows. Some storage engines, such as MyISAM, store the exact count. For other storage engines, such as InnoDB, this value is an approximation, and may vary from the actual value by as much as 40 to 50%. In such cases, use SELECT COUNT(*) to obtain an accurate count.

The test confirms it by showing 345 more records then expected thus making it not very useful but for some edge cases. If you know a way to improve the speed of count() on InnoDB with some other approach beyond using a counter table, please share.

Plugin I Cannot Live Without

The Enhanced Rails Migrations plugin was written to end the constant battle we had with clashing names in db migrations within our large development team. We tried everything: special commit policies, rake tasks, even claiming the next migration number in subversion. Nothing worked and CI server was sending 'broken build due to conflicting migration number' messages almost daily. Since the plugin was introduced to all our rails applications around six months ago, I have not heard of a single case of conflicting migrations. Seemingly, the goal was well accomplished.

What I found over time, is that the plugin is not only useful for large projects. Any rails development effort with more than one programmer involved benefits from using it. If you ever had to renumber your new migration after doing svn up you know what I am talking about. It makes sense to install this plugin as the very first one in your project since an amount of migrations at the beginning tends to grow much faster then later in the game.

The plugin works for rails versions 1.1.6 up to the latest edge. When you start your next project with multiple developers, use it and you should be able to forget that you ever had problems with clashing migrations.

Moving models to a different database

There many reasons to use multiple databases (DBs) and when this is done, there is often a case when a model needs to be moved from one DB to another. The impetus could be that part of the data is referential and this is being reflected by moving it to a read-only DB. Another possibility is that we want to protect some data with an additional layer of security, so we extract it to a secure DB. In all cases, the challenge is to migrate the existing data. When the amount of data is considerably large, there is no choice but to do it via SQL data loaders or similar techniques. On the other hand, if it is acceptable to leverage rails db migrations and you prefer to do any data manipulation through them, there are some challenges to face.

Often, you need to have an access to old and new models during data migration. One solution is to move or copy an existing model to a separate namespace and put the new model instead at the old namespace. Let's look at a couple of examples:


Extracting referential data

I have a model Fruit in our main DB which gets its data from an external source, so we only access it read-only. We want to enforce it by moving the data to a DB which we access with a read-only account. First, I create a referential_db entry in database.yml:

dbs:
  database: main

  referential_db:
    database: referential

Then, I copy the original model, Fruit, to a dedicated namespace, so the model becomes RetiredModels::Fruit. I add establish_connection to the original namespace model:

# create_table :fruits do |t|
#   t.column :name, :string
# end
class Fruit < ActiveRecord::Base
  establish_connection configurations[RAILS_ENV]['referential_db']  
end

Everything is set for migration. Since it is a referential data, the migration needs to preserve data integrity so the models belonging to Fruit can still reference it by an old id:

def self.up
  RetiredModels::Fruit.find(:all).each do |old_record|
    Fruit.new(old_record.attributes) { |new_record| new_record.id = old_record.id }.save!
  end
end

After the successful migration run, all data is replicated to a new DB. The retired model can be removed during next deployment, and the original table dropped.

There is one caveat for development and test modes. If you don't want to bother with multiple databases in those modes, you need to take care of having no table name clashing. So, the new model would have to use different table names via set_table_name.


Securing sensitive data

One of the models belonging to Fruit is SecretFruit. It contains a secret name for every fruit out there. Our legal department asked the development team to protect that data in case our DB is stolen. We decided to migrate the existing SecretFruit data to a protected DB and keep sensitive data encrypted with help from Acts As Secure. First, I create a secure_db entry in database.yml:

dbs:
  database: main

  secure_db:
    database: secure
    host: protected_host

Then, I copy the original model, SecretFruit, to a dedicated namespace, so the model becomes RetiredModels::SecretFruit. I modify the model in the original namespace to reflect the new requirements:

# create_table :secret_fruits do |t|
#   t.column :name, :binary
#   t.column :fruit_id, :integer
# end
class SecretFruit < ActiveRecord::Base
  establish_connection configurations[RAILS_ENV]['secure_db']
  acts_as_secure :crypto_provider => MasterKeyProvider
  belongs_to :fruit
end

Since data encryption is done on-the-fly and there are no data integrity requirements, the migration is straightforward:

def self.up
  RetiredModels::SecretFruit.find(:all).each { |old| SecretFruit.create!(old.attributes) }
end

I can now safely delete RetiredModels::SecretFruit and associated data.