partitioned 1.3.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb273afc943e89b665d5102b95da5edb8a08ece3
-  data.tar.gz: 82acc9f8f6adf56e2f9819aa2a6162f83f932183
+  metadata.gz: be864b7e40e4e6c504bf98b195a564bde6d076b4
+  data.tar.gz: b79141c1dc5742385d9426f7a6fcf176844642ec
 SHA512:
-  metadata.gz: fc7a3eb02f86a030908f2bded67c3ad0569b582b884f4226e5385f43866827fec51d671f2f06b2a1768df52fbafb0be3ce99dc8e3acc0cd95621ec3f02b0e796
-  data.tar.gz: 65007a35629ed9f656e16d29e97e07b4d0985fb6ada1d1a2913d5380ce2e4add70f46759af5a4f8141956e857aa4542fefeeec49b5b348f69e86f6edcdd1dbf3
+  metadata.gz: b0a74962101fbff55ae9edc9a8203088fca7aaa078b3bbac3594a03d3d3c8bb122f545cb984c5ad5a897ffbe80c557d530180cd2b0a0af5e353ba0bb469adcdc
+  data.tar.gz: 06c0780a190219771c06f27091774395eb682e126bf458dcb4cc1091a41b6ece5e3d104ed343684eae41e50259c6e7fc167e7ee40b9833b0460d16e036f7d2bb

data/.gitignore

@@ -1,3 +1,7 @@
 .ruby-version
 Gemfile.lock
 /spec/dummy/log
+/pkg
+/.bundle
+/spec/dummy/db/structure.sql
+/spec/dummy/db/schema.rb

data/.travis.yml

@@ -9,7 +9,6 @@ rvm:
   - 2.0.0
   - 2.1.7
 
-before_script:
-  - createdb part_test
+before_script: travis/before.sh
 
 script: bundle exec rspec

data/lib/monkey_patch_activerecord.rb

@@ -14,101 +14,135 @@ module ActiveRecord
   # Patches for Persistence to allow certain partitioning (that related to the primary key) to work.
   #
   module Persistence
-    # Deletes the record in the database and freezes this instance to reflect
-    # 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)
-        
-        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
+    # This method is patched to provide a relation referencing the partition instead
+    # of the parent table.
+    def relation_for_destroy
+      pk         = self.class.primary_key
+      column     = self.class.columns_hash[pk]
+      substitute = self.class.connection.substitute_at(column, 0)
+
+      # ****** BEGIN PARTITIONED PATCH ******
+      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
+        # ****** END PARTITIONED PATCH ******
+        relation = self.class.unscoped.where(
+                                             self.class.arel_table[pk].eq(substitute))
+        # ****** BEGIN PARTITIONED PATCH ******
       end
-      
-      @destroyed = true
-      freeze
-    end
+      # ****** END PARTITIONED PATCH ******
 
-    # Updates the associated record with values matching those of the instance attributes.
-    # Returns the number of affected rows.
-    def update(attribute_names = @attributes.keys)
-      attributes_with_values = arel_attributes_values(false, false, attribute_names)
-      return 0 if attributes_with_values.empty?
-      klass = self.class
-      using_arel_table = self.respond_to?(:dynamic_arel_table) ? dynamic_arel_table() : klass.arel_table
-      stmt = klass.unscoped.where(using_arel_table[klass.primary_key].eq(id)).arel.compile_update(attributes_with_values)
-      klass.connection.update stmt
+      relation.bind_values = [[column, id]]
+      relation
     end
 
-    #
-    # patch the create method to prefetch the primary key if needed
-    #
-    def create
+    # This method is patched to prefetch the primary key (if necessary) and to ensure
+    # that the partitioning attributes are always included (AR will exclude them
+    # if the db column's default value is the same as the new record's value).
+    def _create_record(attribute_names = @attributes.keys)
+      # ****** BEGIN PARTITIONED PATCH ******
       if self.id.nil? && self.class.respond_to?(:prefetch_primary_key?) && self.class.prefetch_primary_key?
-        self.id = connection.next_sequence_value(self.class.sequence_name)
+        self.id = self.class.connection.next_sequence_value(self.class.sequence_name)
+        attribute_names |= ["id"]
+      end
+
+      if self.class.respond_to?(:partition_keys)
+        attribute_names |= self.class.partition_keys.map(&:to_s)
       end
+      # ****** END PARTITIONED PATCH ******
 
-      attributes_values = arel_attributes_values(!id.nil?)
+      attributes_values = arel_attributes_with_values_for_create(attribute_names)
 
       new_id = self.class.unscoped.insert attributes_values
+      self.id ||= new_id if self.class.primary_key
 
-      self.id ||= new_id
-
-      IdentityMap.add(self) if IdentityMap.enabled?
       @new_record = false
       id
     end
