partitioned 1.1.3 → 1.1.5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    partitioned (1.1.3)
+    partitioned (1.1.4)
       bulk_data_methods (= 1.0.0)
       pg
       rails (>= 3.2.8)
@@ -48,7 +48,7 @@ GEM
     hike (1.2.1)
     i18n (0.6.1)
     journey (1.0.4)
-    jquery-rails (2.1.4)
+    jquery-rails (2.2.0)
       railties (>= 3.0, < 5.0)
       thor (>= 0.14, < 2.0)
     json (1.7.6)
@@ -56,14 +56,14 @@ GEM
       i18n (>= 0.4.0)
       mime-types (~> 1.16)
       treetop (~> 1.4.8)
-    mime-types (1.19)
+    mime-types (1.20.1)
     multi_json (1.5.0)
     pg (0.14.1)
     polyglot (0.3.3)
     rack (1.4.4)
     rack-cache (1.2)
       rack (>= 0.4)
-    rack-ssl (1.3.2)
+    rack-ssl (1.3.3)
       rack
     rack-test (0.6.2)
       rack (>= 1.0)
@@ -88,7 +88,7 @@ GEM
     rspec-core (2.12.2)
     rspec-expectations (2.12.1)
       diff-lcs (~> 1.1.3)
-    rspec-mocks (2.12.1)
+    rspec-mocks (2.12.2)
     rspec-rails (2.12.2)
       actionpack (>= 3.0)
       activesupport (>= 3.0)
@@ -101,7 +101,7 @@ GEM
       multi_json (~> 1.0)
       rack (~> 1.0)
       tilt (~> 1.1, != 1.3.0)
-    thor (0.16.0)
+    thor (0.17.0)
     tilt (1.3.3)
     treetop (1.4.12)
       polyglot

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2012, Fiksu, Inc.
+Copyright (c) 2010-2013, Fiksu, Inc.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/lib/monkey_patch_activerecord.rb

@@ -17,21 +17,26 @@ module ActiveRecord
     # that no changes should be made (since they can't be persisted).
     def destroy
       destroy_associations
-
+      
       if persisted?
         IdentityMap.remove(self) if IdentityMap.enabled?
         pk         = self.class.primary_key
         column     = self.class.columns_hash[pk]
         substitute = connection.substitute_at(column, 0)
-
-        using_arel_table = self.respond_to?(:dynamic_arel_table) ? dynamic_arel_table() : self.class.arel_table
-        relation = self.class.unscoped.where(
-          using_arel_table[pk].eq(substitute))
-
+        
+        if self.class.respond_to?(:dynamic_arel_table)
+          using_arel_table = dynamic_arel_table()
+          relation = ActiveRecord::Relation.new(self.class, using_arel_table).
+            where(using_arel_table[pk].eq(substitute))
+        else
+          using_arel_table = self.class.arel_table
+          relation = self.class.unscoped.where(using_arel_table[pk].eq(substitute))
+        end
+        
         relation.bind_values = [[column, id]]
         relation.delete_all
       end
-
+      
       @destroyed = true
       freeze
     end

data/lib/monkey_patch_postgres.rb

@@ -29,6 +29,9 @@ module ActiveRecord::ConnectionAdapters
   # to take advantage of these SQL builders.
   #
   class PostgreSQLAdapter < AbstractAdapter
+    def partitioned_sql_adapter(model)
+      return Partitioned::PartitionedBase::SqlAdapter.new(model)
+    end
 
     #
     # Returns the sequence name for a table's primary key or some other specified key.

data/lib/monkey_patch_redshift.rb

