partitioned 0.8.0

data/spec/partitioned/partitioned_base/sql_adapter_spec.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+module Partitioned
+  class PartitionedBase
+    describe SqlAdapter do
+
+      before(:all) do
+        class SqlAdapter
+          def last_n_partitions_order_by_clause
+            return configurator.last_partitions_order_by_clause
+          end
+        end
+        module Sql
+          class Employee < PartitionedBase
+            def self.partition_table_size
+              return 2
+            end
+
+            def self.partition_integer_field
+              return :id
+            end
+
+            partitioned do |partition|
+              partition.foreign_key :company_id
+              partition.index :id, :unique => true
+              partition.check_constraint lambda { |model, id|
+                value = model.partition_normalize_key_value(id)
+                if model.partition_table_size == 1
+                  return "( #{model.partition_integer_field} = #{value} )"
+                else
+                  return "( #{model.partition_integer_field} >= #{value} and #{model.partition_integer_field} < #{value + model.partition_table_size} )"
+                end
+              }
+            end
+          end
+        end # Sql
+        ActiveRecord::Base.connection.execute <<-SQL
+          create table employees
+          (
+              id               serial not null primary key,
+              name             text not null,
+              company_id       integer not null
+          );
+        SQL
+      end
+
+      after(:all) do
+        ActiveRecord::Base.connection.execute <<-SQL
+          drop table employees;
+        SQL
+        Partitioned::PartitionedBase::Sql.send(:remove_const, :Employee)
+      end
+
+      let(:sql_adapter) { Sql::Employee::SqlAdapter.new( Sql::Employee) }
+
+      let(:check_existence_schema) do
+        ActiveRecord::Base.connection.execute <<-SQL
+          select oid from pg_catalog.pg_namespace where nspname='employees_partitions';
+        SQL
+      end
+
+      let(:create_new_schema) do
+        ActiveRecord::Base.connection.execute <<-SQL
+          create schema employees_partitions;
+        SQL
+      end
+
+      let(:check_existence_table) do
+        ActiveRecord::Base.connection.execute <<-SQL
+          SELECT relname
+          FROM pg_class
+          WHERE relname !~ '^(pg_|sql_)'
+          AND relkind = 'r';
+        SQL
+      end
+
+      let(:create_new_partition_table) do
+        ActiveRecord::Base.connection.execute <<-SQL
+          create table employees_partitions.p1(
+            id    serial not null primary key
+          );
+        SQL
+      end
+
+      describe "ensure_always_fail_on_insert_exists" do
+        it "generates the db function" do
+          sql_adapter.ensure_always_fail_on_insert_exists
+          result = ActiveRecord::Base.connection.execute <<-SQL
+            SELECT routine_name FROM information_schema.routines
+            WHERE specific_schema NOT IN ('pg_catalog', 'information_schema')
+            AND type_udt_name != 'trigger';
+          SQL
+          result.values.first.should == ["always_fail_on_insert"]
+        end
+      end # ensure_always_fail_on_insert_exists
+
+      describe "create_partition_schema" do
+        it "created schema" do
+          sql_adapter.create_partition_schema
+          check_existence_schema.values.should_not be_blank
+        end
+      end # create_partition_schema
+
+      describe "partition_exists?" do
+
+        context "when partition table don't exist" do
+          it "returns false" do
+            sql_adapter.partition_exists?(1).should be_false
+          end
+        end # when partition table don't exist
+
+        context "when partition table exist" do
+          it "returns true" do
+            create_new_schema
+            create_new_partition_table
+            sql_adapter.partition_exists?(1).should be_true
+          end
+        end # when partition table exist
+      end # partition_exists?
+
+      describe "last_n_partition_names" do
+
+        context "when partition table don't exist" do
+          it "returns empty array" do
+            sql_adapter.last_n_partition_names.should == []
+          end
+        end # when partition table don't exist
+
+        context "when partition table exist" do
+          it "returns partition table name" do
+            create_new_schema
+            create_new_partition_table
+            sql_adapter.last_n_partition_names.should == ["p1"]
+          end
+        end # when partition table exist
+      end
+
+      describe "add_parent_table_rules" do
+        context "when try to insert row into table with rules" do
+          it "raises ActiveRecord::StatementInvalid" do
+            sql_adapter.add_parent_table_rules
+            lambda { ActiveRecord::Base.connection.execute <<-SQL
+                insert into employee (name) values ('name');
+              SQL
+            }.should raise_error(ActiveRecord::StatementInvalid)
+          end
+        end # when try to insert row into table with rules
+      end # add_parent_table_rules
+
+      describe "create_partition_table" do
+        it "created partition table" do
+          create_new_schema
+          lambda {
+            sql_adapter.create_partition_table(1)
+          }.should_not raise_error
+          check_existence_table.values.sort.should == [["employees"], ["p1"]].sort
+        end
+      end # create_partition_table
+
+      describe "drop_partition_table" do
+        it "deleted partition table" do
+          create_new_schema
+          sql_adapter.create_partition_table(1)
+          sql_adapter.drop_partition_table(1)
+          check_existence_table.values.should == [["employees"]]
+        end
+      end # drop_partition_table
+
+      describe "add_partition_table_index" do
+        it "added index for partition table" do
+          create_new_schema
+          sql_adapter.create_partition_table(1)
+          sql_adapter.add_partition_table_index(1)
+          result = ActiveRecord::Base.connection.execute <<-SQL
+            SELECT count(*) FROM pg_class
+            where relname = 'p1_id_udx'
+          SQL
+          result.values.should == [["1"]]
+        end
+      end # add_partition_table_index
+
+      describe "add_references_to_partition_table" do
+        it "added foreign key constraint" do
+          create_new_schema
+          sql_adapter.create_partition_table(1)
+          ActiveRecord::Base.connection.execute <<-SQL
+            create table companies
+            (
+                id               serial not null primary key,
+                name             text null
+            );
+          SQL
+          sql_adapter.add_references_to_partition_table(1)
+          result = ActiveRecord::Base.connection.execute <<-SQL
+            SELECT constraint_type FROM information_schema.table_constraints
+            WHERE table_name = 'p1' AND constraint_name = 'p1_company_id_fkey';
+          SQL
+          result.values.first.should == ["FOREIGN KEY"]
+        end
+      end # add_references_to_partition_table
+
+    end # SqlAdapter
+  end # PartitionedBase
+end # Partitioned

