partitioned 1.1.1 → 1.1.3

data/spec/partitioned/partitioned_base/configurator/dsl_spec.rb

@@ -23,9 +23,13 @@ module Partitioned
             {
               "on_field" => nil,
               "indexes" => [],
+              "janitorial_archives_needed" => nil,
+              "janitorial_creates_needed" => nil,
+              "janitorial_drops_needed" => nil,
               "foreign_keys" => [],
               "last_partitions_order_by_clause" => nil,
               "schema_name" => nil,
+              "table_alias_name" => nil,
               "name_prefix" => nil,
               "base_name" => nil,
               "part_name" => nil,

data/spec/support/shared_example_spec_helper_for_time_key.rb

@@ -121,7 +121,7 @@ shared_examples_for "check that basic operations with postgres works correctly f
   context "when try to create new record outside the range of partitions" do
 
     it "raises ActiveRecord::StatementInvalid" do
-      lambda { subject.create_many([{ :created_at => DATE_NOW + 1.year, :company_id => 1 }])
+      lambda { subject.create_many([{ :created_at => DATE_NOW - 1.year, :company_id => 1 }])
       }.should raise_error(ActiveRecord::StatementInvalid)
     end
 
@@ -130,7 +130,7 @@ shared_examples_for "check that basic operations with postgres works correctly f
   context "when try to update a record outside the range of partitions" do
 
     it "raises ActiveRecord::StatementInvalid" do
-      lambda { subject.update(1, :name => 'Kevin', :created_at => DATE_NOW + 1.year)
+      lambda { subject.update(1, :name => 'Kevin', :created_at => DATE_NOW - 1.year)
       }.should raise_error(ActiveRecord::StatementInvalid)
     end
 
@@ -139,7 +139,7 @@ shared_examples_for "check that basic operations with postgres works correctly f
   context "when try to find a record outside the range of partitions" do
 
     it "raises ActiveRecord::StatementInvalid" do
-      lambda { subject.from_partition(DATE_NOW + 1.year).find(1)
+      lambda { subject.from_partition(DATE_NOW - 1.year).find(1)
       }.should raise_error(ActiveRecord::StatementInvalid)
     end
 

data/spec/support/tables_spec_helper.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module TablesSpecHelper
 
   class Company < ActiveRecord::Base
-    extend Partitioned::BulkMethodsMixin
+    extend BulkMethodsMixin
     has_many :employees, :class_name => 'Company', :conditions => "companies.id = employees.companies_id"
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: partitioned
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-13 00:00:00.000000000 Z
+date: 2013-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -60,6 +60,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: bulk_data_methods
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 description: A gem providing support for table partitioning in ActiveRecord. Support
   is only available for postgres databases. Other features include child table management
   (creation and deletion) and bulk data creating and updating.
@@ -68,7 +84,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .rspec
 - Gemfile
+- Gemfile.lock
 - LICENSE
 - PARTITIONING_EXPLAINED.txt
 - README
@@ -90,7 +108,6 @@ files:
 - lib/monkey_patch_postgres.rb
 - lib/partitioned.rb
 - lib/partitioned/active_record_overrides.rb
-- lib/partitioned/bulk_methods_mixin.rb
 - lib/partitioned/by_created_at.rb
 - lib/partitioned/by_foreign_key.rb
 - lib/partitioned/by_id.rb
@@ -98,6 +115,7 @@ files:
 - lib/partitioned/by_monthly_time_field.rb
 - lib/partitioned/by_time_field.rb
 - lib/partitioned/by_weekly_time_field.rb
+- lib/partitioned/by_yearly_time_field.rb
 - lib/partitioned/multi_level.rb
 - lib/partitioned/multi_level/configurator/data.rb
 - lib/partitioned/multi_level/configurator/dsl.rb
@@ -144,7 +162,6 @@ files:
 - spec/dummy/script/rails
 - spec/dummy/spec/spec_helper.rb
 - spec/monkey_patch_posgres_spec.rb
-- spec/partitioned/bulk_methods_mixin_spec.rb
 - spec/partitioned/by_created_at_spec.rb
 - spec/partitioned/by_foreign_key_spec.rb
 - spec/partitioned/by_id_spec.rb
@@ -152,6 +169,7 @@ files:
 - spec/partitioned/by_monthly_time_field_spec.rb
 - spec/partitioned/by_time_field_spec.rb
 - spec/partitioned/by_weekly_time_field_spec.rb
+- spec/partitioned/by_yearly_time_field_spec.rb
 - spec/partitioned/multi_level/configurator/dsl_spec.rb
 - spec/partitioned/multi_level/configurator/reader_spec.rb
 - spec/partitioned/partitioned_base/configurator/dsl_spec.rb
@@ -219,7 +237,6 @@ test_files:
 - spec/dummy/script/rails
 - spec/dummy/spec/spec_helper.rb
 - spec/monkey_patch_posgres_spec.rb
-- spec/partitioned/bulk_methods_mixin_spec.rb
 - spec/partitioned/by_created_at_spec.rb
 - spec/partitioned/by_foreign_key_spec.rb
 - spec/partitioned/by_id_spec.rb
@@ -227,6 +244,7 @@ test_files:
 - spec/partitioned/by_monthly_time_field_spec.rb
 - spec/partitioned/by_time_field_spec.rb
 - spec/partitioned/by_weekly_time_field_spec.rb
+- spec/partitioned/by_yearly_time_field_spec.rb
 - spec/partitioned/multi_level/configurator/dsl_spec.rb
 - spec/partitioned/multi_level/configurator/reader_spec.rb
 - spec/partitioned/partitioned_base/configurator/dsl_spec.rb

data/lib/partitioned/bulk_methods_mixin.rb

@@ -1,233 +0,0 @@
-module Partitioned
-  #
-  # MixIn used to extend ActiveRecord::Base classes implementing bulk insert and update operations
-  # through {#create_many} and {#update_many}.  {Partitioned::PartitionedBase} classes are extended
-  # with these methods by default.
-  #
-  # @example to use in non-{Partitioned::PartitionedBase} class:
-  #   class Company < ActiveRecord::Base
-  #     extend Partitioned::BulkMethodsMixin
-  #   end
-  #
-  module BulkMethodsMixin
-    # exception thrown when row data structures are inconsistent between rows in single call to {#create_many} or {#update_many}
-    class BulkUploadDataInconsistent < StandardError
-      def initialize(model, table_name, expected_columns, found_columns, while_doing)
-        super("#{model.name}: for table: #{table_name}; #{expected_columns} != #{found_columns}; #{while_doing}")
-      end
-    end
-
-    # BULK creation of many rows
-    #
-    # @example no options used
-    #   rows = [
-    #         { :name => 'Keith', :salary => 1000 },
-    #         { :name => 'Alex', :salary => 2000 }
-    #   ]
-    #   Employee.create_many(rows)
-    #
-    # @example with :returning option to returns key value
-    #   rows = [
-    #         { :name => 'Keith', :salary => 1000 },
-    #         { :name => 'Alex', :salary => 2000 }
-    #   ]
-    #   options = { :returning => [:id] }
-    #   Employee.create_many(rows, options)
-    #   [#<Employee id: 1>, #<Employee id: 2>]
-    #
-    # @example with :slice_size option (will generate two insert queries)
-    #   rows = [
-    #         { :name => 'Keith', :salary => 1000 },
-    #         { :name => 'Alex', :salary => 2000 },
-    #         { :name => 'Mark', :salary => 3000 }
-    #   ]
-    #   options = { :slice_size => 2 }
-    #   Employee.create_many(rows, options)
-    #
-    # @param [Array<Hash>] rows ([]) data to be inserted into database
-    # @param [Hash] options ({}) options for bulk inserts
-    # @option options [Integer] :slice_size (1000) how many records will be created in a single SQL query
-    # @option options [Boolean] :check_consitency (true) ensure some modicum of sanity on the incoming dataset, specifically: does each row define the same set of key/value pairs
-    # @option options [Array or String] :returning (nil) list of fields to return.
-    # @return [Array<Hash>] rows returned from DB as option[:returning] requests
-    # @raise [BulkUploadDataInconsistent] raised when key/value pairs between rows are inconsistent (check disabled with option :check_consistency)
-    def create_many(rows, options = {})
-      return [] if rows.blank?
-      options[:slice_size] = 1000 unless options.has_key?(:slice_size)
-      options[:check_consistency] = true unless options.has_key?(:check_consistency)
-      returning_clause = ""
-      if options[:returning]
-        if options[:returning].is_a? Array
-          returning_list = options[:returning].join(',')
-        else
-          returning_list = options[:returning]
-        end
-        returning_clause = " returning #{returning_list}"
-      end
-      returning = []
-
-      created_at_value = Time.zone.now
-
-      num_sequences_needed = rows.reject{|r| r[:id].present?}.length
-      if num_sequences_needed > 0
-        row_ids = connection.next_sequence_values(sequence_name, num_sequences_needed)
-      else
-        row_ids = []
-      end
-      rows.each do |row|
-        # set the primary key if it needs to be set
-        row[:id] ||= row_ids.shift
-      end.each do |row|
-        # set :created_at if need be
-        row[:created_at] ||= created_at_value
-      end.group_by do |row|
-        respond_to?(:partition_table_name) ? partition_table_name(*partition_key_values(row)) : table_name
-      end.each do |table_name, rows_for_table|
-        column_names = rows_for_table[0].keys.sort{|a,b| a.to_s <=> b.to_s}
-        sql_insert_string = "insert into #{table_name} (#{column_names.join(',')}) values "
-        rows_for_table.map do |row|
-          if options[:check_consistency]
-            row_column_names = row.keys.sort{|a,b| a.to_s <=> b.to_s}
-            if column_names != row_column_names
-              raise BulkUploadDataInconsistent.new(self, table_name, column_names, row_column_names, "while attempting to build insert statement")
-            end
-          end
-          column_values = column_names.map do |column_name|
-            quote_value(row[column_name], columns_hash[column_name.to_s])
-          end.join(',')
-          "(#{column_values})"
-        end.each_slice(options[:slice_size]) do |insert_slice|
-          returning += find_by_sql(sql_insert_string + insert_slice.join(',') + returning_clause)
-        end
-      end
-      return returning
-    end
-
-    #
-    # BULK updates of many rows
-    #
-    # @return [Array<Hash>] rows returned from DB as option[:returning] requests
-    # @raise [BulkUploadDataInconsistent] raised when key/value pairs between rows are inconsistent (check disabled with option :check_consistency)
-    # @param [Hash] options ({}) options for bulk inserts
-    # @option options [Integer] :slice_size (1000) how many records will be created in a single SQL query
-    # @option options [Boolean] :check_consitency (true) ensure some modicum of sanity on the incoming dataset, specifically: does each row define the same set of key/value pairs
-    # @option options [Array] :returning (nil) list of fields to return.
-    # @option options [String] :returning (nil) single field to return.
-    #
-    # @overload update_many(rows = [], options = {})
-    #   @param [Array<Hash>] rows ([]) data to be updated
-    #   @option options [String] :set_array (built from first row passed in) the set clause
-    #   @option options [String] :where ('"#{table_name}.id = datatable.id"') the where clause
-    #
-    # @overload update_many(rows = {}, options = {})
-    #   @param [Hash<Hash, Hash>] rows ({}) data to be updated
-    #   @option options [String] :set_array (built from the values in the first key/value pair of `rows`) the set clause
-    #   @option options [String] :where (built from the keys in the first key/value pair of `rows`) the where clause
-    #
-    # @example using "set_array" to add the value of "salary" to the specific employee's salary the default where clause matches IDs so, it works here.
-    #   rows = [
-    #     { :id => 1, :salary => 1000 },
-    #     { :id => 10, :salary => 2000 },
-    #     { :id => 23, :salary => 2500 }
-    #   ]
-    #   options = { :set_array => '"salary = datatable.salary"' }
-    #   Employee.update_many(rows, options)
-    #
-    # @example using where clause to match salary.
-    #   rows = [
-    #     { :id => 1, :salary => 1000, :company_id => 10 },
-    #     { :id => 10, :salary => 2000, :company_id => 12 },
-    #     { :id => 23, :salary => 2500, :company_id => 5 }
-    #   ]
-    #   options = {
-    #     :set_array => '"company_id = datatable.company_id"',
-    #     :where => '"#{table_name}.salary = datatable.salary"'
-    #   }
-    #   Employee.update_many(rows, options)
-    #
-    # @example setting where clause to the KEY of the hash passed in and the set_array is generated from the VALUES
-    #   rows = {
-    #     { :id => 1 } => { :salary => 100000, :company_id => 10 },
-    #     { :id => 10 } => { :salary => 110000, :company_id => 12 },
-    #     { :id => 23 } => { :salary => 90000, :company_id => 5 }
-    #   }
-    #   Employee.update_many(rows)
-    #
-    # @note Remember that you should probably set updated_at using "updated = datatable.updated_at"
-    #   or "updated_at = now()" in the set_array if you want to follow
-    #   the standard active record model for time columns (and you have an updated_at column)
-    def update_many(rows, options = {})
-      return [] if rows.blank?
-      if rows.is_a?(Hash)
-        options[:where] = '"' + rows.keys[0].keys.map{|key| '#{table_name}.' + "#{key} = datatable.#{key}"}.join(' and ') + '"'
-        options[:set_array] = '"' + rows.values[0].keys.map{|key| "#{key} = datatable.#{key}"}.join(',') + '"' unless options[:set_array]
-        r = []
-        rows.each do |key,value|
-          r << key.merge(value)
-        end
-        rows = r
-      end
-      unless options[:set_array]
-        column_names =  rows[0].keys
-        columns_to_remove = [:id]
-        columns_to_remove += [partition_keys].map{|k| k.to_sym} if respond_to?(:partition_keys)
-        options[:set_array] = '"' + (column_names - columns_to_remove.flatten).map{|cn| "#{cn} = datatable.#{cn}"}.join(',') + '"'
-      end
-      options[:slice_size] = 1000 unless options[:slice_size]
-      options[:check_consistency] = true unless options.has_key?(:check_consistency)
-      returning_clause = ""
-      if options[:returning]
-        if options[:returning].is_a?(Array)
-          returning_list = options[:returning].map{|r| '#{table_name}.' + r.to_s}.join(',')
-        else
-          returning_list = options[:returning]
-        end
-        returning_clause = "\" returning #{returning_list}\""
-      end
-      options[:where] = '"#{table_name}.id = datatable.id"' unless options[:where]
-
-      returning = []
-
-      rows.group_by do |row|
-        respond_to?(:partition_table_name) ? partition_table_name(*partition_key_values(row)) : table_name
-      end.each do |table_name, rows_for_table|
-        column_names = rows_for_table[0].keys.sort{|a,b| a.to_s <=> b.to_s}
-        rows_for_table.each_slice(options[:slice_size]) do |update_slice|
-          datatable_rows = []
-          update_slice.each_with_index do |row,i|
-            if options[:check_consistency]
-              row_column_names = row.keys.sort{|a,b| a.to_s <=> b.to_s}
-              if column_names != row_column_names
-                raise BulkUploadDataInconsistent.new(self, table_name, column_names, row_column_names, "while attempting to build update statement")
-              end
-            end
-            datatable_rows << row.map do |column_name,column_value|
-              column_name = column_name.to_s
-              columns_hash_value = columns_hash[column_name]
-              if i == 0 
-                "#{quote_value(column_value, columns_hash_value)}::#{columns_hash_value.sql_type} as #{column_name}"
-              else
-                quote_value(column_value, columns_hash_value)
-              end
-            end.join(',')
-          end
-          datatable = datatable_rows.join(' union select ')
-
-          sql_update_string = <<-SQL
-            update #{table_name} set
-              #{eval(options[:set_array])}
-            from
-            (select
-              #{datatable}
-            ) as datatable
-            where
-              #{eval(options[:where])}
-            #{eval(returning_clause)}
-          SQL
-          returning += find_by_sql(sql_update_string)
-        end
-      end
-      return returning
-    end
-  end
-end

data/spec/partitioned/bulk_methods_mixin_spec.rb

@@ -1,512 +0,0 @@
-require 'spec_helper'
-require "#{File.dirname(__FILE__)}/../support/tables_spec_helper"
-
-module Partitioned
-  module BulkMethodsMixin
-    describe "BulkMethodsMixin" do
-      include TablesSpecHelper
-
-      before do
-        class Employee < ActiveRecord::Base
-          include ActiveRecordOverrides
-          extend Partitioned::BulkMethodsMixin
-        end
-        create_tables
-      end
-
-      describe "create_many" do
-
-        context "when call method with empty rows" do
-          it "returns empty array" do
-            Employee.create_many("").should == []
-          end
-        end # when call method with empty rows
-
-        context "when try to create records with the given id" do
-          it "records created" do
-            Employee.create_many([{ :id => Employee.connection.next_sequence_value(Employee.sequence_name),
-                                    :name => 'Keith',
-                                    :company_id => 2
-                                  },
-                                  { :id => Employee.connection.next_sequence_value(Employee.sequence_name),
-                                    :name => 'Mike',
-                                    :company_id => 3
-                                  },
-                                  { :id => Employee.connection.next_sequence_value(Employee.sequence_name),
-                                    :name => 'Alex',
-                                    :company_id => 1
-                                  }])
-            Employee.all.map{ |r| r.name }.should == ["Keith", "Mike", "Alex"]
-          end
-        end # when try to create records with the given id
-
-        context "when try to create records without the given id" do
-          it "records created" do
-            Employee.create_many([{ :name => 'Keith', :company_id => 2 },
-                                  { :name => 'Mike', :company_id => 3 },
-                                  { :name => 'Alex', :company_id => 1 }])
-            Employee.all.map{ |r| r.name }.should == ["Keith", "Mike", "Alex"]
-          end
-        end # when try to create records without the given id
-
-        context "when try to create records with a mixture of given ids and non-given ids" do
-          it "records created" do
-            Employee.create_many([{ :name => 'Keith', :company_id => 2 },
-                                  { :id => Employee.connection.next_sequence_value(Employee.sequence_name),
-                                    :name => 'Mike',
-                                    :company_id => 3
-                                  },
-                                  { :name => 'Mark', :company_id => 1 },
-                                  { :id => Employee.connection.next_sequence_value(Employee.sequence_name),
-                                    :name => 'Alex',
-                                    :company_id => 1
-                                  }])
-            Employee.all.map{ |r| r.name }.should == ["Keith", "Mike", "Mark", "Alex"]
-          end
-        end # when try to create records with a mixture of given ids and non-given ids
-
-        context "when try to create records with the given created_at" do
-          it "records created" do
-            Employee.create_many([{ :name => 'Keith',
-                                    :company_id => 2,
-                                    :created_at => Time.zone.parse('2012-01-02')
-                                  },
-                                  { :name => 'Mike',
-                                    :company_id => 3,
-                                    :created_at => Time.zone.parse('2012-01-03')
-                                  },
-                                  { :name => 'Alex',
-                                    :company_id => 1,
-                                    :created_at => Time.zone.parse('2012-01-04')
-                                  }])
-            Employee.all.map{ |r| r.created_at }.should == [
-                                                             Time.zone.parse('2012-01-02'),
-                                                             Time.zone.parse('2012-01-03'),
-                                                             Time.zone.parse('2012-01-04')
-                                                            ]
-          end
-        end # when try to create records with the given created_at
-
-        context "when try to create records without the given created_at" do
-          it "records created" do
-            Employee.create_many([{ :name => 'Keith', :company_id => 2 },
-                                  { :name => 'Mike', :company_id => 3 },
-                                  { :name => 'Alex', :company_id => 1 }])
-            Employee.all.each{ |r| r.created_at.between?(Time.now - 3.minute, Time.now + 3.minute) }.
-                should be_true
-          end
-        end # when try to create records without the given created_at
-
-        context "when try to create records without options" do
-          it "generates one insert queries" do
-            Employee.should_receive(:find_by_sql).once.and_return([])
-            Employee.create_many([{ :name => 'Keith', :company_id => 2 },
-                                  { :name => 'Alex', :company_id => 1 },
-                                  { :name => 'Mark', :company_id => 2 },
-                                  { :name => 'Phil', :company_id => 3 }])
-          end
-        end # when try to create records without options
-
-        context "when call method with option 'slice_size' equal 2" do
-          it "generates two insert queries" do
-            Employee.should_receive(:find_by_sql).twice.and_return([])
-            Employee.create_many([{ :name => 'Keith', :company_id => 2 },
-                                  { :name => 'Alex', :company_id => 1 },
-                                  { :name => 'Mark', :company_id => 2 },
-                                  { :name => 'Phil', :company_id => 3 }],
-                                  { :slice_size => 2})
-          end
-        end # when call method with option 'slice_size' equal 2
-
-        context "when create two records with options 'returning' equal id" do
-          it "returns last records id" do
-            Employee.create_many([{ :name => 'Keith', :company_id => 2 },
-                                  { :name => 'Alex', :company_id => 3 }],
-                                  { :returning => [:id] }).
-                       last.id.should == 2
-          end
-        end # when create two records with options 'returning' equal id
-
-        context "when try to create two records and doesn't
-                 the same number of keys and options check_consistency equal false" do
-          it "records created, last salary is nil" do
-            Employee.create_many([{ :company_id => 2, :name => 'Keith', :salary => 1002 },
-                                  { :name => 'Alex', :company_id => 3 }],
-                                  { :check_consistency => false })
-            Employee.find(2).salary.should == nil
-          end
-        end # when try to create two records and doesn't
-            # the same number of keys and options check_consistency equal false
-
-        context "when try to create two records and doesn't the same number of keys" do
-          it "raises BulkUploadDataInconsistent" do
-            lambda { Employee.create_many([{ :company_id => 2, :name => 'Keith', :salary => 1002  },
-                                           { :name => 'Alex', :company_id => 3}])
-            }.should raise_error(BulkUploadDataInconsistent)
-          end
-        end # when try to create two records and doesn't the same number of keys
-
-        context "when try to create records using partitioning" do
-
-          before do
-            Partitioned::BulkMethodsMixin.send(:remove_const, :Employee)
-            class Employee < ByForeignKey
-              belongs_to :company, :class_name => 'Company'
-
-              def self.partition_foreign_key
-                return :company_id
-              end
-
-              partitioned do |partition|
-                partition.index :id, :unique => true
-                partition.foreign_key :company_id
-              end
-            end # Employee
-            Employee.create_new_partition_tables(Employee.partition_generate_range(0, 4, 1))
-          end
-
-          after do
-            Partitioned::BulkMethodsMixin.send(:remove_const, :Employee)
-          end
-
-          it "returns records" do
-            Employee.create_many([{ :name => 'Keith', :company_id => 2 },
-                                  { :name => 'Alex', :company_id => 1 },
-                                  { :name => 'Phil', :company_id => 3 }])
-            Employee.from_partition(1).where(:id => 2).first.name.should == "Alex"
-            Employee.where(:id => 1, :company_id => 2).first.name.should == "Keith"
-            Employee.all.map{ |r| r.name }.should == ["Alex", "Keith", "Phil"]
-          end
-        end # when try to create records using partitioning
-
-        context "when try to create records in the table that has all the different sql types" do
-
-          before do
-            ActiveRecord::Base.connection.execute <<-SQL
-              ALTER TABLE employees ADD COLUMN test_string character varying;
-              ALTER TABLE employees ADD COLUMN test_float float;
-              ALTER TABLE employees ADD COLUMN test_decimal decimal;
-              ALTER TABLE employees ADD COLUMN test_time time;
-              ALTER TABLE employees ADD COLUMN test_time_string time;
-              ALTER TABLE employees ADD COLUMN test_date date;
-              ALTER TABLE employees ADD COLUMN test_date_string date;
-              ALTER TABLE employees ADD COLUMN test_bytea bytea;
-              ALTER TABLE employees ADD COLUMN test_boolean boolean;
-              ALTER TABLE employees ADD COLUMN test_xml xml;
-              ALTER TABLE employees ADD COLUMN test_tsvector tsvector;
-            SQL
-            Employee.reset_column_information
-          end
-
-          after do
-            ActiveRecord::Base.connection.reset!
-          end
-
-          context "non-null values" do
-            it "returns record with all sql types" do
-              lambda { Employee.create_many([{ :name => 'Keith',
-                                               :company_id => 2,
-                                               :created_at => Time.zone.parse('2012-12-21'),
-                                               :updated_at => '2012-12-21 00:00:00',
-                                               :test_string => "string",
-                                               :test_float => 12.34,
-                                               :test_decimal => 123456789101112,
-                                               :test_time => Time.now,
-                                               :test_time_string => '00:00:00',
-                                               :test_date => Date.parse('2012-12-21'),
-                                               :test_date_string => '2012-12-21',
-                                               :test_bytea => "text".bytes.to_a,
-                                               :test_boolean => false,
-                                               :test_xml => ["text"].to_xml,
-                                               :test_tsvector => "test string",
-                                             }]) }.should_not raise_error
-              Employee.all.size.should == 1
-            end
-          end # non-null values
-
-          context "null values" do
-            it "returns record with all sql types" do
-              lambda { Employee.create_many([{ :name => 'Keith',
-                                               :company_id => 2,
-                                               :created_at => nil,
-                                               :updated_at => nil,
-                                               :salary => nil,
-                                               :test_string => nil,
-                                               :test_float => nil,
-                                               :test_decimal => nil,
-                                               :test_time => nil,
-                                               :test_time_string => nil,
-                                               :test_date => nil,
-                                               :test_date_string => nil,
-                                               :test_bytea => nil,
-                                               :test_boolean => nil,
-                                               :test_xml => nil,
-                                               :test_tsvector => nil,
-                                             }]) }.should_not raise_error
-              Employee.all.size.should == 1
-            end
-          end # null values
-
-        end # when try to create records in the table that has all the different sql types
-
-      end # create_many
-
-      describe "update_many" do
-
-        before do
-          Employee.create_many([{ :name => 'Keith', :company_id => 2 },
-                                { :name => 'Alex', :company_id => 1 },
-                                { :name => 'Mark', :company_id => 2 },
-                                { :name => 'Phil', :company_id => 3 }])
-        end
-
-        context "when call method with empty rows" do
-          it "returns empty array" do
-            Employee.update_many("").should == []
-          end
-        end # when call method with empty rows
-
-        context "when try to update records without options" do
-
-          context "input parameters is hash" do
-            it "records updated" do
-              Employee.update_many({ { :id => 1 } => {
-                                       :name => 'Elvis'
-                                     },
-                                     { :id => 2 } => {
-                                       :name => 'Freddi'
-                                     } })
-              Employee.find(1).name.should == "Elvis"
-              Employee.find(2).name.should == "Freddi"
-            end
-          end # input parameters is hash
-
-          context "input parameters is array" do
-            it "records updated" do
-              Employee.update_many([{ :id => 1,
-                                      :name => 'Elvis'
-                                    },
-                                    { :id => 2,
-                                      :name => 'Freddi'
-                                    }])
-              Employee.find(1).name.should == "Elvis"
-              Employee.find(2).name.should == "Freddi"
-            end
-          end # input parameters is array
-
-          context "when try to update two records and doesn't the same number of keys" do
-            it "raises BulkUploadDataInconsistent" do
-              lambda { Employee.update_many([{ :id => 1, :name => 'Elvis', :salary => 1002  },
-                                             { :name => 'Freddi', :id => 2}])
-              }.should raise_error(BulkUploadDataInconsistent)
-            end
-          end # when try to update two records and doesn't the same number of keys
-
-          context "when try to update records with the given updated_at" do
-            it "records created" do
-              Employee.update_many([{ :id => 1,
-                                      :updated_at => Time.zone.parse('2012-01-02')
-                                    },
-                                    { :id => 2,
-                                      :updated_at => Time.zone.parse('2012-01-03')
-                                    },
-                                    { :id => 3,
-                                      :updated_at => Time.zone.parse('2012-01-04')
-                                    },
-                                    { :id => 4,
-                                      :updated_at => Time.zone.parse('2012-01-05')
-                                    }])
-              Employee.all.map{ |r| r.updated_at }.should == [
-                                                               Time.zone.parse('2012-01-02'),
-                                                               Time.zone.parse('2012-01-03'),
-                                                               Time.zone.parse('2012-01-04'),
-                                                               Time.zone.parse('2012-01-05')
-                                                              ]
-            end
-          end # when try to update records with the given updated_at
-
-        end # when try to update records without options
-
-        context "when call method with option :slice_size set is default" do
-          it "generates one insert queries" do
-            Employee.should_receive(:find_by_sql).once.and_return([])
-            Employee.update_many([{ :id => 1, :name => 'Elvis' },
-                                  { :id => 2, :name => 'Freddi'},
-                                  { :id => 3, :name => 'Patric'},
-                                  { :id => 4, :name => 'Jane'}])
-          end
-        end # when call method with option :slice_size set is default
-
-
-        context "when call method with option :slice_size = 2" do
-          it "generates two insert queries" do
-            Employee.should_receive(:find_by_sql).twice.and_return([])
-            Employee.update_many([{ :id => 1, :name => 'Elvis' },
-                                  { :id => 2, :name => 'Freddi'},
-                                  { :id => 3, :name => 'Patric'},
-                                  { :id => 4, :name => 'Jane'}],
-                                  { :slice_size => 2})
-          end
-        end # when call method with option :slice_size = 2
-
-        context "when try to update two records and doesn't
-                 the same number of keys and options check_consistency equal false" do
-          it "raises ActiveRecord::StatementInvalid" do
-            lambda {
-              Employee.update_many([{ :id => 1, :name => 'Elvis', :salary => 1002  },
-                                    { :name => 'Freddi', :id => 2}],
-                                    { :check_consistency => false })
-            }.should raise_error(ActiveRecord::StatementInvalid)
-          end
-        end # when try to update two records and doesn't
-            # the same number of keys and options check_consistency equal false
-
-        context "when update two records with options 'returning' equal :name" do
-          it "returns last records name" do
-            Employee.update_many([{ :id => 1, :name => 'Elvis' },
-                                  { :id => 2, :name => 'Freddi'}],
-                                  { :returning => [:name] }).
-                       last.name.should == 'Freddi'
-          end
-        end # when update two records with options 'returning' equal :name
-
-        context "when update method with options :set_array equal 'salary = datatable.salary'" do
-          it "updates only salary column" do
-            Employee.update_many([{ :id => 1, :name => 'Elvis', :salary => 12 },
-                                  { :id => 2, :name => 'Freddi',:salary => 22}],
-                                  { :set_array => '"salary = datatable.salary"' })
-            Employee.find(1).name.should_not == "Elvis"
-            Employee.find(1).salary.should == 12
-            Employee.find(2).name.should_not == "Freddi"
-            Employee.find(2).salary.should == 22
-          end
-        end # when update method with options :set_array equal 'salary = datatable.salary'
-
-        context "when update method with options :where" do
-          it "updates only name column, where salary equal input values" do
-            Employee.update_many([{ :id => 1, :name => 'Elvis', :salary => 12 },
-                                  { :id => 2, :name => 'Freddi',:salary => 22}],
-                                  { :where => '"#{table_name}.salary = datatable.salary"' })
-            Employee.find(1).name.should_not == "Elvis"
-            Employee.find(1).salary.should == 3
-            Employee.find(2).name.should_not == "Freddi"
-            Employee.find(2).salary.should == 3
-          end
-        end # when update method with options :where
-
-        context "when try to update records using partitioning" do
-
-          before do
-            drop_tables
-            create_tables
-            Partitioned::BulkMethodsMixin.send(:remove_const, :Employee)
-            class Employee < ByForeignKey
-              belongs_to :company, :class_name => 'Company'
-
-              def self.partition_foreign_key
-                return :company_id
-              end
-
-              partitioned do |partition|
-                partition.index :id, :unique => true
-                partition.foreign_key :company_id
-              end
-            end # Employee
-            Employee.create_new_partition_tables(Employee.partition_generate_range(0, 4, 1))
-            Employee.create_many([{ :name => 'Keith', :company_id => 2 },
-                                  { :name => 'Alex', :company_id => 1 },
-                                  { :name => 'Mark', :company_id => 3 }])
-          end
-
-          after do
-            Partitioned::BulkMethodsMixin.send(:remove_const, :Employee)
-          end
-
-          it "returns records" do
-            Employee.update_many({ { :company_id => 2, :id => 1 } => { :name => 'Indy' },
-                                   { :company_id => 1, :id => 2 } => { :name => 'Larry' },
-                                   { :company_id => 3, :id => 3 } => { :name => 'Filip' } })
-            Employee.from_partition(1).where(:id => 2).first.name.should == "Larry"
-            Employee.where(:id => 1, :company_id => 2).first.name.should == "Indy"
-            Employee.all.map{ |r| r.name }.should == ["Larry", "Indy", "Filip"]
-          end
-        end # when try to update records using partitioning
-
-        context "when try to update records in the table that has all the different sql types" do
-
-          before do
-            ActiveRecord::Base.connection.execute <<-SQL
-              ALTER TABLE employees ADD COLUMN test_string character varying;
-              ALTER TABLE employees ADD COLUMN test_float float;
-              ALTER TABLE employees ADD COLUMN test_decimal decimal;
-              ALTER TABLE employees ADD COLUMN test_time time;
-              ALTER TABLE employees ADD COLUMN test_time_string time;
-              ALTER TABLE employees ADD COLUMN test_date date;
-              ALTER TABLE employees ADD COLUMN test_date_string date;
-              ALTER TABLE employees ADD COLUMN test_bytea bytea;
-              ALTER TABLE employees ADD COLUMN test_boolean boolean;
-              ALTER TABLE employees ADD COLUMN test_xml xml;
-              ALTER TABLE employees ADD COLUMN test_tsvector tsvector;
-            SQL
-            Employee.reset_column_information
-          end
-
-          after do
-            ActiveRecord::Base.connection.reset!
-          end
-
-          context "non-null values" do
-            it "returns record with all sql types" do
-              lambda { Employee.update_many([{ :id => 1,
-                                               :name => 'Keith',
-                                               :company_id => 2,
-                                               :created_at => Time.zone.parse('2012-12-21'),
-                                               :updated_at => '2012-12-21 00:00:00',
-                                               :test_string => "string",
-                                               :test_float => 12.34,
-                                               :test_decimal => 123456789101112,
-                                               :test_time => Time.now,
-                                               :test_time_string => '00:00:00',
-                                               :test_date => Date.parse('2012-12-21'),
-                                               :test_date_string => '2012-12-21',
-                                               :test_bytea => "text".bytes.to_a,
-                                               :test_boolean => false,
-                                               :test_xml => ["text"].to_xml,
-                                               :test_tsvector => "test string",
-                                             }]) }.should_not raise_error
-              Employee.find(1).test_boolean.should == false
-              Employee.find(1).test_tsvector.should == "'string' 'test'"
-            end
-          end # non-null values
-
-          context "null values" do
-            it "returns record with all sql types" do
-              lambda { Employee.update_many([{ :id => 1,
-                                               :name => 'Keith',
-                                               :company_id => 2,
-                                               :updated_at => nil,
-                                               :salary => nil,
-                                               :test_string => nil,
-                                               :test_float => nil,
-                                               :test_decimal => nil,
-                                               :test_time => nil,
-                                               :test_time_string => nil,
-                                               :test_date => nil,
-                                               :test_date_string => nil,
-                                               :test_bytea => nil,
-                                               :test_boolean => nil,
-                                               :test_xml => nil,
-                                               :test_tsvector => nil,
-                                             }]) }.should_not raise_error
-              Employee.find(1).test_boolean.should == nil
-              Employee.find(1).test_tsvector.should == nil
-            end
-          end # null values
-
-        end # when try to update records in the table that has all the different sql types
-
-      end # update_many
-
-    end # BulkMethodsMixin
-  end # BulkMethodsMixin
-end # Partitioned