-  end
- 
-  #
-  # A patch to QueryMethods to change default behavior of select
-  # to use the Relation's Arel::Table.
-  #
+
+    # Updates the associated record with values matching those of the instance attributes.
+    # Returns the number of affected rows.
+    # NOTE(hofer): This monkeypatch intended for activerecord 4.0.  Based on this code:
+    # https://github.com/rails/rails/blob/4-0-stable/activerecord/lib/active_record/persistence.rb#L487
+    def _update_record(attribute_names = @attributes.keys)
+      attributes_with_values = arel_attributes_with_values_for_update(attribute_names)
+      if attributes_with_values.empty?
+        0
+      else
+        klass = self.class
+        column_hash = klass.connection.schema_cache.columns_hash klass.table_name
+        db_columns_with_values = attributes_with_values.map { |attr,value|
+          real_column = column_hash[attr.name]
+          [real_column, value]
+        }
+        bind_attrs = attributes_with_values.dup
+        bind_attrs.keys.each_with_index do |column, i|
+          real_column = db_columns_with_values[i].first
+          bind_attrs[column] = klass.connection.substitute_at(real_column, i)
+        end
+
+        # ****** BEGIN PARTITIONED PATCH ******
+        if self.respond_to?(:dynamic_arel_table)
+          using_arel_table = dynamic_arel_table()
+          stmt = klass.unscoped.where(using_arel_table[klass.primary_key].eq(id_was || id)).arel.compile_update(bind_attrs)
+
+          # NOTE(hofer): The stmt variable got set up using
+          # klass.arel_table as its arel value.  So arel_table.name is
+          # what gets used to construct the update statement.  Here we
+          # set it to the specific partition name for this record so
+          # that the update gets run just on that partition, not on
+          # the parent one (which can cause performance issues).
+          begin
+            klass.arel_table.name = partition_table_name()
+            klass.connection.update stmt, 'SQL', db_columns_with_values
+          ensure
+            klass.arel_table.name = klass.table_name
+          end
+        else
+          # Original lines:
+          stmt = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(id_was || id)).arel.compile_update(bind_attrs)
+          klass.connection.update stmt, 'SQL', db_columns_with_values
+        end
+        # ****** END PARTITIONED PATCH ******
+      end
+    end
+
+  end # module Persistence
+
   module QueryMethods
 
+    # This method is patched to change the default behavior of select
+    # to use the Relation's Arel::Table
     def build_select(arel, selects)
-      unless selects.empty?
-        @implicit_readonly = false
-        arel.project(*selects)
+      if !selects.empty?
+        expanded_select = selects.map do |field|
+          columns_hash.key?(field.to_s) ? arel_table[field] : field
+        end
+        arel.project(*expanded_select)
       else
+        # ****** BEGIN PARTITIONED PATCH ******
+        # Original line:
+        # arel.project(@klass.arel_table[Arel.star])
         arel.project(table[Arel.star])
+        # ****** END PARTITIONED PATCH ******
       end
     end
 
-  end
+  end # module QueryMethods
 
-  #
-  # Patches for relation to allow back hooks into the {ActiveRecord}
-  # requesting name of table as a function of attributes.
-  #
   class Relation
-    #
-    # Patches {ActiveRecord}'s building of an insert statement to request
-    # of the model a table name with respect to attribute values being
-    # inserted.
-    #
-    # The differences between this and the original code are small and marked
-    # with PARTITIONED comment.
+
+    # This method is patched to use a table name that is derived from
+    # the attribute values.
     def insert(values)
       primary_key_value = nil
 
       if primary_key && Hash === values
         primary_key_value = values[values.keys.find { |k|
-          k.name == primary_key
-        }]
+                                     k.name == primary_key
+                                   }]
 
         if !primary_key_value && connection.prefetch_primary_key?(klass.table_name)
           primary_key_value = connection.next_sequence_value(klass.sequence_name)
@@ -117,15 +151,14 @@ module ActiveRecord
       end
 
       im = arel.create_insert
-      #
-      # PARTITIONED ADDITION. get arel_table from class with respect to the
-      # current values to placed in the table (which hopefully hold the values
-      # that are used to determine the child table this insert should be
-      # redirected to)
-      #
+
+      # ****** BEGIN PARTITIONED PATCH ******
       actual_arel_table = @klass.dynamic_arel_table(Hash[*values.map{|k,v| [k.name,v]}.flatten]) if @klass.respond_to?(:dynamic_arel_table)
       actual_arel_table = @table unless actual_arel_table
+      # Original line:
+      # im.into @table
       im.into actual_arel_table
+      # ****** END PARTITIONED PATCH ******
 
       conn = @klass.connection
 
@@ -145,12 +178,13 @@ module ActiveRecord
       end
 
       conn.insert(
-        im,
-        'SQL',
-        primary_key,
-        primary_key_value,
-        nil,
-        binds)
+                  im,
+                  'SQL',
+                  primary_key,
+                  primary_key_value,
+                  nil,
+                  binds)
     end
-  end
-end
+
+  end # class Relation
+end # module ActiveRecord

data/lib/monkey_patch_postgres.rb