@@ -0,0 +1,114 @@
+require 'active_record'
+require 'active_record/base'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/redshift_adapter'
+
+#
+# Patching {ActiveRecord::ConnectionAdapters::TableDefinition} and
+# {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter} to add functionality
+# needed to abstract partition specific SQL statements.
+#
+module ActiveRecord::ConnectionAdapters
+  #
+  # Patches extending the postgres adapter with new operations for managing
+  # sequences (and sets of sequence values), schemas and foreign keys.
+  # These should go into AbstractAdapter allowing any database adapter
+  # to take advantage of these SQL builders.
+  #
+  class RedshiftAdapter < AbstractAdapter
+    def partitioned_sql_adapter(model)
+      return Partitioned::PartitionedBase::RedshiftSqlAdapter.new(model)
+    end
+
+    #
+    # Returns the sequence name for a table's primary key or some other specified key.
+    #
+    # the default version strips off the schema name on the table (if it exists), as:
+    #   serial_sequence(table_name, pk || 'id').split('.').last
+    # i can't see any good reason for that -- in fact, it seems completely
+    # broken -- if you have a table public.foos and other.foos, you'll fail to
+    # get the correct schema if you fetch the default schema name from model
+    # associated with other.foos
+    #
+    def default_sequence_name(table_name, pk = nil) #:nodoc:
+      serial_sequence(table_name, pk || 'id')
+    rescue ActiveRecord::StatementInvalid => e
+      "#{table_name}_#{pk || 'id'}_seq"
+    end
+
+    #
+    # Get the next value in a sequence. Used on INSERT operation for
+    # partitioning like by_id because the ID is required before the insert
+    # so that the specific child table is known ahead of time.
+    #
+    # @param [String] sequence_name the name of the sequence to fetch the next value from
+    # @return [Integer] the value from the sequence
+    def next_sequence_value(sequence_name)
+      return execute("select nextval('#{sequence_name}')").field_values("nextval").first.to_i
+    end
+
+    #
+    # Get the some next values in a sequence.
+    #
+    # @param [String] sequence_name the name of the sequence to fetch the next values from
+    # @param [Integer] batch_size count of values.
+    # @return [Array<Integer>] an array of values from the sequence
+    def next_sequence_values(sequence_name, batch_size)
+      result = execute("select nextval('#{sequence_name}') from generate_series(1, #{batch_size})")
+      return result.field_values("nextval").map(&:to_i)
+    end
+
+    #
+    # Causes active resource to fetch the primary key for the table (using next_sequence_value())
+    # just before an insert. We need the prefetch to happen but we don't have enough information
+    # here to determine if it should happen, so Relation::insert has been modified to request of
+    # the ActiveRecord::Base derived class if it requires a prefetch.
+    #
+    # @param [String] table_name the table name to query
+    # @return [Boolean] returns true if the table should have its primary key prefetched.
+    def prefetch_primary_key?(table_name)
+      return false
+    end
+
+    #
+    # Creates a schema given a name.
+    #
+    # @param [String] name the name of the schema.
+    # @param [Hash] options ({}) options for creating a schema
+    # @option options [Boolean] :unless_exists (false) check if schema exists.
+    # @return [optional] undefined
+    def create_schema(name, options = {})
+      if options[:unless_exists]
+        return if execute("select count(*) from pg_namespace where nspname = '#{name}'").getvalue(0,0).to_i > 0
+      end
+      execute("CREATE SCHEMA #{name}")
+    end
+
+    #
+    # Drop a schema given a name.
+    #
+    # @param [String] name the name of the schema.
+    # @param [Hash] options ({}) options for dropping a schema
+    # @option options [Boolean] :if_exists (false) check if schema exists.
+    # @option options [Boolean] :cascade (false) drop dependant objects
+    # @return [optional] undefined
+    def drop_schema(name, options = {})
+      if options[:if_exists]
+        return if execute("select count(*) from pg_namespace where nspname = '#{name}'").getvalue(0,0).to_i == 0
+      end
+      execute("DROP SCHEMA #{name}#{' cascade' if options[:cascade]}")
+    end
+
+    #
+    # Add foreign key constraint to table.
+    #
+    # @param [String] referencing_table_name the name of the table containing the foreign key
+    # @param [String] referencing_field_name the name of foreign key column
+    # @param [String] referenced_table_name the name of the table referenced by the foreign key
+    # @param [String] referenced_field_name (:id) the name of the column referenced by the foreign key
+    # @return [optional] undefined
+    def add_foreign_key(referencing_table_name, referencing_field_name, referenced_table_name, referenced_field_name = :id)
+      execute("ALTER TABLE #{referencing_table_name} add foreign key (#{referencing_field_name}) references #{referenced_table_name}(#{referenced_field_name})")
+    end
+  end
+end

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

