partitioned 0.8.0

data/lib/partitioned/by_created_at.rb

@@ -0,0 +1,13 @@
+module Partitioned
+  #
+  # partition tables by created_at grouping them by week, with
+  # a week defined as seven days starting on Monday.
+  #
+  class ByCreatedAt < ByWeeklyTimeField
+    self.abstract_class = true
+
+    def self.partition_time_field
+      return :created_at
+    end
+  end
+end

data/lib/partitioned/by_foreign_key.rb

@@ -0,0 +1,21 @@
+module Partitioned
+  class ByForeignKey < ByIntegerField
+    self.abstract_class = true
+
+    def self.partition_integer_field
+      return partition_foreign_key
+    end
+
+    def self.partition_foreign_key
+      raise MethodNotImplemented.new(self, :partition_foreign_key)
+    end
+
+    partitioned do |partition|
+      partition.foreign_key lambda {|model, foreign_key_value|
+        return Configurator::Data::ForeignKey.new(model.partition_foreign_key,
+                                                  ActiveSupport::Inflector::pluralize(model.partition_foreign_key.to_s.sub(/_id$/,'')),
+                                                  :id)
+      }
+    end
+  end
+end

data/lib/partitioned/by_id.rb

@@ -0,0 +1,35 @@
+module Partitioned
+  #
+  # table partitioning by id.  this partitioning breaks up data by
+  # the value of its primary key.  a specific record's child table
+  # is determined by the number resulting from the integer math:
+  #   ID / ById::partition_table_size * ById::partition_table_size
+  # 
+  class ById < ByIntegerField
+    self.abstract_class = true
+
+    #
+    # specific to this partitioning, we need to prefetch the primary key (id)
+    # before we attempt to do the insert because the insert wants to know the
+    # name of the specific child table to access.
+    #
+    def self.prefetch_primary_key?
+      return true
+    end
+
+    #
+    # the number of records in each child table.
+    #
+    def self.partition_table_size
+      return 10000000
+    end
+
+    def self.partition_integer_field
+      return :id
+    end
+
+    partitioned do |partition|
+      partition.index :id, :unique => true
+    end
+  end
+end

data/lib/partitioned/by_integer_field.rb

@@ -0,0 +1,32 @@
+module Partitioned
+  class ByIntegerField < PartitionedBase
+    self.abstract_class = true
+
+    def self.partition_table_size
+      return 1
+    end
+
+    def self.partition_integer_field
+      raise MethodNotImplemented.new(self, :partition_integer_field)
+    end
+
+    def self.partition_normalize_key_value(integer_field_value)
+      return integer_field_value / partition_table_size * partition_table_size
+    end
+
+    partitioned do |partition|
+      partition.on lambda {|model| return model.partition_integer_field }
+
+      partition.order "substring(tablename, 2)::integer desc"
+
+      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

data/lib/partitioned/by_monthly_time_field.rb

@@ -0,0 +1,23 @@
+module Partitioned
+  #
+  # partition tables by a time field grouping them by week, with
+  # a week defined as seven days starting on Monday.
+  #
+  class ByMonthlyTimeField < ByTimeField
+    self.abstract_class = true
+
+    def self.partition_normalize_key_value(time_value)
+      return time_value.at_beginning_of_month
+    end
+
+    def self.partition_table_size
+      return 1.month
+    end
+
+    partitioned do |partition|
+      partition.base_name lambda { |model, time_field|
+        return model.partition_normalize_key_value(time_field).strftime('%Y%m')
+      }
+    end
+  end
+end

data/lib/partitioned/by_time_field.rb