data/spec/partitioned/partitioned_base_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+module Partitioned
+  describe PartitionedBase do
+
+    before(:all) do
+      class Employee < PartitionedBase
+      end
+    end
+
+    after(:all) do
+      Partitioned.send(:remove_const, :Employee)
+    end
+
+    let(:class_partitioned_base) { ::Partitioned::PartitionedBase }
+
+    describe "model is abstract class" do
+
+      it "returns true" do
+        class_partitioned_base.abstract_class.should be_true
+      end
+
+    end # model is abstract class
+
+    describe "partitioned block" do
+
+      let(:data) do
+        class_partitioned_base.configurator_dsl.data
+      end
+
+      context "checks data in the schema_name" do
+
+        it "returns schema_name" do
+          data.schema_name.call(Employee).should == "employees_partitions"
+        end
+
+      end # checks data in the schema_name
+
+      context "checks data in the parent_table_name" do
+
+        it "returns parent_table_name" do
+          data.parent_table_name.call(Employee).should == "employees"
+        end
+
+      end # checks data in the parent_table_name
+
+      context "checks data in the parent_table_schema_name" do
+
+        it "returns parent_table_schema_name" do
+          data.parent_table_schema_name.call(Employee).should == "public"
+        end
+
+      end # checks data in the parent_table_schema_name
+
+      context "checks data in the name_prefix" do
+
+        it "returns name_prefix" do
+          data.name_prefix.call(Employee).should == "p"
+        end
+
+      end # checks data in the name_prefix
+
+      context "checks data in the part_name" do
+
+        it "returns part_name" do
+          data.part_name.call(Employee, 1).should == "p1"
+        end
+
+      end # checks data in the part_name
+
+      context "checks data in the table_name" do
+
+        it "returns table_name" do
+          data.table_name.call(Employee, 1).should == "employees_partitions.p1"
+        end
+
+      end # checks data in the table_name
+
+      context "checks data in the base_name" do
+
+        it "returns base_name" do
+          data.base_name.call(Employee, 1).should == "1"
+        end
+
+      end # checks data in the base_name
+    end # partitioned block
+
+    context "#partition_key_values" do
+
+      before do
+        class_partitioned_base.stub!(:partition_keys).and_return([:id])
+      end
+
+      context "call method with key that represented as a string" do
+
+        it "returns values" do
+          class_partitioned_base.partition_key_values( "id" => 1 ).should == [1]
+        end
+
+      end # call method with key that represented as a string
+
+      context "call method with key that represented as a symbol" do
+
+        it "returns values" do
+          class_partitioned_base.partition_key_values( :id => 2 ).should == [2]
+        end
+
+      end # call method with key that represented as a symbol
+
+    end # #partition_key_values
+
+    context "checks instance methods" do
+
+      before do
+        ActiveRecord::Base.connection.execute <<-SQL
+          create table employees (
+            id               serial not null primary key,
+            created_at       timestamp not null default now(),
+            updated_at       timestamp,
+            name             text not null
+          );
+        SQL
+        Employee.stub!(:partition_keys).and_return([:id])
+        @employee = Employee.new
+      end
+
+      context "partition_table_name" do
+
+        context "call method with attributes key that represented as a string" do
+
+          it "returns employees_partitions.p1" do
+            @employee.stub!(:attributes).and_return("id" => 1)
+            @employee.partition_table_name.should == "employees_partitions.p1"
+          end
+
+        end # call method with attributes key that represented as a string
+
+        context "call method with attributes key that represented as a symbol" do
+
+          it "returns employees_partitions.p2" do
+            @employee.stub!(:attributes).and_return(:id => 2)
+            @employee.partition_table_name.should == "employees_partitions.p2"
+          end
+
+        end # call method with attributes key that represented as a symbol
+
+      end # partition_table_name
+
+      context "dynamic_arel_table" do
+
+        context "call method with attributes key that represented as a string" do
+
+          it "returns arel table name employees_partitions.p1" do
+            @employee.stub!(:attributes).and_return("id" => 1)
+            @employee.dynamic_arel_table.name.should == "employees_partitions.p1"
+          end
+
+        end # call method with attributes key that represented as a string
+
+        context "call method with attributes key that represented as a symbol" do
+
+          it "returns arel table name employees_partitions.p2" do
+            @employee.stub!(:attributes).and_return(:id => 2)
+            @employee.dynamic_arel_table.name.should == "employees_partitions.p2"
+          end
+
+        end # call method with attributes key that represented as a symbol
+
+      end # dynamic_arel_table
+
+    end # checks instance methods
+  end # PartitionedBase
+end # Partitioned

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path("../dummy/config/environment", __FILE__)
+require 'rspec/rails'
+require 'rspec/autorun'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}
+
+RSpec.configure do |config|
+  # ## Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  # If true, the base class of anonymous controllers will be inferred
+  # automatically. This will be the default behavior in future versions of
+  # rspec-rails.
+  config.infer_base_class_for_anonymous_controllers = false
+end