@@ -5,6 +5,10 @@ module Partitioned
       # {PartitionManager} to request partitioning information froma
       # centralized source from multi level partitioned models
       class Reader < Partitioned::PartitionedBase::Configurator::Reader
+        
+        alias :base_collect_from_collection :collect_from_collection
+        alias :base_collect :collect
+        
         # configurator for a specific class level
         UsingConfigurator = Struct.new(:model, :sliced_class, :dsl)
 
@@ -20,7 +24,7 @@ module Partitioned
         # @return [Array<Symbol>] fields used to partition this model
         def on_fields
           unless @on_fields
-            @on_fields = using_collect(&:on_field).map(&:to_sym)
+            @on_fields = collect(&:on_field).map(&:to_sym)
           end
           return @on_fields
         end
@@ -67,6 +71,35 @@ module Partitioned
           return using_configurator(index).check_constraint(value)
         end
 
+        def indexes(*partition_key_values)
+          bag = {}
+          partition_key_values.each_with_index do |key_value, index|
+            bag.merge!(using_configurator(index).indexes(key_value))
+          end
+          base_collect_from_collection(*partition_key_values, &:indexes).inject(bag) do |bag, data_index|
+            bag[data_index.field] = (data_index.options || {}) unless data_index.blank?
+            bag
+          end
+        end
+        
+        #
+        # Foreign keys to create on each leaf partition.
+        #
+        def foreign_keys(*partition_key_values)
+          set = Set.new
+          partition_key_values.each_with_index do |key_value, index|
+            set.merge(using_configurator(index).foreign_keys(key_value))
+          end
+          base_collect_from_collection(*partition_key_values, &:foreign_keys).inject(set) do |set, new_items|
+            if new_items.is_a? Array
+              set += new_items
+            else
+              set += [new_items]
+            end
+            set
+          end
+        end
+
         #
         # The name of the child table without the schema name or name prefix.
         #
@@ -117,14 +150,14 @@ module Partitioned
 
         def using_classes
           unless @using_classes
-            @using_classes = collect_from_collection(&:using_classes).inject([]) do |array,new_items|
+            @using_classes = base_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)
+        def collect(*partition_key_values, &block)
           values = []
           using_configurators.each do |using_configurator|
             data = using_configurator.dsl.data
@@ -137,25 +170,10 @@ module Partitioned
               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
+          return base_collect(*partition_key_values, &block) + values
         end
 
-        def using_collect_from_collection(*partition_key_values, &block)
+        def collect_from_collection(*partition_key_values, &block)
           values = []
           using_configurators.each do |using_configurator|
             data = using_configurator.dsl.data
@@ -171,7 +189,7 @@ module Partitioned
               end
             end
           end
-          return values
+          return base_collect_from_collection(*partition_key_values, &block) + values
         end
 
       end

data/lib/partitioned/multi_level/partition_manager.rb

@@ -17,8 +17,6 @@ module Partitioned
         end
       end
 
-      protected
-
       #
       # Create a specific child table that does not currently
       # exist and whose schema (the schema that the table exists in)
@@ -37,6 +35,8 @@ module Partitioned
         end
       end
 
+      protected
+
       #
       # Is the table a child table without itself having any children.
       # generally leaf tables are where all indexes and foreign key

data/lib/partitioned/partitioned_base/configurator/data.rb

@@ -42,7 +42,8 @@ module Partitioned
            :schema_name, :name_prefix, :base_name,
            :part_name, :table_name, :table_alias_name, :parent_table_schema_name,
            :parent_table_name, :check_constraint, :encoded_name,