@@ -0,0 +1,65 @@
+module Partitioned
+  #
+  # partition tables by a time field grouping them by day
+  #
+  class ByTimeField < PartitionedBase
+    self.abstract_class = true
+
+    #
+    # generate an enumerable that represents all the dates between
+    # start_date and end_date skipping step
+    #
+    # this can be used to calls that take an enumerable like create_infrastructure
+    #
+    def self.partition_generate_range(start_date, end_date, step = :default)
+      step = partition_table_size if step == :default
+      current_date = partition_normalize_key_value(start_date)
+      dates = []
+      while current_date <= end_date
+        dates << current_date
+        current_date += step
+      end
+      return dates
+    end
+
+    #
+    # normalize the value to the current day
+    #
+    def self.partition_normalize_key_value(time_value)
+      return time_value.to_date
+    end
+
+    #
+    # the size of the partition, 1.day
+    #
+    def self.partition_table_size
+      return 1.day
+    end
+
+    #
+    # abstract -- implement in a derived clas.
+    # the name of the time-related field we will use to partition child tables
+    #
+    def self.partition_time_field
+      raise MethodNotImplemented.new(self, :partition_time_field)
+    end
+
+    partitioned do |partition|
+      partition.on lambda {|model| model.partition_time_field}
+
+      partition.index lambda {|model, time_field|
+        return Configurator::Data::Index.new(model.partition_time_field, {})
+      }
+
+      partition.order 'tablename desc'
+
+      partition.base_name lambda { |model, time_field|
+        return model.partition_normalize_key_value(time_field).strftime('%Y%m%d')
+      }
+      partition.check_constraint lambda { |model, time_field|
+        date = model.partition_normalize_key_value(time_field)
+        return "#{model.partition_time_field} >= '#{date.strftime}' AND #{model.partition_time_field} < '#{(date + model.partition_table_size).strftime}'"
+      }
+    end
+  end
+end

data/lib/partitioned/by_weekly_time_field.rb

@@ -0,0 +1,30 @@
+module Partitioned
+  #
+  # partition tables by a time field grouping them by week, with
+  # a week defined as seven days starting on Monday.
+  #
+  class ByWeeklyTimeField < ByTimeField
+    self.abstract_class = true
+
+    #
+    # normalize a partition key value by week.  We've picked
+    # the begining of the week to key on, which is Monday.
+    #
+    def self.partition_normalize_key_value(time_value)
+      return time_value.at_beginning_of_week
+    end
+
+    #
+    # The size of the partition table, 7 days (1.week)
+    # 
+    def self.partition_table_size
+      return 1.week
+    end
+
+    partitioned do |partition|
+      partition.base_name lambda { |model, time_field|
+        return model.partition_normalize_key_value(time_field).strftime('%Y%m%d')
+      }
+    end
+  end
+end

data/lib/partitioned/multi_level.rb

@@ -0,0 +1,20 @@
+module Partitioned
+  #
+  # table partitioning by a referenced id column which itself is partitioned
+  # further weekly by a date column.
+  # 
+  class MultiLevel < PartitionedBase
+    self.abstract_class = true
+
+    #
+    # Normalize the values for the each of using class.
+    #
+    def self.partition_normalize_key_value(values)
+      normalized_values = []
+      [*values].each_with_index do |value,index|
+        normalized_values << configurator.using_class(index).partition_normalize_key_value(value)
+      end
+      return normalized_values
+    end
+  end
+end

data/lib/partitioned/multi_level/configurator/data.rb

@@ -0,0 +1,14 @@
+module Partitioned
+  class MultiLevel
+    module Configurator
+      class Data < Partitioned::PartitionedBase::Configurator::Data
+        attr_accessor :using_classes
+
+        def initialize
+          super
+          @using_classes = []
+        end
+      end
+    end
+  end
+end

data/lib/partitioned/multi_level/configurator/dsl.rb

@@ -0,0 +1,32 @@
+module Partitioned
+  class MultiLevel
+    module Configurator
+      class Dsl < Partitioned::PartitionedBase::Configurator::Dsl
+        class InvalidForMultiLevelPartitioning < StandardError
+          def initialize(model, dsl_key, remedy)
+            super("#{model.name}: '#{dsl_key}' is not valid for multi-level partitioning.  #{remedy}")
+          end
+        end
+
+        attr_reader :data, :model
+
+        def initialize(most_derived_activerecord_class)
+          super(most_derived_activerecord_class, Partitioned::MultiLevel::Configurator::Data)
+          @using_classes = []
+        end
+
+        #
+        # Definition of classes which will be used at multi level partitioning.
+        #
+        def using_classes(*classes)
+          data.using_classes += [*classes]
+        end
+
+        def on(*ignored)
+          raise InvalidForMultiLevelPartitioning.new(model, :on, "the partitioned keyword 'using' is used to define multi-level partitioned tables.")
+        end
+        
+      end
+    end
+  end
+end

data/lib/partitioned/multi_level/configurator/reader.rb