data/spec/support/shared_example_spec_helper_for_integer_key.rb

@@ -0,0 +1,137 @@
+shared_examples_for "check that basic operations with postgres works correctly for integer key" do |class_name|
+
+  let!(:subject) do
+    class_name.reset_column_information
+    class_name
+  end
+
+  context "when try to create one record" do
+
+    it "record created" do
+      lambda { subject.create(:name => 'Phil', :company_id => 3, :integer_field => 2)
+      }.should_not raise_error
+    end
+
+  end # when try to create one record
+
+  context "when try to create one record using new/save" do
+
+    it "record created" do
+      lambda {
+        instance = subject.new(:name => 'Mike', :company_id => 1, :integer_field => 1)
+        instance.save!
+      }.should_not raise_error
+    end
+
+  end # when try to create one record using new/save
+
+  context "when try to create many records" do
+
+    it "records created" do
+      lambda { subject.create_many([
+                                     { :name => 'Alex', :company_id => 2, :integer_field => 4 },
+                                     { :name => 'Aaron', :company_id => 3, :integer_field => 2 }])
+      }.should_not raise_error
+    end
+
+  end # when try to create many records
+
+  context "when try to find a record with the search term is id" do
+
+    it "returns employee name" do
+      subject.find(1).name.should == "Keith"
+    end
+
+  end # when try to find a record with the search term is id
+
+  context "when try to find a record with the search term is name" do
+
+    it "returns employee name" do
+      subject.where(:name => 'Keith').first.name.should == "Keith"
+    end
+
+  end # when try to find a record with the search term is name
+
+  context "when try to find a record which is showing partition table" do
+
+    it "returns employee name" do
+      subject.from_partition(1).find(1).name.should == "Keith"
+    end
+
+  end # when try to find a record which is showing partition table
+
+  context "when try to update a record with id = 1" do
+
+    it "returns updated employee name" do
+      subject.update(1, :name => 'Kevin')
+      subject.find(1).name.should == "Kevin"
+    end
+
+  end # when try to update a record with id = 1
+
+  context "when try to update a record with update_many functions" do
+
+    it "returns updated employee name" do
+      subject.update_many( {
+        { :id => 1, :integer_field => 1, :company_id => 1 } => {
+            :name => 'Alex'
+          }
+      } )
+      subject.find(1).name.should == "Alex"
+    end
+
+    it "returns updated employee name" do
+      rows = [{
+         :id => 1,
+         :integer_field => 1,
+         :company_id => 1,
+         :name => 'Pit',
+      }]
+
+      options = {
+        :set_array => '"name = datatable.name"',
+        :where => '"#{table_name}.id = datatable.id"'
+      }
+      subject.update_many(rows, options)
+      subject.find(1).name.should == "Pit"
+    end
+
+  end # when try to update a record with update_many functions
+
+  context "when try to delete a record with id = 1" do
+
+    it "returns empty array" do
+      subject.delete(1)
+      subject.find(:all).should == []
+    end
+
+  end # when try to delete a record with id = 1
+
+  context "when try to create new record outside the range of partitions" do
+
+    it "raises ActiveRecord::StatementInvalid" do
+      lambda { subject.create_many([{ :name => 'Mark', :company_id => 13, :integer_field => 5 } ])
+      }.should raise_error(ActiveRecord::StatementInvalid)
+    end
+
+  end # when try to create new record outside the range of partitions
+
+  context "when try to update a record outside the range of partitions" do
+
+    it "raises ActiveRecord::RecordNotFound" do
+      lambda { subject.update(100500, :name => 'Kevin')
+      }.should raise_error(ActiveRecord::RecordNotFound)
+    end
+
+  end # when try to update a record outside the range of partitions
+
+  context "when try to find a record outside the range of partitions" do
+
+    it "raises ActiveRecord::StatementInvalid" do
+      lambda { subject.from_partition(8).find(1)
+      }.should raise_error(ActiveRecord::StatementInvalid)
+    end
+
+  end # when try to find a record outside the range of partitions
+
+end # check that basic operations with postgres works correctly for integer key