-           :janitorial_creates_needed, :janitorial_archives_needed, :janitorial_drops_needed
+           :janitorial_creates_needed, :janitorial_archives_needed, :janitorial_drops_needed,
+           :after_partition_table_create_hooks
         
         def initialize
           @on_field = nil
@@ -70,6 +71,8 @@ module Partitioned
           @janitorial_creates_needed = nil
           @janitorial_archives_needed = nil
           @janitorial_drops_needed = nil
+
+          @after_partition_table_create_hooks = []
         end
       end
     end

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

@@ -263,6 +263,16 @@ module Partitioned
           end
         end
 
+        def after_partition_table_create_hook(method_name)
+          if method_name.is_a? Proc
+            data.after_partition_table_create_hooks << method_name
+          else
+            # XXX should be a symbol
+            data.after_partition_table_create_hooks << lambda {|model,*partition_key_values| model.send(method_name, *partition_key_values)}
+          end
+        end
+
+
         #
         # Define the check constraint for a given child table.
         #

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

@@ -30,6 +30,7 @@ module Partitioned
           @janitorial_creates_needed = nil
           @janitorial_archives_needed = nil
           @janitorial_drops_needed = nil
+          @after_partition_table_create_hooks = nil
         end
 
         #
@@ -101,7 +102,11 @@ module Partitioned
         # The full name of a child table defined by the partition key values.
         #
         def table_name(*partition_key_values)
-          return collect_first(*partition_key_values, &:table_name)
+          if partition_key_values.length < 1
+            return model.table_name
+          else
+            return collect_first(*partition_key_values, &:table_name)
+          end
         end
 
         #
@@ -167,6 +172,10 @@ module Partitioned
           return @janitorial_drops_needed
         end
 
+        def run_after_partition_table_create_hooks(*partition_key_values)
+          collect_from_collection(*partition_key_values, &:after_partition_table_create_hooks)
+        end
+
         protected
 
         def configurators

data/lib/partitioned/partitioned_base/partition_manager.rb

@@ -127,6 +127,7 @@ module Partitioned
         create_partition_table(*partition_key_values)
         add_partition_table_index(*partition_key_values)
         add_references_to_partition_table(*partition_key_values)
+        configurator.run_after_partition_table_create_hooks(*partition_key_values)
       end
 
       ##

data/lib/partitioned/partitioned_base/redshift_sql_adapter.rb

