mass_insert 0.1.1 → 0.1.2

data/.gitignore

@@ -15,3 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.rvmrc
+.rspec

data/.travis.yml

@@ -2,3 +2,13 @@ language: ruby
 rvm:
   - "1.9.2"
   - "1.9.3"
+  - "2.0.0"
+
+before_script:
+  - mysql -e 'create database mysql2_test;'
+  - psql -c 'create database postgresql_test;' -U postgres
+  - cd spec/dummy
+  - rake db:migrate RAILS_ENV=mysql2
+  - rake db:migrate RAILS_ENV=postgresql
+  - rake db:migrate RAILS_ENV=sqlite3
+  - cd ../..

data/Gemfile

@@ -1,13 +1,11 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in mass_insert.gemspec
 gemspec
 
 gem "rails", "3.2.13"
 gem "mysql2"
 gem "sqlite3"
 gem "pg"
-
 gem "rspec"
 gem "simplecov"
 gem "rake"

data/README.md

@@ -1,7 +1,7 @@
 # MassInsert [![Build Status](https://travis-ci.org/alejandrogutierrez/mass_insert.png?branch=master)](https://travis-ci.org/alejandrogutierrez/mass_insert)
 
 This gem aims to provide an easy and faster way to do single database insertions in Rails.
-Support Mysql, PostgreSQL, SQLite3 and SQLServer adapters.
+Support Mysql, PostgreSQL and SQLite3 adapters.
 
 ## Installation
 
@@ -21,7 +21,7 @@ Or install it yourself with:
 
 Faster. It's depending of the computer but these are some results...
 
-* PostgreSQL - Saving 10,000 records in 0.84s
+* PostgreSQL - Saving 10,000 records in 0.49s
 
 ## Attention
 
@@ -43,11 +43,6 @@ The array of values:
         :name   => "Beverly",
         :email  => "nippy_programmer@gmail.com",
         :age    => 24
-      },
-      {
-        :name   => "Scottie",
-        :email  => "angry_programmer@gmail.com",
-        :age    => 32
       }
     ]
 
@@ -58,7 +53,7 @@ And call mass_insert method from your model:
 
 ## Results
 
-Sometimes after MassInsert process you need to see some necessary information about the process. MassInsert gem provides a simple way to do it. Only call the next methods from your model after MassInsert execution.
+Sometimes after MassInsert process you need to see some necessary information about the process. MassInsert gem provides a simple way to do it. Just call the next methods from your model after MassInsert execution.
 
     User.mass_insert_results.records                    # => 120000
 
@@ -66,8 +61,8 @@ Some result options are...
 
 1. `records` : Returns the amount of records that were persisted.
 2. `time` : Returns the time that took to do all the MassInsert process.
-3. `build_time` : Returns the time that took to create the query string that was persisted.
-4. `execute_time` : Returns the time that took to execute the query string that was persisted.
+3. `building_time` : Returns the time that took to create the query string that was persisted.
+4. `execution_time` : Returns the time that took to execute the query string that was persisted.
 
 
 ## Options
@@ -75,32 +70,29 @@ Some result options are...
 MassInsert accepts options hash by second param when you call `mass_insert` from your model. This options allow you to configure the way that the records will be created. Example...
 
     options = {
-      :primary_key => :user_id,
-      :primary_key_mode => :manual
+      :some_option => some_value,
+      :some_option => some_value
     }
 
     User.mass_insert(values, options)
 
 OR directly
 
-    User.mass_insert(values, :primary_key => :user_id, :primary_key_mode => :manual)
+    User.mass_insert(values, :option => value)
 
-Some options that you can include are...
+Some options you can include are...
 
-**table_name**
-- Default value is the table name to your model. This options rarely needs to change but you can do it if you pass a string with the table name. Example...
+**Primary key**
 
-    options = {:table_name => "users"}
+By default primary key is ignored. If you wish primary key doesn't be ignored you need to pass the `primary_key` option on true. Example...
 
-**primary_key**
-- Default value is `:id`. You can change the name of primary key column send it a symbol with the column name.
+    User.mass_insert(values, :primary_key => true)
 
-    options = {:primary_key => :post_id}
+**Each slice**
 