@@ -0,0 +1,162 @@
+module Partitioned
+  class MultiLevel
+    module Configurator
+      class Reader < Partitioned::PartitionedBase::Configurator::Reader
+        UsingConfigurator = Struct.new(:model, :sliced_class, :dsl)
+        def initialize(most_derived_activerecord_class)
+          super
+          @using_classes = nil
+          @using_configurators = nil
+        end
+
+        #
+        # The field used to partition child tables.
+        #
+        def on_fields
+          unless @on_fields
+            @on_fields = using_collect(&:on_field).map(&:to_sym)
+          end
+          return @on_fields
+        end
+
+        #
+        # The schema name of the table who is the direct ancestor of a child table.
+        #
+        def parent_table_schema_name(*partition_key_values)
+          if partition_key_values.length <= 1
+            return super
+          end
+
+          return schema_name
+        end
+
+        #
+        # The table name of the table who is the direct ancestor of a child table.
+        #
+        def parent_table_name(*partition_key_values)
+          if partition_key_values.length <= 1
+            return super
+          end
+
+          # [0...-1] is here because the base name for this parent table is defined by the remove the leaf key value
+          # that is:
+          # current top level table name: public.foos
+          # child schema area: foos_partitions
+          # current partition classes: ByCompanyId then ByCreatedAt
+          # current key values:
+          #   company_id: 42
+          #   created_at: 2011-01-03
+          # child table name: foos_partitions.p42_20110103
+          # parent table: foos_partitions.p42
+          # grand parent table: public.foos
+          return parent_table_schema_name(*partition_key_values) + '.p' + base_name(*partition_key_values[0...-1])
+        end
+
+        #
+        # Define the check constraint for a given child table.
+        #
+        def check_constraint(*partition_key_values)
+          index = partition_key_values.length - 1
+          value = partition_key_values[index]
+          return using_configurator(index).check_constraint(value)
+        end
+
+        #
+        # The name of the child table without the schema name or name prefix.
+        #
+        def base_name(*partition_key_values)
+          parts = []
+          partition_key_values.each_with_index do |value,index|
+            parts << using_configurator(index).base_name(value)
+          end
+          return parts.join('_')
+        end
+
+        def using_configurator(index)
+          return using_class(index).configurator
+        end
+
+        def using_class(index)
+          return using_classes[index]
+        end
+
+
+        protected
+
+        def using_configurators
+          unless @using_configurators
+            @using_configurators = []
+            using_classes.each do |using_class|
+              using_class.ancestors.each do |ancestor|
+                next if ancestor.class == Module
+                @using_configurators << UsingConfigurator.new(using_class, ancestor, ancestor::configurator_dsl) if ancestor::configurator_dsl
+                break if ancestor == Partitioned::PartitionedBase
+              end
+            end
+          end
+          return @using_configurators
+        end
+
+        def using_classes
+          unless @using_classes
+            @using_classes = collect_from_collection(&:using_classes).inject([]) do |array,new_items|
+              array += [*new_items]
+            end.to_a
+          end
+          return @using_classes
+        end
+
+        def using_collect(*partition_key_values, &block)
+          values = []
+          using_configurators.each do |using_configurator|
+            data = using_configurator.dsl.data
+            intermediate_value = block.call(data) rescue nil
+            if intermediate_value.is_a? Proc
+              values << intermediate_value.call(using_configurator.model, *partition_key_values)
+            elsif intermediate_value.is_a? String
+              values << eval("\"#{intermediate_value}\"")
+            else
+              values << intermediate_value unless intermediate_value.blank?
+            end
+          end
+          return values
+        end
+
+        def using_collect_first(*partition_key_values, &block)
+          using_configurators.each do |using_configurator|
+            data = using_configurator.dsl.data
+            intermediate_value = block.call(data) rescue nil
+            if intermediate_value.is_a? Proc
+              return intermediate_value.call(using_configurator.model, *partition_key_values)
+            elsif intermediate_value.is_a? String
+              return eval("\"#{intermediate_value}\"")
+            else
+              return intermediate_value unless intermediate_value.nil?
+            end
+          end
+          return nil
+        end
+
+        def using_collect_from_collection(*partition_key_values, &block)
+          values = []
+          using_configurators.each do |using_configurator|
+            data = using_configurator.dsl.data
+            intermediate_values = []
+            intermediate_values = block.call(data) rescue nil
+            [*intermediate_values].each do |intermediate_value|
+              if intermediate_value.is_a? Proc
+                values << intermediate_value.call(using_configurator.model, *partition_key_values)
+              elsif intermediate_value.is_a? String
+                values << eval("\"#{intermediate_value}\"")
+              else
+                values << intermediate_value unless intermediate_value.blank?
+              end
+            end
+          end
+          return values
+        end
+
+      end
+    end
+  end
+end