@@ -0,0 +1,269 @@
+require 'forwardable'
+
+module Partitioned
+  class PartitionedBase
+    #
+    # SqlAdapter
+    # manages requests of partitioned tables.
+    #
+    class RedshiftSqlAdapter
+      attr_reader :parent_table_class
+
+      def initialize(parent_table_class)
+        @parent_table_class = parent_table_class
+      end
+
+      #
+      # Ensure our function for warning about improper partition usage is in place.
+      #
+      # Name: always_fail_on_insert(text); Type: FUNCTION; Schema: public
+      #
+      # Used to raise an exception explaining why a specific insert (into a parent
+      # table which should never have records) should never be attempted.
+      #
+      def ensure_always_fail_on_insert_exists
+        # XXX nothing can be done here
+      end
+
+      #
+      # Child tables whose parent table is 'foos', typically exist in a schema named foos_partitions.
+      #
+      # *partition_key_values are needed here to support the use of multiple schemas to keep tables in.
+      #
+      def create_partition_schema(*partition_key_values)
+        create_schema(configurator.schema_name, :unless_exists => true)
+      end
+
+      #
+      # Does a specific child partition exist.
+      #
+      def partition_exists?(*partition_key_values)
+        return find(:first,
+                    :from => "pg_tables",
+                    :select => "count(*) as count",
+                    :conditions  => ["schemaname = ? and tablename = ?",
+                                      configurator.schema_name,
+                                      configurator.part_name(*partition_key_values)
+                    ]).count.to_i == 1
+      end
+
+      #
+      # Returns an array of partition table names from last to first limited to
+      # the number of entries requested by its first parameter.
+      #
+      # The magic here is in the overridden method "last_n_partitions_order_by_clause"
+      # which is designed to order a list of partition table names (table names without
+      # their schema name) from last to first.
+      #
+      # If the child table names are the format "pYYYYMMDD" where YYYY is a four digit year, MM is
+      # a month number and DD is a day number, you would use the following to order from last to
+      # first:
+      #   tablename desc
+      #
+      # For child table names of the format "pXXXX" where XXXX is a number, you may want something like:
+      #   substring(tablename, 2)::integer desc
+      #
+      # For clarity, the sql executed is:
+      #    select tablename from pg_tables where schemaname = $1 order by $2 limit $3
+      # where:
+      #  $1 = the name of schema (foos_partitions)
+      #  $2 = the order by clause that would make the greatest table name listed first
+      #  $3 = the parameter 'how_many'
+      #
+      def last_n_partition_names(how_many = 1)
+        return find(:all,
+                    :from => "pg_tables",
+                    :select => :tablename,
+                    :conditions  => ["schemaname = ?", configurator.schema_name],
+                    :order => last_n_partitions_order_by_clause,
+                    :limit => how_many).map(&:tablename)
+      end
+
+      #
+      # Override this or order the tables from last (greatest value? greatest date?) to first.
+      #
+      def last_n_partitions_order_by_clause
+        return configurator.last_partitions_order_by_clause
+      end
+
+      #
+      # Used to create the parent table rule to ensure.
+      #
+      # This will cause an error on attempt to insert into the parent table.
+      #
+      # We want all records to exist in one of the child tables so the
+      # query planner can optimize access to the records.
+      #
+      def add_parent_table_rules(*partition_key_values)
+        # XXX nothing can be done here
+      end
+
+      #
+      # The name of the table (schemaname.childtablename) given the check constraint values.
+      #
+      def partition_table_name(*partition_key_values)
+        return configurator.table_name(*partition_key_values)
+      end
+
+      #
+      # A reasonable alias for the partition table
+      #
+      def partition_table_alias_name(*partition_key_values)
+        return configurator.table_alias_name(*partition_key_values)
+      end
+
+      #
+      # Create a single child table.
+      #
+      def create_partition_table(*partition_key_values)
+        execute("select * into #{configurator.table_name(*partition_key_values)} from #{configurator.parent_table_name(*partition_key_values)} where false")
+      end
+
+      #
+      # Remove a specific single child table.
+      #
+      def drop_partition_table(*partition_key_values)
+        drop_table(configurator.table_name(*partition_key_values))
+      end
+
+      #
+      # Add indexes that must exist on child tables. Only leaf child tables
+      # need indexes as parent table indexes are not used in postgres.
+      #
+      def add_partition_table_index(*partition_key_values)
+        configurator.indexes(*partition_key_values).each do |field,options|
+          used_options = options.clone
+          unless used_options.has_key?(:name)
+            name = [*field].join('_')
+            used_options[:name] = used_options[:unique] ? unique_index_name(name, *partition_key_values) : index_name(name, *partition_key_values)
+          end
+          add_index(partition_table_name(*partition_key_values), field, used_options)
+        end
+      end
+
+      #
+      # Used when creating the name of a SQL rule.
+      #
+      def parent_table_rule_name(name, suffix = "rule", *partition_key_values)
+        return "#{configurator.table_name(*partition_key_values).gsub(/[.]/, '_')}_#{name}_#{suffix}"
+      end
+
+      #
+      # Used to create index names.
+      #
+      def index_name(name, *partition_key_values)
+        return "#{configurator.part_name(*partition_key_values)}_#{name}_idx"
+      end
+
+      #
+      # Used to create index names.
+      #
+      def unique_index_name(name, *partition_key_values)
+        return "#{configurator.part_name(*partition_key_values)}_#{name}_udx"
+      end
+
+      #
+      # This is here for derived classes to set up references to added columns
+      # (or columns in the parent that need foreign key constraints).
+      #
+      # Foreign keys are not inherited in postgres. So, a parent table
+      # of the form:
+      #
+      #   -- this is the referenced table
+      #   create table companies
+      #   (
+      #       id               serial not null primary key,
+      #       created_at       timestamp not null default now(),
+      #       updated_at       timestamp,
+      #       name             text not null
+      #   );
+      #
+      #   -- this is the parent table
+      #   create table employees
+      #   (
+      #       id               serial not null primary key,
+      #       created_at       timestamp not null default now(),
+      #       updated_at       timestamp,
+      #       name             text not null,
+      #       company_id       integer not null references companies,
+      #       supervisor_id    integer not null references employees
+      #   );
+      #
+      #   -- some children
+      #   create table employees_of_company_1 ( CHECK ( company_id = 1 ) ) INHERITS (employees);
+      #   create table employees_of_company_2 ( CHECK ( company_id = 2 ) ) INHERITS (employees);
+      #   create table employees_of_company_3 ( CHECK ( company_id = 3 ) ) INHERITS (employees);
+      #
+      # Since postgres does not inherit referential integrity from parent tables, the following
+      # insert will work:
+      #    insert into employees_of_company_1 (name, company_id, supervisor_id) values ('joe', 1, 10);
+      # even if there is no record in companies with id = 1 and there is no record in employees with id = 10
+      #
+      # For proper referential integrity handling you must do the following:
+      #   ALTER TABLE employees_of_company_1 add foreign key (company_id) references companies(id)
+      #   ALTER TABLE employees_of_company_2 add foreign key (company_id) references companies(id)
+      #   ALTER TABLE employees_of_company_3 add foreign key (company_id) references companies(id)
+      #
+      #   ALTER TABLE employees_of_company_1 add foreign key (supervisor_id) references employees_of_company_1(id)
+      #   ALTER TABLE employees_of_company_2 add foreign key (supervisor_id) references employees_of_company_2(id)
+      #   ALTER TABLE employees_of_company_3 add foreign key (supervisor_id) references employees_of_company_3(id)
+      #
+      # The second set of alter tables brings up a good another consideration about postgres references and partitions.
+      # postgres will not follow references to a child table.  So, a foreign key reference to "employees" in this
+      # set of alter statements would not work because postgres would expect the table "employees" to have
+      # the specific referenced record, but the record really exists in a child of employees.  So, the alter statement
+      # forces the reference check on the specific child table we know must contain this employees supervisor (since
+      # such a supervisor would have to work for the same company in our model).
+      #
+      def add_references_to_partition_table(*partition_key_values)
+        configurator.foreign_keys(*partition_key_values).each do |foreign_key|
+          add_foreign_key(partition_table_name(*partition_key_values),
+                          foreign_key.referencing_field,
+                          foreign_key.referenced_table,
+                          foreign_key.referenced_field)
+        end
+      end
+
+      ##
+      # :method: connection
+      # delegated to the connection of the parent table class
+
+      ##
+      # :method: execute
+      # delegated to the connection of the parent table class
+
+      ##
+      # :method: create_schema
+      # delegated to the connection of the parent table class
+
+      ##
+      # :method: drop_schema
+      # delegated to the connection of the parent table class
+
+      ##
+      # :method: add_index
+      # delegated to the connection of the parent table class
+
+      ##
+      # :method: remove_index
+      # delegated to the connection of the parent table class
+
+      ##
+      # :method: transaction
+      # delegated to the connection of the parent table class
+
+      ##
+      # :method: find_by_sql
+      # delegated to the connection of the parent table class
+
+      ##
+      # :method: find
+      # delegated to the connection of the parent table class
+
+      extend Forwardable
+      def_delegators :parent_table_class, :connection, :find_by_sql, :transaction, :find, :configurator
+      def_delegators :connection, :execute, :add_index, :remove_index, :create_schema, :drop_schema, :add_foreign_key,
+                     :create_table, :drop_table
+    end
+  end
+end