-**primary_key_mode**
-- Default value is `:auto`. When is `:auto` MassInsert knows that the database will generate the value of the primary key column automatically. If you pass `:manual` as primary key mode you need to create your value hashes with the key and value of the primary key column.
+Due you can get a database timeout error you can specify that the insertion will be in batches. You need to pass the `each_slice` option with the records per batch. Example...
 
-    options = {:primary_key_mode => :manual}
+    User.mass_insert(values, :each_slice => 10000)
 
 ## Contributing
 

data/Rakefile

@@ -1,44 +1,33 @@
 require "bundler/gem_tasks"
 
 namespace :spec do
-  desc "Prepares the environment to use the gem"
-  task :prepare do
-    system("
-      bundle install
-      cd spec/active_record_dummy
-      rake db:drop db:create db:migrate RAILS_ENV=mysql2
-      rake db:drop db:create db:migrate RAILS_ENV=postgresql
-      rake db:drop db:create db:migrate RAILS_ENV=sqlite3
-    ")
+  desc "Runs unit tests"
+  task :unit do
+    system("echo '\e[00;32m\033[1mRunning unit tests...\e[00m'")
+    system("bundle exec rspec spec/lib")
   end
 
-  desc "Runs all unit tests"
-  task :all do
-    system("echo '\e[00;32m\033[1mRunning all unit tests...\e[00m'")
-    system("bundle exec rspec spec/mass_insert_spec.rb spec/mass_insert")
-  end
-  
-  desc "Runs all the mysql2 specs"
-  task :mysql2 do
-    ENV["RAILS_ENV"] = "mysql2"
-    system("echo '\e[00;32m\033[1mRunning the Mysql2 adapter tests...\e[00m'")
-    system("bundle exec rspec spec/active_record_models")
-  end
+  adapters = [:mysql2, :postgresql, :sqlite3]
 
-  desc "Runs all the Postgresql specs"
-  task :postgresql do
-    ENV["RAILS_ENV"] = "postgresql"
-    system("echo '\e[00;32m\033[1mRunning the Postgresql adapter tests...\e[00m'")
-    system("bundle exec rspec spec/active_record_models")
+  adapters.each do |adapter|
+    desc "Runs test suite to #{adapter}"
+    task adapter do
+      ENV["RAILS_ENV"] = adapter.to_s
+      system("echo '\e[00;32m\033[1mRunning test suite to #{adapter}...\e[00m'")
+      system("bundle exec rspec spec/adapters")
+    end
   end
 
-  desc "Runs all the Sqlite3 specs"
-  task :sqlite3 do
-    ENV["RAILS_ENV"] = "sqlite3"
-    system("echo '\e[00;32m\033[1mRunning the Sqlite3 adapter tests...\e[00m'")
-    system("bundle exec rspec spec/active_record_models")
+  desc "Runs all specs"
+  task :all do
+    Rake.application['spec:unit'].invoke
+    raise "Unit test failed!" unless $?.exitstatus == 0
+
+    adapters.each do |adapter|
+      Rake.application["spec:#{adapter}"].invoke
+      raise "Test suite to #{adapter} failed!" unless $?.exitstatus == 0
+    end
   end
 end
 
-
-task default: ['spec:mysql2', 'spec:postgresql', 'spec:sqlite3', 'spec:all']
+task default: 'spec:all'

data/lib/mass_insert.rb

@@ -1,11 +1,15 @@
-require "mass_insert/version"
-
 module MassInsert
-  autoload :Adapters,         'mass_insert/adapters.rb'
-  autoload :Base,             'mass_insert/base.rb'
-  autoload :ProcessControl,   'mass_insert/process_control.rb'
-  autoload :QueryBuilder,     'mass_insert/query_builder.rb'
-  autoload :QueryExecution,   'mass_insert/query_execution.rb'
+  autoload :Base,        'mass_insert/base.rb'
+  autoload :Result,      'mass_insert/result.rb'
+  autoload :Process,     'mass_insert/process.rb'
+  autoload :Executer,    'mass_insert/executer.rb'
+  autoload :VERSION,     'mass_insert/version.rb'
+
+  module Builder
+    autoload :Base,      'mass_insert/builder/base.rb'
+    autoload :Adapters,  'mass_insert/builder/adapters.rb'
+    autoload :Utilities, 'mass_insert/builder/utilities.rb'
+  end
 end
 
 if defined?(ActiveRecord::Base)

data/lib/mass_insert/base.rb

@@ -3,93 +3,57 @@ module MassInsert
 
     # = MassInsert
     #
-    # This method does a mass database insertion just calling it from your
-    # ActiveRecord model. Example...
+    # Invoke mass insert just calling this from your ActiveRecord model...
     #
     #   User.mass_insert(values)
     #
-    # The values should be an array with the object values in a hash.
-    # Example...
+    # The values should be an array of hashes. Include attributes and values
+    # in every hash. Example...
     #
     #   values = [
     #     {:name   => "user name", :email  => "user email"},
-    #     {:name   => "user name", :email  => "user email"},
     #     {:name   => "user name", :email  => "user email"}
     #   ]
     #
     # == Options
     #
-    # And MassInset gem allow you to send it some options as second param
-    # Example...
+    # MassInset gem allow you to send it options as second param. Example...
     #
     #   User.mass_insert(values, options)
     #
-    # === table_name
-    #
-    # Default value is the table name to your model. This options rarely
-    # needs to change but you can do it if you pass a string with the table
-    # name. Example...
-    #
-    #   options = {:table_name => "users"}
-    #
-    # === primary_key
-    #
-    # Default value is :id. You can change the name of primary key column
-    # send it a symbol with the column name.
+    # === Primary key
     #
-    #   options = {:primary_key => :post_id}
+    # By default primary key is ignored. If you wish primary key doesn't
+    # be ignored you need to pass the primary_key option on true.
     #
-    # === primary_key_mode
+    #   options = {:primary_key => true}
     #
-    # Default value is :auto. When is :auto MassInsert knows that database
-    # will generate the value of the primary key column automatically. If
-    # you pass :manual as primary key mode you need to create your value
-    # hashes with the key and value of the primary key column.
+    # === Each slice
     #
-    #   options = {:primary_key_mode => :manual}
+    # Due you can get a database timeout error you can specify that the
+    # insertion will be in batches. You need to pass the each_slice option
+    # with the records per batch. Example...
     #
-    # When a class that inherit from ActiveRecord::Base calls this method
-    # is going to extend the methods in ClassMethods module. This module
-    # contains some methods that provides some necessary functionality.
+    #   User.mass_insert(values, :each_slice => 10000)
     #
-    # After extends the class with methods in ClassMethods module. The
-    # options that were passed by params are sanitized in the method
-    # called mass_insert_options to be passed by params to ProcessControl
-    # class. The record values are passed too.
-    def mass_insert values, args = {}
-      class_eval do
-        extend ClassMethods
-      end
+    def mass_insert values, options = {}
+      extend ClassMethods
+
+      options[:class_name]  ||= self
+      options[:each_slice]  ||= false
+      options[:primary_key] ||= false
 
-      options = mass_insert_options(args)
-      @mass_insert_process = ProcessControl.new(values, options)
+      @mass_insert_process = Process.new(values, options)
       @mass_insert_process.start
     end
 
 
     module ClassMethods
-      # Returns an OpenStruc instance where is possible to see the
-      # results of MassInsert process. This method calls results method
-      # in ProcessControl class. Returns nil if there is not a instance
-      # variable with the MassInset process.
+
       def mass_insert_results
-        @mass_insert_process.results if @mass_insert_process
+        Result.new(@mass_insert_process)
       end
 
-      private
-        # Sanitizes the MassInset options that were passed by params.
-        # Prepares default options that come in the class that invokes the
-        # mass_insert function and attributes options that were configured
-        # and if the options weren't passed, they would be initialized with
-        # the default values.
-        def mass_insert_options options = {}
-          options[:class_name]        ||= self
-          options[:table_name]        ||= self.table_name
-          options[:primary_key]       ||= :id
-          options[:primary_key_mode]  ||= :auto
-          options
-        end
-
     end
   end
 end

data/lib/mass_insert/builder/adapters.rb

@@ -0,0 +1,16 @@
+module MassInsert
+  module Builder
+    module Adapters
+      autoload :Adapter,            'mass_insert/builder/adapters/adapter.rb'
+      autoload :Mysql2Adapter,      'mass_insert/builder/adapters/mysql2_adapter.rb'
+      autoload :PostgreSQLAdapter,  'mass_insert/builder/adapters/postgresql_adapter.rb'
+      autoload :SQLite3Adapter,     'mass_insert/builder/adapters/sqlite3_adapter.rb'
+      autoload :SQLServerAdapter,   'mass_insert/builder/adapters/sqlserver_adapter.rb'
+
+      module Helpers
+        autoload :AbstractQuery,    'mass_insert/builder/adapters/helpers/abstract_query.rb'
+        autoload :ColumnValue,      'mass_insert/builder/adapters/helpers/column_value.rb'
+      end
+    end
+  end
+end

data/lib/mass_insert/builder/adapters/adapter.rb

@@ -0,0 +1,65 @@
+module MassInsert
+  module Builder
+    module Adapters
+      class Adapter
+        include Helpers::AbstractQuery
+
+        attr_accessor :values, :options
+
+        def initialize values, options
+          @values  = values
+          @options = options
+        end
+
+        # Returns the options according to the method that wasn't found.
+        def method_missing method, *args
+          @options.has_key?(method) ? @options[method] : super
+        end
+
+        # Returns an array according to the options with the column names
+        # that will be included in the queries.
+        def columns
+          @columns ||= sanitized_columns
+        end
+
+        # Prepare array with the column names according to the options.
+        def sanitized_columns
+          columns = class_name.column_names
+          columns.delete(class_name.primary_key) unless primary_key
+          columns.map(&:to_sym)
+        end
+
+        # Returns true o false if the database table has timestamp columns.
+        def timestamp?
+          columns.include?(:created_at) && columns.include?(:updated_at)
+        end
+
+        # Returns timestamp format according to the database adapter. This
+        # function can be overwrite in database adapters classes.
+        def timestamp_format
+          "%Y-%m-%d %H:%M:%S.%6N"
+        end
+
+        # Returns the timestamp value according to the correct timestamp
+        # format to that database engine.
+        def timestamp
+          Time.now.strftime(timestamp_format)
+        end
+
+        # Returns the timestamp hash to be merge into row values that will
+        # be saved in the database.
+        def timestamp_hash
+          timestamp_value = timestamp
+          {:created_at => timestamp_value, :updated_at => timestamp_value}
+        end
+
+        # Returns the amount of records to each query. Tries to take the
+        # each_slice option value or the length of values.
+        def values_per_insertion
+          each_slice || @values.count
+        end
+
+      end
+    end
+  end
+end

data/lib/mass_insert/builder/adapters/helpers/abstract_query.rb

@@ -0,0 +1,52 @@
+module MassInsert
+  module Builder
+    module Adapters
+      module Helpers
+        module AbstractQuery
+
+          # Returns a basic beginning of the query.
+          def begin_string
+            "INSERT INTO #{class_name.table_name} "
+          end
+
+          # Returns a basic part of the query with the columns definition.
+          def string_columns
+            "(#{columns.join(", ")}) "
+          end
+
+          # Returns a basic part of the query with all the records values.
+          def string_values
+            "VALUES (#{string_rows_values});"
+          end
+
+          # Returns all the column values to all the records
+          def string_rows_values
+            values.map{ |row| string_single_row_values(row) }.join("), (")
+          end
+
+          # Returns all the column values to a single record.
+          def string_single_row_values row
+            row.merge!(timestamp_hash) if timestamp?
+            columns.map{ |col| string_single_value(row, col) }.join(", ")
+          end
+
+          # Returns a single column value. According to the database
+          # configuration, column type and presence.
+          def string_single_value row, column
+            ColumnValue.new(row, column, class_name).build
+          end
+
+          # Values will be treated in batches according to the values per
+          # insertion value. It'll generate an array with queries.
+          def execute
+            @values.each_slice(values_per_insertion).map do |slice|
+              @values = slice;
+              "#{begin_string}#{string_columns}#{string_values}"
+            end
+          end
+
+        end
+      end
+    end
+  end
+end