@@ -9,19 +9,6 @@ require 'active_record/connection_adapters/postgresql_adapter'
 # needed to abstract partition specific SQL statements.
 #
 module ActiveRecord::ConnectionAdapters
-  #
-  # Patches associated with building check constraints.
-  #
-  class TableDefinition
-    #
-    # Builds a SQL check constraint
-    #
-    # @param [String] constraint a SQL constraint
-    def check_constraint(constraint)
-      @columns << Struct.new(:to_sql).new("CHECK (#{constraint})")
-    end
-  end
-
   #
   # Patches extending the postgres adapter with new operations for managing
   # sequences (and sets of sequence values), schemas and foreign keys.

data/lib/partitioned/by_time_field.rb

@@ -66,7 +66,8 @@ module Partitioned
       }
       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}'"
+        return "#{model.partition_time_field} >= '#{date.strftime('%Y-%m-%d')}' AND " +
+                 "#{model.partition_time_field} < '#{(date + model.partition_table_size).strftime('%Y-%m-%d')}'"
       }
     end
   end

data/lib/partitioned/partitioned_base.rb

@@ -150,7 +150,7 @@ module Partitioned
     #
     # Use as:
     #
-    #   Foo.from_partition(KEY).find(:first)
+    #   Foo.from_partition(KEY).first
     #
     # where KEY is the key value(s) used as the check constraint on Foo's table.
     #
@@ -168,7 +168,7 @@ module Partitioned
     #
     # Use as:
     #
-    #   Foo.from_partition_without_alias(KEY).find(:all, :select => "*")
+    #   Foo.from_partition_without_alias(KEY).all
     #
     # where KEY is the key value(s) used as the check constraint on Foo's table.
     #

data/lib/partitioned/partitioned_base/redshift_sql_adapter.rb

@@ -38,13 +38,11 @@ module Partitioned
       # 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
+        return find_by_sql([
+                             "SELECT COUNT(*) as count FROM pg_tables WHERE schemaname = ? AND tablename = ?;",
+                             configurator.schema_name,
+                             configurator.part_name(*partition_key_values)
+                           ]).first.count.to_i == 1
       end
 
       #

data/lib/partitioned/partitioned_base/sql_adapter.rb

@@ -57,13 +57,14 @@ module Partitioned
       # 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
+        query = <<-SQL
+          SELECT COUNT(*) AS count
+          FROM pg_tables
+          WHERE schemaname = '#{configurator.schema_name}'
+            AND tablename = '#{configurator.part_name(*partition_key_values)}'
+          LIMIT 1
+        SQL
+        return find_by_sql(query).first.count.to_i == 1
       end
 
       #
@@ -90,12 +91,15 @@ module Partitioned
       #  $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)
+        order_by_clause = last_n_partitions_order_by_clause
+        query = <<-SQL
+          SELECT tablename
+          FROM pg_tables
+          WHERE schemaname = '#{configurator.schema_name}'
+          #{order_by_clause.nil? ? "" : "ORDER BY " + order_by_clause}
+          LIMIT 1
+        SQL
+        return find_by_sql(query).map(&:tablename)
       end
 
       #
@@ -162,8 +166,20 @@ module Partitioned
                        :id => false,
                        :options => "INHERITS (#{configurator.parent_table_name(*partition_key_values)})"
                      }) do |t|
-          constraint = configurator.check_constraint(*partition_key_values)
-          t.check_constraint constraint if constraint
+        end
+        add_check_constraint(*partition_key_values)
+      end
+
+      #
+      # Add the check constraint to the table (if applicable)
+      #
+      def add_check_constraint(*partition_key_values)
+        constraint = configurator.check_constraint(*partition_key_values)
+        if constraint
+          sql = <<-SQL
+            ALTER TABLE #{configurator.table_name(*partition_key_values)} ADD CHECK (#{constraint});
+          SQL
+          execute(sql)
         end
       end
 

data/lib/partitioned/version.rb

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

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-12-13'
+  s.date           = '2015-10-01'
   s.summary        = "Postgres table partitioning support for ActiveRecord."
   s.description    = "A gem providing support for table partitioning in ActiveRecord. Support is available for postgres and AWS RedShift databases. Other features include child table management (creation and deletion) and bulk data creating and updating."
   s.authors        = ["Keith Gabryelski", "Aleksandr Dembskiy", "Edward Slavich"]
@@ -22,7 +22,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'pg'
   s.add_dependency 'bulk_data_methods'
   s.add_dependency 'activerecord-redshift-adapter'
-  s.add_dependency 'activerecord', '~> 3.0'
-  s.add_development_dependency 'rails', '~> 3.2.8'
-  s.add_development_dependency 'rspec-rails', '~> 3.0'
+  s.add_dependency 'activerecord', '~> 4.0.4'
+  s.add_development_dependency 'rails', '~> 4.0.4'
+  s.add_development_dependency 'rspec-rails'
 end

data/spec/dummy/.gitignore

@@ -0,0 +1,16 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+/db/*.sqlite3-journal
+
+# Ignore all logfiles and tempfiles.
+/log/*.log
+/tmp