data/lib/partitioned/partitioned_base/sql_adapter.rb

@@ -93,7 +93,7 @@ module Partitioned
       # Override this or order the tables from last (greatest value? greatest date?) to first.
       #
       def last_n_partitions_order_by_clause
-        return configurator.last_n_partitions_order_by_clause
+        return configurator.last_partitions_order_by_clause
       end
 
       #
@@ -110,10 +110,10 @@ module Partitioned
         insert_redirector_name = parent_table_rule_name("insert", "redirector", *partition_key_values)
         sql = <<-SQL
           CREATE OR REPLACE RULE #{insert_redirector_name} AS
-            ON INSERT TO #{configurator.parent_table_name(*partition_key_values)}
+            ON INSERT TO #{configurator.table_name(*partition_key_values)}
             DO INSTEAD
             (
-               SELECT always_fail_on_insert('#{configurator.parent_table_name(*partition_key_values)}')
+               SELECT always_fail_on_insert('#{configurator.table_name(*partition_key_values)}')
             )
         SQL
         execute(sql)
@@ -141,7 +141,8 @@ module Partitioned
                        :id => false,
                        :options => "INHERITS (#{configurator.parent_table_name(*partition_key_values)})"
                      }) do |t|
-          t.check_constraint configurator.check_constraint(*partition_key_values)
+          constraint = configurator.check_constraint(*partition_key_values)
+          t.check_constraint constraint if constraint
         end
       end
 
