each_batched 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 David Burry
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,88 @@
+= EachBatched
+
+More grouping/batching logic options than what's included in Rails.
+
+Ever since Rails 2.3, it has had ActiveRecord::Batches#find_in_batches[http://api.rubyonrails.org/classes/ActiveRecord/Batches.html#method-i-find_in_batches] (and its cousin ActiveRecord::Batches#find_each[http://api.rubyonrails.org/classes/ActiveRecord/Batches.html#method-i-find_each]) as a great resource saver, because it allowed you to run through larger data sets in batches, instead of loading everything under the sun into memory first.
+
+But it has some gotchas.  First, the algorithm it uses tries to keep from messing up during concurrent inserts/deletes, during the loop.  This is a good thing, except it does it by fixing the order to an id order, then grabbing each successive batch (with limit) that's greater than your last primary key id.  So there's no way to limit it to a subset of your data, and there's no way to order anything any differently than by primary key id order.  This can be rather limiting sometimes.  Also it uses finders in kind of an old fashioned way compared to Rails 3... instead of scopes.
+
+So this library attempts to address these, by providing two additional algorithms you can choose from, depending on your needs.
+
+== Dependencies
+
+* Ruby 1.9.2 - does not support Ruby 1.8!
+* Rails 3.x - does not support Rails 2!
+
+== Features
+
+* Saves memory by not needing to load all records into memory at once, just one batch at a time, looping over them all.
+* You can specify an order for your results, using the standard Rails 3 arel/scoped way.
+* You can specify an offset and/or limit to only grab some results, using the standard Rails 3 arel/scoped way.
+* Two different algorithms provided, to fit your different needs.
+* Includes variants that yields groups (each as a scope), or yields individual rows, depending on your needs.
+
+== Installation
+
+Add to your <tt>Gemfile</tt>:
+
+ # Gemfile
+ 
+ gem 'each_batched'
+
+and run:
+
+ $ bundle install
+
+== Usage
+
+First, let's explain the "range" algorithm:
+* It simply uses offset/limit internally to run through each batch.
+* Simple obvious approach, few queries.
+* Could work on primary-key-less data.
+* Does NOT work well with data that could have inserts/deletes while you're looping (it might miss or duplicate random rows at the boundaries of batches)!  So it should only be used on data that you are sure will not change (such as locked data, or static data, etc).
+
+ YourModel.each_by_ranges do |record|
+   # Do something with this model record
+ end
+ YourModel.batches_by_ranges do |batch|
+   # Do something with this batch
+   # It's a standard model scope that's already been loaded
+   # and can act like an array of records
+ end
+
+Next, the "ids" algorithm:
+* Grabs a list of all selected primary keys in one query, then loops through them all, grabbing the row data in batches.
+* Works with simultaneously changing data nicely (might miss added/deleted rows themselves of course).
+* For complicated queries, it could be faster than other approaches too.
+* May generate really long queries if you're doing a lot of rows in each batch.
+
+ YourModel.each_by_ids do |record|
+   # Do something with this model record
+ end
+ YourModel.batches_by_ids do |batch|
+   # Do something with this batch
+   # It's a standard model scope that has NOT been lazy loaded yet
+   # but will be as soon as you access its records
+ end
+
+All the above can take an optional parameter: the size of the batch to use (defaults to 1000).
+
+== Contributing
+
+If you think you found a bug or want a feature, get involved at http://github.com/dburry/each_batched/issues  If you'd then like to contribute a patch, use Github's wonderful fork and pull request features.
+
+To set up a full development environment:
+* <tt>git clone</tt> the repository,
+* have RVM[https://rvm.beginrescueend.com/] and Bundler[http://gembundler.com/] installed,
+* then cd into your repo (follow any RVM prompts if this is your first time using that),
+* and run <tt>bundle install</tt> to pull in all the rest of the development dependencies.
+* After that point, <tt>rake -T</tt> should be fairly self-explanatory.
+
+== Alternatives
+
+* ActiveRecord::Batches#find_in_batches[http://api.rubyonrails.org/classes/ActiveRecord/Batches.html#method-i-find_in_batches] and
+* ActiveRecord::Batches#find_each[http://api.rubyonrails.org/classes/ActiveRecord/Batches.html#method-i-find_each] built into rails 2.3 and above.
+
+== License
+
+This library is distributed under the MIT license. Please see the LICENSE file.

data/Rakefile

@@ -0,0 +1,55 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'EachBatched'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+begin
+  require 'simplecov'
+rescue LoadError
+  puts 'WARNING: missing simplecov library, some tasks are not available'
+else
+  desc 'Analyze code coverage with tests'
+  task :coverage => 'coverage:clobber' do
+    ENV['USE_SIMPLECOV'] = :true.to_s
+    Rake::Task['test'].invoke
+    # see top of test helper for the rest of this task, which is triggered with the environment var....
+  end
+  namespace :coverage do
+    desc 'Remove output directory generated by simplecov'
+    task :clobber do
+      FileUtils.rm_rf(File.expand_path('../coverage', __FILE__))
+    end
+  end
+end
+
+task :default => :test

data/lib/each_batched/version.rb

@@ -0,0 +1,3 @@
+module EachBatched
+  VERSION = "0.1.0"
+end

data/lib/each_batched.rb

@@ -0,0 +1,65 @@
+# 
+# More grouping/batching logic options than what's included in Rails.
+#
+
+module EachBatched
+  
+  # Default batch size to use, if none is specified (defaults to 1000)
+  DEFAULT_BATCH_SIZE = 1_000
+  
+  # Yields batches of records from the current scope.
+  # Uses offset/limit internally to run through each batch,
+  # and can be further restricted by in-scope offset/limit/order (it doesn't just toss them out!).
+  # 
+  # * This algorithm does NOT work well with data that may have inserts/deletes while you're looping,
+  #   so if that's a problem, then you should either lock the table or rows first or use a different algorithm
+  #   (like ActiveRecord::Batches#find_in_batches or #batches_by_ids).
+  # * This algorithm may be slower than #batches_by_ids if your query doesn't execute very quickly.
+  # * This algorithm can't be lazily loaded, because it checks for empty results to see when it's done.
+  def batches_by_range(batch_size=DEFAULT_BATCH_SIZE)
+    start_offset = scoped.offset_value || 0
+    end_limit = scoped.limit_value # || nil
+    group_number = 0
+    processed_number = 0
+    # This giant while condition (with multiple assignments in it) is a mess, isn't it!
+    # But simplifying it means I have to repeat most of it multiple times!
+    # And putting it into a subroutine doesn't really save space either, with lots of parameters and/or return values!
+    while (length = (records = offset(start_offset + batch_size * group_number).
+        limit(asked_limit = end_limit.nil? || processed_number + batch_size < end_limit ?
+          batch_size : end_limit - processed_number)).length) > 0
+      yield records
+      processed_number += length
+      break if length < asked_limit || (! end_limit.nil? && processed_number >= end_limit)
+      group_number += 1
+    end
+  end
+  
+  # Loops through each individual row found by #batches_by_range, instead of each batch
+  # see #batches_by_range for an explanation of its algorithm
+  def each_by_range(batch_size=DEFAULT_BATCH_SIZE)
+    batches_by_range(batch_size) { |batch| batch.each { |row| yield row } }
+  end
+  
+  # Yields batches of records from the current scope
+  # Snapshots the primary key ids in scope, then loops through grabbing the rows, one chunk of ids at a time.
+  # 
+  # * You should explicitly set an order if you want the same order as #batches_by_range, or it may be different.
+  # * The yielded scope can be lazily loaded (though the id selection query has already run obviously)
+  def batches_by_ids(batch_size=DEFAULT_BATCH_SIZE)
+    reduced_scope = scoped.tap { |s| s.where_values = [] }.offset(nil).limit(nil)
+    select("#{table_name}.#{primary_key}").collect(&(primary_key.to_sym)).in_groups_of(batch_size, false) do |group_ids|
+      # keeps select/group/joins/includes, inside inner batched scope
+      yield reduced_scope.where(primary_key => group_ids)
+    end
+  end
+  
+  # Loops through each individual row found by #batches_by_ids, instead of each batch
+  # see #batches_by_ids for an explanation of its algorithm
+  def each_by_ids(batch_size=DEFAULT_BATCH_SIZE)
+    batches_by_ids(batch_size) { |batch| batch.each { |row| yield row } }
+  end
+  
+end
+
+# add all this functionality to ActiveRecord for all models to use
+ActiveRecord::Base.extend EachBatched

data/lib/tasks/each_batched_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :each_batched do
+#   # Task goes here
+# end

data/test/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/test/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+end

data/test/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/test/dummy/app/models/company.rb

@@ -0,0 +1,7 @@
+
+class Company < ActiveRecord::Base
+  has_many :customers
+  has_many :products
+  has_many :customer_purchases, :through => :customers, :source => :purchases
+  has_many :purchased_products, :through => :customer_purchases, :source => :product, :uniq => true
+end

data/test/dummy/app/models/customer.rb

@@ -0,0 +1,6 @@
+
+class Customer < ActiveRecord::Base
+  belongs_to :company
+  has_many :purchases
+  has_many :purchased_products, :through => :purchases, :source => :products, :uniq => true
+end

data/test/dummy/app/models/product.rb

@@ -0,0 +1,5 @@
+
+class Product < ActiveRecord::Base
+  belongs_to :company
+  has_many :purchases
+end

data/test/dummy/app/models/purchase.rb

@@ -0,0 +1,5 @@
+
+class Purchase < ActiveRecord::Base
+  belongs_to :product
+  belongs_to :customer
+end

data/test/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+  <%= stylesheet_link_tag    "application" %>
+  <%= javascript_include_tag "application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/test/dummy/config/application.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../boot', __FILE__)
+
+require 'rails/all'
+
+Bundler.require
+require "each_batched"
+
+module Dummy
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Custom directories with classes and modules you want to be autoloadable.
+    # config.autoload_paths += %W(#{config.root}/extras)
+
+    # Only load the plugins named here, in the order given (default is alphabetical).
+    # :all can be used as a placeholder for all plugins not explicitly named.
+    # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
+
+    # Activate observers that should always be running.
+    # config.active_record.observers = :cacher, :garbage_collector, :forum_observer
+
+    # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
+    # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
+    # config.time_zone = 'Central Time (US & Canada)'
+
+    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
+    # config.i18n.default_locale = :de
+
+    # Configure the default encoding used in templates for Ruby 1.9.
+    config.encoding = "utf-8"
+
+    # Configure sensitive parameters which will be filtered from the log file.
+    config.filter_parameters += [:password]
+
+    # Enable the asset pipeline
+    config.assets.enabled = false
+
+    # Version of your assets, change this if you want to expire all your assets
+    config.assets.version = '1.0'
+  end
+end
+

data/test/dummy/config/boot.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+gemfile = File.expand_path('../../../../Gemfile', __FILE__)
+
+if File.exist?(gemfile)
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  require 'bundler'
+  Bundler.setup
+end
+
+$:.unshift File.expand_path('../../../../lib', __FILE__)

data/test/dummy/config/database.yml

@@ -0,0 +1,25 @@
+# SQLite version 3.x
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem 'sqlite3'
+development:
+  adapter: sqlite3
+  database: db/development.sqlite3
+  pool: 5
+  timeout: 5000
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  adapter: sqlite3
+  database: db/test.sqlite3
+  pool: 5
+  timeout: 5000
+
+production:
+  adapter: sqlite3
+  database: db/production.sqlite3
+  pool: 5
+  timeout: 5000

data/test/dummy/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the rails application
+require File.expand_path('../application', __FILE__)
+
+# Initialize the rails application
+Dummy::Application.initialize!

data/test/dummy/config/environments/development.rb

@@ -0,0 +1,30 @@
+Dummy::Application.configure do
+  # Settings specified here will take precedence over those in config/application.rb
+
+  # In the development environment your application's code is reloaded on
+  # every request.  This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.cache_classes = false
+
+  # Log error messages when you accidentally call methods on nil.
+  config.whiny_nils = true
+
+  # Show full error reports and disable caching
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+
+  # Don't care if the mailer can't send
+  config.action_mailer.raise_delivery_errors = false
+
+  # Print deprecation notices to the Rails logger
+  config.active_support.deprecation = :log
+
+  # Only use best-standards-support built into browsers
+  config.action_dispatch.best_standards_support = :builtin
+
+  # Do not compress assets
+  config.assets.compress = false
+
+  # Expands the lines which load the assets
+  config.assets.debug = true
+end

data/test/dummy/config/environments/production.rb

@@ -0,0 +1,60 @@
+Dummy::Application.configure do
+  # Settings specified here will take precedence over those in config/application.rb
+
+  # Code is not reloaded between requests
+  config.cache_classes = true
+
+  # Full error reports are disabled and caching is turned on
+  config.consider_all_requests_local       = false
+  config.action_controller.perform_caching = true
+
+  # Disable Rails's static asset server (Apache or nginx will already do this)
+  config.serve_static_assets = false
+
+  # Compress JavaScripts and CSS
+  config.assets.compress = true
+
+  # Don't fallback to assets pipeline if a precompiled asset is missed
+  config.assets.compile = false
+
+  # Generate digests for assets URLs
+  config.assets.digest = true
+
+  # Defaults to Rails.root.join("public/assets")
+  # config.assets.manifest = YOUR_PATH
+
+  # Specifies the header that your server uses for sending files
+  # config.action_dispatch.x_sendfile_header = "X-Sendfile" # for apache
+  # config.action_dispatch.x_sendfile_header = 'X-Accel-Redirect' # for nginx
+
+  # Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
+  # config.force_ssl = true
+
+  # See everything in the log (default is :info)
+  # config.log_level = :debug
+
+  # Use a different logger for distributed setups
+  # config.logger = SyslogLogger.new
+
+  # Use a different cache store in production
+  # config.cache_store = :mem_cache_store
+
+  # Enable serving of images, stylesheets, and JavaScripts from an asset server
+  # config.action_controller.asset_host = "http://assets.example.com"
+
+  # Precompile additional assets (application.js, application.css, and all non-JS/CSS are already added)
+  # config.assets.precompile += %w( search.js )
+
+  # Disable delivery errors, bad email addresses will be ignored
+  # config.action_mailer.raise_delivery_errors = false
+
+  # Enable threaded mode
+  # config.threadsafe!
+
+  # Enable locale fallbacks for I18n (makes lookups for any locale fall back to
+  # the I18n.default_locale when a translation can not be found)
+  config.i18n.fallbacks = true
+
+  # Send deprecation notices to registered listeners
+  config.active_support.deprecation = :notify
+end

data/test/dummy/config/environments/test.rb

@@ -0,0 +1,42 @@
+Dummy::Application.configure do
+  # Settings specified here will take precedence over those in config/application.rb
+
+  # The test environment is used exclusively to run your application's
+  # test suite.  You never need to work with it otherwise.  Remember that
+  # your test database is "scratch space" for the test suite and is wiped
+  # and recreated between test runs.  Don't rely on the data there!
+  config.cache_classes = true
+
+  # Configure static asset server for tests with Cache-Control for performance
+  config.serve_static_assets = true
+  config.static_cache_control = "public, max-age=3600"
+
+  # Log error messages when you accidentally call methods on nil
+  config.whiny_nils = true
+
+  # Show full error reports and disable caching
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+
+  # Raise exceptions instead of rendering exception templates
+  config.action_dispatch.show_exceptions = false
+
+  # Disable request forgery protection in test environment
+  config.action_controller.allow_forgery_protection    = false
+
+  # Tell Action Mailer not to deliver emails to the real world.
+  # The :test delivery method accumulates sent emails in the
+  # ActionMailer::Base.deliveries array.
+  config.action_mailer.delivery_method = :test
+
+  # Use SQL instead of Active Record's schema dumper when creating the test database.
+  # This is necessary if your schema can't be completely dumped by the schema dumper,
+  # like if you have constraints or database-specific column types
+  # config.active_record.schema_format = :sql
+
+  # Print deprecation notices to the stderr
+  config.active_support.deprecation = :stderr
+
+  # Allow pass debug_assets=true as a query parameter to load pages with unpackaged assets
+  config.assets.allow_debugging = true
+end

data/test/dummy/config/initializers/backtrace_silencers.rb

@@ -0,0 +1,7 @@
+# Be sure to restart your server when you modify this file.
+
+# You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
+# Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }
+
+# You can also remove all the silencers if you're trying to debug a problem that might stem from framework code.
+# Rails.backtrace_cleaner.remove_silencers!

data/test/dummy/config/initializers/inflections.rb

@@ -0,0 +1,10 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format
+# (all these examples are active by default):
+# ActiveSupport::Inflector.inflections do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end

data/test/dummy/config/initializers/mime_types.rb

@@ -0,0 +1,5 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new mime types for use in respond_to blocks:
+# Mime::Type.register "text/richtext", :rtf
+# Mime::Type.register_alias "text/html", :iphone

data/test/dummy/config/initializers/secret_token.rb

@@ -0,0 +1,7 @@
+# Be sure to restart your server when you modify this file.
+
+# Your secret key for verifying the integrity of signed cookies.
+# If you change this key, all old signed cookies will become invalid!
+# Make sure the secret is at least 30 characters and all random,
+# no regular words or you'll be exposed to dictionary attacks.
+Dummy::Application.config.secret_token = '34350caf6c17053a9b555856c85a7b3b9da91bc35d6f3362621232d0b18621fd01f1f1cbdac374dc9d8d9425fe50ab82b4069fe4b3b6fefd1832a94a4dffc117'

data/test/dummy/config/initializers/session_store.rb

@@ -0,0 +1,8 @@
+# Be sure to restart your server when you modify this file.
+
+Dummy::Application.config.session_store :cookie_store, key: '_dummy_session'
+
+# Use the database for sessions instead of the cookie-based default,
+# which shouldn't be used to store highly confidential information
+# (create the session table with "rails generate session_migration")
+# Dummy::Application.config.session_store :active_record_store

data/test/dummy/config/locales/en.yml

@@ -0,0 +1,5 @@
+# Sample localization file for English. Add more files in this directory for other locales.
+# See https://github.com/svenfuchs/rails-i18n/tree/master/rails%2Flocale for starting points.
+
+en:
+  hello: "Hello world"

data/test/dummy/config/routes.rb

@@ -0,0 +1,2 @@
+Dummy::Application.routes.draw do
+end

data/test/dummy/config.ru

@@ -0,0 +1,4 @@
+# This file is used by Rack-based servers to start the application.
+
+require ::File.expand_path('../config/environment',  __FILE__)
+run Dummy::Application

data/test/dummy/db/migrate/0001_initialize_models.rb

@@ -0,0 +1,36 @@
+
+class InitializeModels < ActiveRecord::Migration
+  def self.up
+    create_table :companies do |t|
+      t.integer    :sort,       :null => false, :default => 0
+    end
+    create_table :customers do |t|
+      t.integer    :sort ,      :null => false, :default => 0
+      t.references :company,    :null => false
+    end
+    create_table :products do |t|
+      t.integer    :sort,       :null => false, :default => 0
+      t.references :company,    :null => false
+    end
+    create_table :purchases do |t|
+      t.date       :ordered_on, :null => false, :default => Date.parse('Jan 1 2011')
+      t.references :product,    :null => false
+      t.references :customer,   :null => false
+    end
+    add_index :companies, :sort
+    add_index :customers, :sort
+    add_index :customers, :company_id
+    add_index :products,  :sort
+    add_index :products,  :company_id
+    add_index :purchases, :ordered_on
+    add_index :purchases, :product_id
+    add_index :purchases, :customer_id
+  end
+  
+  def self.down
+    drop_table :purchases
+    drop_table :products
+    drop_table :customers
+    drop_table :companies
+  end
+end