@@ -171,7 +172,7 @@ module Partitioned
       # Used when creating the name of a SQL rule.
       #
       def parent_table_rule_name(name, suffix = "rule", *partition_key_values)
-        return "#{configurator.parent_table_name(*partition_key_values).gsub(/[.]/, '_')}_#{name}_#{suffix}"
+        return "#{configurator.table_name(*partition_key_values).gsub(/[.]/, '_')}_#{name}_#{suffix}"
       end
 
       #

data/lib/partitioned/partitioned_base.rb

@@ -103,10 +103,23 @@ module Partitioned
     #
     # @return [{SqlAdapter}] the object used to create sql statements for this partitioned model
     def self.sql_adapter
-      @sql_adapter = self::SqlAdapter.new(self) unless @sql_adapter.present?
+      @sql_adapter ||= connection.partitioned_sql_adapter(self)
       return @sql_adapter
     end
+    
+    def self.arel_table_from_key_values(partition_key_values, as = nil)
+      @arel_tables ||= {}
+      new_arel_table = @arel_tables[[partition_key_values, as]]
+      
+      unless new_arel_table
+        arel_engine_hash = {:engine => self.arel_engine, :as => as}
+        new_arel_table = Arel::Table.new(self.partition_table_name(*partition_key_values), arel_engine_hash)
+        @arel_tables[[partition_key_values, as]] = new_arel_table
+      end
 
+      return new_arel_table
+    end
+    
     #
     # In activerecord 3.0 we need to supply an Arel::Table for the key value(s) used
     # to determine the specific child table to access.
@@ -115,13 +128,8 @@ module Partitioned
     # @param [String] as (nil) the name of the table associated with this Arel::Table
     # @return [Arel::Table] the generated Arel::Table
     def self.dynamic_arel_table(values, as = nil)
-      @arel_tables ||= {}
       key_values = self.partition_key_values(values)
-      new_arel_table = @arel_tables[key_values]
-      arel_engine_hash = {:engine => self.arel_engine}
-      arel_engine_hash[:as] = as unless as.blank?
-      new_arel_table = Arel::Table.new(self.partition_table_name(*key_values), arel_engine_hash)
-      return new_arel_table
+      return arel_table_from_key_values(key_values, as)
     end
 
     #
@@ -131,9 +139,8 @@ module Partitioned
     # @param [String] as (nil) the name of the table associated with the Arel::Table
     # @return [Arel::Table] the generated Arel::Table
     def dynamic_arel_table(as = nil)
-      symbolized_attributes = attributes.symbolize_keys
-      key_values = Hash[*self.class.partition_keys.map{|name| [name,symbolized_attributes[name]]}.flatten]
-      return self.class.dynamic_arel_table(key_values, as)
+      key_values = self.class.partition_key_values(attributes)
+      return self.class.arel_table_from_key_values(key_values, as)
     end
 
     #
@@ -149,10 +156,9 @@ module Partitioned
     #
     # @param [*Array<Object>] partition_field the field values to partition on
     # @return [Hash] the scoping
-    def self.from_partition(*partition_field)
-      table_alias_name = partition_table_alias_name(*partition_field)
-      from("#{partition_table_name(*partition_field)} AS #{table_alias_name}").
-        tap{|relation| relation.table.table_alias = table_alias_name}
+    def self.from_partition(*partition_key_values)
+      table_alias_name = partition_table_alias_name(*partition_key_values)
+      return ActiveRecord::Relation.new(self, self.arel_table_from_key_values(partition_key_values, table_alias_name))
     end
 
     #
@@ -177,10 +183,8 @@ module Partitioned
     #
     # @param [*Array<Object>] partition_field the field values to partition on
     # @return [Hash] the scoping
-    def self.from_partition_without_alias(*partition_field)
-      table_alias_name = partition_table_name(*partition_field)
-      from(table_alias_name).
-        tap{|relation| relation.table.table_alias = table_alias_name}
+    def self.from_partition_without_alias(*partition_key_values)
+      return ActiveRecord::Relation.new(self, self.arel_table_from_key_values(partition_key_values, nil))
     end
 
     #
@@ -305,7 +309,7 @@ module Partitioned
       # A reasonable alias for this table
       #
       partition.table_alias_name lambda {|model, *partition_key_values|
-        return model.configurator.parent_table_name(*partition_key_values).gsub('.', '_')
+        return model.table_name
       }
 
       #

data/lib/partitioned/version.rb

@@ -1,4 +1,4 @@
 module Partitioned
   # the current version of this gem
-  VERSION = "1.1.3"
+  VERSION = "1.1.5"
 end

data/lib/partitioned.rb

@@ -1,5 +1,6 @@
 require 'monkey_patch_activerecord'
 require 'monkey_patch_postgres'
+require 'monkey_patch_redshift'
 
 require 'partitioned/active_record_overrides'
 require 'partitioned/partitioned_base/configurator.rb'
@@ -9,6 +10,7 @@ require 'partitioned/partitioned_base.rb'
 require 'partitioned/partitioned_base/configurator/reader'
 require 'partitioned/partitioned_base/partition_manager'
 require 'partitioned/partitioned_base/sql_adapter'
+require 'partitioned/partitioned_base/redshift_sql_adapter'
 
 require 'partitioned/by_time_field'
 require 'partitioned/by_yearly_time_field'

data/partitioned.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
  s.name        = 'partitioned'
  s.version     = Partitioned::VERSION
  s.license     = 'New BSD License'
- s.date        = '2013-10-14'
+ s.date        = '2013-02-04'
  s.summary     = "Postgres table partitioning support for ActiveRecord."
  s.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."
  s.authors     = ["Keith Gabryelski", "Aleksandr Dembskiy"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: partitioned
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.5
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-14 00:00:00.000000000 Z
+date: 2013-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -106,6 +106,7 @@ files:
 - init.rb
 - lib/monkey_patch_activerecord.rb
 - lib/monkey_patch_postgres.rb
+- lib/monkey_patch_redshift.rb
 - lib/partitioned.rb
 - lib/partitioned/active_record_overrides.rb
 - lib/partitioned/by_created_at.rb
@@ -127,6 +128,7 @@ files:
 - lib/partitioned/partitioned_base/configurator/dsl.rb
 - lib/partitioned/partitioned_base/configurator/reader.rb
 - lib/partitioned/partitioned_base/partition_manager.rb
+- lib/partitioned/partitioned_base/redshift_sql_adapter.rb
 - lib/partitioned/partitioned_base/sql_adapter.rb
 - lib/partitioned/version.rb
 - lib/tasks/desirable_tasks.rake
@@ -201,7 +203,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Postgres table partitioning support for ActiveRecord.