pg_party 0.7.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4b3cbb99316596bf151d53ef3d550d449e7f7853
-  data.tar.gz: 2f0185c8e5ae5b8928ae0c196eafe0b72dbca215
+SHA256:
+  metadata.gz: b3eb42aaee8d1f94ffd962760c6f4596330cbdc899a314738848861bfc01e29c
+  data.tar.gz: '049172b0bb51a0d8664ad54b4599a588c448b8558861c3f50688fb938aaf7680'
 SHA512:
-  metadata.gz: 4a6a84178f454a81549f02ddd3e2871de48269a8ac86e6f1e68a6df8f8bd40cc8b85945e8914879a8a5543fc71257792d44cf0de0d20dda0c7b67fe0afcceac6
-  data.tar.gz: 1cb16eaf85e97774734eff7e316a404c3d6980e1d95932d6f145cef74f17db83f79e48cc264812c32ff696a135dc82c4f815f0f4624a4d176d416e85a5338e4c
+  metadata.gz: 0e00484e8d7142cdff81b64301f5cf2207318e07dd9f918730472ece7840e2025e71e15a827987042c3ede9c66ad41633af88cc4ec7e0f83d7a4e28c57e822a8
+  data.tar.gz: c3fa8f87087bd47e87910fcb2707cd58d83c7e6bf91207dfde299b550c9aace44cc905a7781d9ddc5b4281a8de654bf096813420aa8937442bf09a053f13f549

data/README.md

@@ -2,26 +2,28 @@
 
 [![Gem Version](https://badge.fury.io/rb/pg_party.svg)][rubygems]
 [![Build Status](https://circleci.com/gh/rkrage/pg_party.svg?&style=shield)][circle]
-[![Dependency Status](https://gemnasium.com/badges/github.com/rkrage/pg_party.svg)][gemnasium]
 [![Maintainability](https://api.codeclimate.com/v1/badges/c409453d2283dd440227/maintainability)][cc_maintainability]
 [![Test Coverage](https://api.codeclimate.com/v1/badges/c409453d2283dd440227/test_coverage)][cc_coverage]
 
 [rubygems]:           https://rubygems.org/gems/pg_party
 [circle]:             https://circleci.com/gh/rkrage/pg_party/tree/master
-[gemnasium]:          https://gemnasium.com/github.com/rkrage/pg_party
 [cc_maintainability]: https://codeclimate.com/github/rkrage/pg_party/maintainability
 [cc_coverage]:        https://codeclimate.com/github/rkrage/pg_party/test_coverage
 
-[ActiveRecord](http://guides.rubyonrails.org/active_record_basics.html) migrations and model helpers for creating and managing [PostgreSQL 10 partitions](https://www.postgresql.org/docs/10/static/ddl-partitioning.html)!
+[ActiveRecord](http://guides.rubyonrails.org/active_record_basics.html) migrations and model helpers for creating and managing [PostgreSQL 10+ partitions](https://www.postgresql.org/docs/10/static/ddl-partitioning.html)!
 
-Features:
-  - Migration methods for partition specific database operations
-  - Model methods for querying partitioned data
-  - Model methods for creating adhoc partitions
+## Features
 
-Limitations:
-  - Partition tables are not represented correctly in `db/schema.rb` — please use the `:sql` schema format
-  - Only single column partition keys supported (e.g., `column`, `column::cast`)
+- Migration methods for partition specific database operations
+- Model methods for querying partitioned data, creating adhoc partitions, and retreiving partition metadata
+
+## Limitations
+
+- Partition tables are not represented correctly in `db/schema.rb` — please use the `:sql` schema format
+
+## Future Work
+
+- Automatic partition creation (via cron or some other means)
 
 ## Installation
 
@@ -33,89 +35,152 @@ gem 'pg_party'
 
 And then execute:
 
-    $ bundle
+```
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install pg_party
-
-## Usage
-
-Full API documentation is in progress.
+```
+$ gem install pg_party
+```
 
-In the meantime, take a look at the [Combustion](https://github.com/pat/combustion) schema definition and integration specs:
-  - https://github.com/rkrage/pg_party/blob/master/spec/internal/db/schema.rb
-  - https://github.com/rkrage/pg_party/tree/master/spec/integration
+Note that the gemspec does not require `pg`, as some model methods _may_ work for other databases.
+Migration methods will be unavailable unless `pg` is installed.
 
-### Migration Examples
+## Usage
 
-Create range partition on `created_at::date` with two child partitions:
+### Migrations
+
+#### Methods
+
+These methods are available in migrations as well as `ActiveRecord::Base#connection` objects.
+
+- `create_range_partition`
+  - Create partitioned table using the _range_ partitioning method
+  - Required args: `table_name`, `partitition_key:`
+- `create_list_partition`
+  - Create partitioned table using the _list_ partitioning method
+  - Required args: `table_name`, `partition_key:`
+- `create_range_partition_of`
+  - Create partition in _range_ partitioned table with partition key between _range_ of values
+  - Required args: `table_name`, `start_range:`, `end_range:`
+- `create_list_partition_of`
+  - Create partition in _list_ partitioned table with partition key in _list_ of values
+  - Required args: `table_name`, `values:`
+- `attach_range_partition`
+  - Attach existing table to _range_ partitioned table with partition key between _range_ of values
+  - Required args: `parent_table_name`, `child_table_name`, `start_range:`, `end_range:`
+- `attach_list_partition`
+  - Attach existing table to _list_ partitioned table with partition key in _list_ of values
+  - Required args: `parent_table_name`, `child_table_name`, `values:`
+- `detach_partition`
+  - Detach partition from both _range and list_ partitioned tables
+  - Required args: `parent_table_name`, `child_table_name`
+- `create_table_like`
+  - Clone _any_ existing table
+  - Required args: `table_name`, `new_table_name`
+
+#### Examples
+
+Create _range_ partitioned table on `created_at::date` with two partitions:
 
 ```ruby
 class CreateSomeRangeRecord < ActiveRecord::Migration[5.1]
   def up
-    current_date = Date.current
-
-    create_range_partition :some_range_records, partition_key: "created_at::date" do |t|
+    # proc is used for partition keys containing expressions
+    create_range_partition :some_range_records, partition_key: ->{ "(created_at::date)" } do |t|
       t.text :some_value
       t.timestamps
     end
 
+    # optional name argument is used to specify child table name
     create_range_partition_of \
       :some_range_records,
-      partition_key: "created_at::date",
-      start_range: current_date,
-      end_range: current_date + 1.day
+      name: :some_range_records_a,
+      start_range: "2019-06-07",
+      end_range: "2019-06-08"
 
+    # optional name argument is used to specify child table name
      create_range_partition_of \
        :some_range_records,
-       partition_key: "created_at::date",
-       start_range: current_date + 1.day,
-       end_range: current_date + 2.days
+       name: :some_range_records_b,
+       start_range: "2019-06-08",
+       end_range: "2019-06-09"
   end
 end
 ```
 
-Create list partition on `id` with two child partitions:
+Create _list_ partitioned table on `id` with two partitions:
 
 ```ruby
 class CreateSomeListRecord < ActiveRecord::Migration[5.1]
   def up
+    # symbol is used for partition keys referring to individual columns
     create_list_partition :some_list_records, partition_key: :id do |t|
       t.text :some_value
       t.timestamps
     end
 
+    # without name argument, child partition created as "some_list_records_<hash>"
     create_list_partition_of \
       :some_list_records,
-      partition_key: :id,
-      values: (1..100).to_a
+      values: 1..100
 
+    # without name argument, child partition created as "some_list_records_<hash>"
      create_list_partition_of \
        :some_list_records,
-       partition_key: :id,
-       values: (100..200).to_a
+       values: 101..200
   end
 end
 ```
 
-Attach an existing table to a range partition:
+Unfortunately, PostgreSQL 10 doesn't support indexes on partitioned tables.
+However, individual _partitions_ can have indexes.
+To avoid explicit index creation for _every_ new partition, we've introduced the idea of template tables.
+For every call to `create_list_partition` and `create_range_partition`, a clone `<table_name>_template` is created.
+Indexes, constraints, etc. created on the template table will propagate to new partitions in calls to `create_list_partition_of` and `create_range_partition_of`:
 
 ```ruby
-class AttachRangePartition < ActiveRecord::Migration[5.1]
+class CreateSomeListRecord < ActiveRecord::Migration[5.1]
   def up
-    current_date = Date.current
+    # template table creation is enabled by default - use "template: false" to opt-out
+    create_list_partition :some_list_records, partition_key: :id do |t|
+      t.integer :some_foreign_id
+      t.text :some_value
+      t.timestamps
+    end
+
+    # create index on the template table
+    add_index :some_list_records_template, :some_foreign_id
+
+    # create partition with an index on "some_foreign_id"
+    create_list_partition_of \
+      :some_list_records,
+      values: 1..100
+
+    # create partition with an index on "some_foreign_id"
+    create_list_partition_of \
+      :some_list_records,
+      values: 101..200
+  end
+end
+```
+
+Attach an existing table to a _range_ partitioned table:
 
+```ruby
+  def up
     attach_range_partition \
       :some_range_records,
       :some_existing_table,
-      start_range: current_date,
-      end_range: current_date + 1.day
+      start_range: "2019-06-09",
+      end_range: "2019-06-10"
   end
 end
 ```
 
-Attach an existing table to a list partition:
+Attach an existing table to a _list_ partitioned table:
 
 ```ruby
 class AttachListPartition < ActiveRecord::Migration[5.1]
@@ -123,12 +188,12 @@ class AttachListPartition < ActiveRecord::Migration[5.1]
     attach_list_partition \
       :some_list_records,
       :some_existing_table,
-      values: (200..300).to_a
+      values: 200..300
   end
 end
 ```
 
-Detach a child table from any partition:
+Detach a partition from any partitioned table:
 
 ```ruby
 class DetachPartition < ActiveRecord::Migration[5.1]
@@ -138,51 +203,104 @@ class DetachPartition < ActiveRecord::Migration[5.1]
 end
 ```
 
-### Model Examples
+For more examples, take a look at the Combustion schema definition and integration specs:
+
+- https://github.com/rkrage/pg_party/blob/master/spec/dummy/db/schema.rb
+- https://github.com/rkrage/pg_party/blob/master/spec/integration/migration_spec.rb
+
+### Models
+
+#### Methods
+
+Class methods available to _all_ ActiveRecord models:
+
+- `partitioned?`
+  - Check if a model is backed by either a _list or range_ partitioned table
+  - No arguments
+- `range_partition_by`
+  - Configure a model backed by a _range_ partitioned table
+  - Required arg: `key` (partition key column) or block returning partition key expression
+- `list_partition_by`
+  - Configure a model backed by a _list_ partitioned table
+  - Required arg: `key` (partition key column) or block returning partition key expression
+
+Class methods available to both _range and list_ partitioned models:
+
+- `partitions`
+  - Retrieve a list of currently attached partitions
+  - No arguments
+- `in_partition`
+  - Retrieve an ActiveRecord model scoped to an individual partition
+  - Required arg: `child_table_name`
+- `partition_key_eq`
+  - Query for records where partition key matches a value
+  - Required arg: `value`
+
+Class methods available to _range_ partitioned models:
+
+- `create_partition`
+  - Dynamically create new partition with partition key in _range_ of values
+  - Required args: `start_range:`, `end_range:`
+- `partition_key_in`
+  - Query for records where partition key in _range_ of values
+  - Required args: `start_range`, `end_range`
+
+Class methods available to _list_ partitioned models:
 
-Define model that is backed by a range partition:
+- `create_partition`
+  - Dynamically create new partition with partition key in _list_ of values
+  - Required arg: `values:`
+- `partition_key_in`
+  - Query for records where partition key in _list_ of values
+  - Required arg: list of `values`
+
+#### Examples
+
+Configure model backed by a _range_ partitioned table to get access to the methods described above:
 
 ```ruby
 class SomeRangeRecord < ApplicationRecord
-  range_partition_by "created_at::date"
+  # block is used for partition keys containing expressions
+  range_partition_by { "(created_at::date)" }
 end
  ```
 
-Define model that is backed by a list partition:
+Configure model backed by a _list_ partitioned table to get access to the methods described above:
 
 ```ruby
 class SomeListRecord < ApplicationRecord
+  # symbol is used for partition keys referring to individual columns
   list_partition_by :id
 end
 ```
 
-Create child partition from range partition model:
+Dynamically create new partition from _range_ partitioned model:
 
 ```ruby
-current_date = Date.current
-
-SomeRangeRecord.create_partition(start_range: current_date + 1.day, end_range: current_date + 2.days)
+# additional options include: "name:" and "primary_key:"
+SomeRangeRecord.create_partition(start_range: "2019-06-09", end_range: "2019-06-10")
 ```
 
-Create child partition from list partition model:
+Dynamically create new partition from _list_ partitioned model:
 
 ```ruby
-SomeListRecord.create_partition(values: (200..300).to_a)
+# additional options include: "name:" and "primary_key:"
+SomeListRecord.create_partition(values: 200..300)
 ```
 
-Query for records within partition range:
+For _range_ partitioned model, query for records where partition key in _range_ of values:
 
 ```ruby
-SomeRangeRecord.partition_key_in("2017-01-01".to_date, "2017-02-01".to_date)
+SomeRangeRecord.partition_key_in("2019-06-08", "2019-06-10")
 ```
 
-Query for records in partition list:
+For _list_ partitioned model, query for records where partition key in _list_ of values:
 
 ```ruby
 SomeListRecord.partition_key_in(1, 2, 3, 4)
 ```
 
-Query for records matching partition key:
+For both _range and list_ partitioned models, query for records matching partition key:
 
 ```ruby
 SomeRangeRecord.partition_key_eq(Date.current)
@@ -190,7 +308,7 @@ SomeRangeRecord.partition_key_eq(Date.current)
 SomeListRecord.partition_key_eq(100)
 ```
 
-List currently attached partitions:
+For both _range and list_ partitioned models, retrieve currently attached partitions:
 
 ```ruby
 SomeRangeRecord.partitions
@@ -198,7 +316,7 @@ SomeRangeRecord.partitions
 SomeListRecord.partitions
 ```
 
-Retrieve ActiveRecord model class scoped to a child partition:
+For both _range and list_ partitioned models, retrieve ActiveRecord model scoped to individual partition:
 
 ```ruby
 SomeRangeRecord.in_partition(:some_range_records_partition_name)
@@ -206,26 +324,38 @@ SomeRangeRecord.in_partition(:some_range_records_partition_name)
 SomeListRecord.in_partition(:some_list_records_partition_name)
 ```
 
+For more examples, take a look at the model integration specs:
+
+- https://github.com/rkrage/pg_party/tree/documentation/spec/integration/model
+
 ## Development
 
 The development / test environment relies heavily on [Docker](https://docs.docker.com).
 
 Start the containers in the background:
 
-    $ docker-compose up -d
+```
+$ docker-compose up -d
+```
 
 Install dependencies:
 
-    $ bin/de bundle
-    $ bin/de appraisal
+```
+$ bin/de bundle
+$ bin/de appraisal
+```
 
 Run the tests:
 
-    $ bin/de appraisal rake
+```
+$ bin/de appraisal rake
+```
 
 Open a Pry console to play around with the sample Rails app:
 
-    $ bin/de console
+```
+$ bin/de console
+```
 
 ## Contributing
 

data/lib/pg_party.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "pg_party/version"
 require "active_support"
 
@@ -8,17 +10,23 @@ ActiveSupport.on_load(:active_record) do
 
   require "pg_party/adapter/abstract_methods"
 
-  ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval do
-    include PgParty::Adapter::AbstractMethods
-  end
-  
+  ActiveRecord::ConnectionAdapters::AbstractAdapter.include(
+    PgParty::Adapter::AbstractMethods
+  )
+
+  require "pg_party/hacks/schema_cache"
+
+  ActiveRecord::ConnectionAdapters::SchemaCache.include(
+    PgParty::Hacks::SchemaCache
+  )
+
   begin
     require "active_record/connection_adapters/postgresql_adapter"
     require "pg_party/adapter/postgresql_methods"
 
-    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
-      include PgParty::Adapter::PostgreSQLMethods
-    end
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.include(
+      PgParty::Adapter::PostgreSQLMethods
+    )
   rescue LoadError
     # migration methods will not be available
   end

data/lib/pg_party/adapter/abstract_methods.rb

@@ -1,32 +1,38 @@
+# frozen_string_literal: true
+
 module PgParty
   module Adapter
     module AbstractMethods
       def create_range_partition(*)
-        raise NotImplementedError, "#create_range_partition is not implemented"
+        raise "#create_range_partition is not implemented"
       end
 
       def create_list_partition(*)
-        raise NotImplementedError, "#create_list_partition is not implemented"
+        raise "#create_list_partition is not implemented"
       end
 
       def create_range_partition_of(*)
-        raise NotImplementedError, "#create_range_partition_of is not implemented"
+        raise "#create_range_partition_of is not implemented"
       end
 
       def create_list_partition_of(*)
-        raise NotImplementedError, "#create_list_partition_of is not implemented"
+        raise "#create_list_partition_of is not implemented"
+      end
+
+      def create_table_like(*)
+        raise "#create_table_like is not implemented"
       end
 
       def attach_range_partition(*)
-        raise NotImplementedError, "#attach_range_partition is not implemented"
+        raise "#attach_range_partition is not implemented"
       end
 
       def attach_list_partition(*)
-        raise NotImplementedError, "#attach_list_partition is not implemented"
+        raise "#attach_list_partition is not implemented"
       end
 
       def detach_partition(*)
-        raise NotImplementedError, "#detach_partition is not implemented"
+        raise "#detach_partition is not implemented"
       end
     end
   end

data/lib/pg_party/adapter/postgresql_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "pg_party/adapter_decorator"
 
 module PgParty
@@ -19,6 +21,10 @@ module PgParty
         PgParty::AdapterDecorator.new(self).create_list_partition_of(*args)
       end
 
+      def create_table_like(*args)
+        PgParty::AdapterDecorator.new(self).create_table_like(*args)
+      end
+
       def attach_range_partition(*args)
         PgParty::AdapterDecorator.new(self).attach_range_partition(*args)
       end

data/lib/pg_party/adapter_decorator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "digest"
 require "pg_party/cache"
 
@@ -18,47 +20,39 @@ module PgParty
     end
 
     def create_range_partition_of(table_name, start_range:, end_range:, **options)
-      if options[:name]
-        child_table_name = options[:name]
-      else
-        child_table_name = hashed_table_name(table_name, "#{start_range}#{end_range}")
-      end
-
-      constraint_clause = "FROM (#{quote(start_range)}) TO (#{quote(end_range)})"
-
-      create_partition_of(table_name, child_table_name, constraint_clause, **options)
+      create_partition_of(table_name, range_constraint_clause(start_range, end_range), **options)
     end
 
     def create_list_partition_of(table_name, values:, **options)
-      if options[:name]
-        child_table_name = options[:name]
-      else
-        child_table_name = hashed_table_name(table_name, values.to_s)
-      end
+      create_partition_of(table_name, list_constraint_clause(values), **options)
+    end
 
-      constraint_clause = "IN (#{Array.wrap(values).map(&method(:quote)).join(",")})"
+    def create_table_like(table_name, new_table_name, **options)
+      primary_key = options.fetch(:primary_key) { calculate_primary_key(table_name) }
 
-      create_partition_of(table_name, child_table_name, constraint_clause, **options)
-    end
+      validate_primary_key(primary_key)
 
-    def attach_range_partition(parent_table_name, child_table_name, start_range:, end_range:)
       execute(<<-SQL)
-        ALTER TABLE #{quote_table_name(parent_table_name)}
-        ATTACH PARTITION #{quote_table_name(child_table_name)}
-        FOR VALUES FROM (#{quote(start_range)}) TO (#{quote(end_range)})
+        CREATE TABLE #{quote_table_name(new_table_name)} (
+          LIKE #{quote_table_name(table_name)} INCLUDING ALL
+        )
       SQL
 
-      PgParty::Cache.clear!
-    end
+      return if !primary_key
+      return if has_primary_key?(new_table_name)
 
-    def attach_list_partition(parent_table_name, child_table_name, values:)
       execute(<<-SQL)
-        ALTER TABLE #{quote_table_name(parent_table_name)}
-        ATTACH PARTITION #{quote_table_name(child_table_name)}
-        FOR VALUES IN (#{Array.wrap(values).map(&method(:quote)).join(",")})
+        ALTER TABLE #{quote_table_name(new_table_name)}
+        ADD PRIMARY KEY (#{quote_column_name(primary_key)})
       SQL
+    end
 
-      PgParty::Cache.clear!
+    def attach_range_partition(parent_table_name, child_table_name, start_range:, end_range:)
+      attach_partition(parent_table_name, child_table_name, range_constraint_clause(start_range, end_range))
+    end
+
+    def attach_list_partition(parent_table_name, child_table_name, values:)
+      attach_partition(parent_table_name, child_table_name, list_constraint_clause(values))
     end
 
     def detach_partition(parent_table_name, child_table_name)
@@ -73,16 +67,17 @@ module PgParty
     private
 
     def create_partition(table_name, type, partition_key, **options)
-      modified_options = options.except(:id, :primary_key)
+      modified_options = options.except(:id, :primary_key, :template)
+      template         = options.fetch(:template, true)
       id               = options.fetch(:id, :bigserial)
-      primary_key      = options.fetch(:primary_key, :id)
+      primary_key      = options.fetch(:primary_key) { calculate_primary_key(table_name) }
 
-      raise ArgumentError, "composite primary key not supported" if primary_key.is_a?(Array)
+      validate_primary_key(primary_key)
 
       modified_options[:id]      = false
-      modified_options[:options] = "PARTITION BY #{type.to_s.upcase} ((#{quote_partition_key(partition_key)}))"
+      modified_options[:options] = "PARTITION BY #{type.to_s.upcase} (#{quote_partition_key(partition_key)})"
 
-      result = create_table(table_name, modified_options) do |td|
+      create_table(table_name, modified_options) do |td|
         if id == :uuid
           td.column(primary_key, id, null: false, default: uuid_function)
         elsif id
@@ -95,42 +90,35 @@ module PgParty
       # Rails 4 has a bug where uuid columns are always nullable
       change_column_null(table_name, primary_key, false) if id == :uuid
 
-      result
+      return unless template
+
+      create_table_like(table_name, template_table_name(table_name), primary_key: id && primary_key)
     end
 
-    def create_partition_of(table_name, child_table_name, constraint_clause, **options)
-      primary_key   = options.fetch(:primary_key, :id)
-      index         = options.fetch(:index, true)
-      partition_key = options[:partition_key]
+    def create_partition_of(table_name, constraint_clause, **options)
+      child_table_name    = options.fetch(:name) { hashed_table_name(table_name, constraint_clause) }
+      primary_key         = options.fetch(:primary_key) { calculate_primary_key(table_name) }
+      template_table_name = template_table_name(table_name)
 
-      raise ArgumentError, "composite primary key not supported" if primary_key.is_a?(Array)
+      if schema_cache.data_source_exists?(template_table_name)
+        create_table_like(template_table_name, child_table_name, primary_key: false)
+      else
+        create_table_like(table_name, child_table_name, primary_key: primary_key)
+      end
 
+      attach_partition(table_name, child_table_name, constraint_clause)
+
+      child_table_name
+    end
+
+    def attach_partition(parent_table_name, child_table_name, constraint_clause)
       execute(<<-SQL)
-        CREATE TABLE #{quote_table_name(child_table_name)}
-        PARTITION OF #{quote_table_name(table_name)}
+        ALTER TABLE #{quote_table_name(parent_table_name)}
+        ATTACH PARTITION #{quote_table_name(child_table_name)}
         FOR VALUES #{constraint_clause}
       SQL
 
-      if primary_key
-        execute(<<-SQL)
-          ALTER TABLE #{quote_table_name(child_table_name)}
-          ADD PRIMARY KEY (#{quote_column_name(primary_key)})
-        SQL
-      end
-
-      if index && partition_key && primary_key != partition_key
-        index_name = index_name(child_table_name, partition_key)
-
-        execute(<<-SQL)
-          CREATE INDEX #{quote_table_name(index_name)}
-          ON #{quote_table_name(child_table_name)}
-          USING btree ((#{quote_partition_key(partition_key)}))
-        SQL
-      end
-
       PgParty::Cache.clear!
-
-      child_table_name
     end
 
     # Rails 5.2 now returns boolean literals
@@ -145,8 +133,40 @@ module PgParty
       end
     end
 
+    def has_primary_key?(table_name)
+      primary_key(table_name).present?
+    end
+
+    def calculate_primary_key(table_name)
+      ActiveRecord::Base.get_primary_key(table_name.to_s.singularize).to_sym
+    end
+
+    def validate_primary_key(key)
+      raise ArgumentError, "composite primary key not supported" if key.is_a?(Array)
+    end
+
     def quote_partition_key(key)
-      key.to_s.split("::").map(&method(:quote_column_name)).join("::")
+      if key.is_a?(Proc)
+        key.call.to_s # very difficult to determine how to sanitize a complex expression
+      else
+        quote_column_name(key)
+      end
+    end
+
+    def quote_collection(values)
+      Array.wrap(values).map(&method(:quote)).join(",")
+    end
+
+    def template_table_name(table_name)
+      "#{table_name}_template"
+    end
+
+    def range_constraint_clause(start_range, end_range)
+      "FROM (#{quote_collection(start_range)}) TO (#{quote_collection(end_range)})"
+    end
+
+    def list_constraint_clause(values)
+      "IN (#{quote_collection(values.try(:to_a) || values)})"
     end
 
     def uuid_function
@@ -160,9 +180,5 @@ module PgParty
     def supports_partitions?
       __getobj__.send(:postgresql_version) >= 100000
     end
-
-    def index_name(table_name, key)
-      "index_#{table_name}_on_#{key.to_s.split("::").join("_")}"
-    end
   end
 end

data/lib/pg_party/cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "thread"
 
 module PgParty

data/lib/pg_party/hacks/schema_cache.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PgParty
+  module Hacks
+    module SchemaCache
+      def self.included(base)
+        return if base.method_defined?(:data_source_exists?)
+
+        base.send(:alias_method, :data_source_exists?, :table_exists?)
+      end
+    end
+  end
+end

data/lib/pg_party/model/list_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "pg_party/model_decorator"
 
 module PgParty

data/lib/pg_party/model/methods.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require "pg_party/model_injector"
 
 module PgParty
   module Model
     module Methods
-      def range_partition_by(key)
-        PgParty::ModelInjector.new(self, key).inject_range_methods
+      def range_partition_by(key=nil, &blk)
+        PgParty::ModelInjector.new(self, key || blk).inject_range_methods
       end
 
-      def list_partition_by(key)
-        PgParty::ModelInjector.new(self, key).inject_list_methods
+      def list_partition_by(key=nil, &blk)
+        PgParty::ModelInjector.new(self, key || blk).inject_list_methods
       end
 
       def partitioned?

data/lib/pg_party/model/range_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "pg_party/model_decorator"
 
 module PgParty

data/lib/pg_party/model/shared_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "pg_party/model_decorator"
 
 module PgParty

data/lib/pg_party/model_decorator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "pg_party/cache"
 
 module PgParty
@@ -15,7 +17,7 @@ module PgParty
     def partition_table_exists?
       target_table = partitions.first || table_name
 
-      connection.schema_cache.send(table_exists_method, target_table)
+      connection.schema_cache.data_source_exists?(target_table)
     end
 
     def in_partition(child_table_name)
@@ -44,17 +46,33 @@ module PgParty
     end
 
     def partition_key_eq(value)
-      where(partition_key_as_arel.eq(value))
+      if complex_partition_key
+        complex_partition_key_query("(#{partition_key}) = (?)", value)
+      else
+        where(current_arel_table[partition_key].eq(value))
+      end
     end
 
     def range_partition_key_in(start_range, end_range)
-      node = partition_key_as_arel
+      if complex_partition_key
+        complex_partition_key_query(
+          "(#{partition_key}) >= (?) AND (#{partition_key}) < (?)",
+          start_range,
+          end_range
+        )
+      else
+        node = current_arel_table[partition_key]
 
-      where(node.gteq(start_range).and(node.lt(end_range)))
+        where(node.gteq(start_range).and(node.lt(end_range)))
+      end
     end
 
     def list_partition_key_in(*values)
-      where(partition_key_as_arel.in(values.flatten))
+      if complex_partition_key
+        complex_partition_key_query("(#{partition_key}) IN (?)", values.flatten)
+      else
+        where(current_arel_table[partition_key].in(values.flatten))
+      end
     end
 
     def partitions
@@ -67,6 +85,8 @@ module PgParty
           WHERE pg_tables.tablename = #{connection.quote(table_name)}
         SQL
       end
+    rescue
+      []
     end
 
     def create_range_partition(start_range:, end_range:, **options)
@@ -74,44 +94,57 @@ module PgParty
         start_range: start_range,
         end_range: end_range,
         primary_key: primary_key,
-        partition_key: partition_key
       )
 
-      connection.create_range_partition_of(table_name, **modified_options)
+      create_partition(:create_range_partition_of, table_name, **modified_options)
     end
 
     def create_list_partition(values:, **options)
       modified_options = options.merge(
         values: values,
         primary_key: primary_key,
-        partition_key: partition_key
       )
 
-      connection.create_list_partition_of(table_name, **modified_options)
+      create_partition(:create_list_partition_of, table_name, **modified_options)
     end
 
     private
 
+    def create_partition(migration_method, table_name, **options)
+      transaction { connection.send(migration_method, table_name, **options) }
+    end
+
     def cache_key
       __getobj__.object_id
     end
 
-    def table_exists_method
-      [:data_source_exists?, :table_exists?].detect do |meth|
-        connection.schema_cache.respond_to?(meth)
+    # https://stackoverflow.com/questions/28685149/activerecord-query-with-aliasd-table-names
+    def current_arel_table
+      none.arel.source.left.tap do |node|
+        if [Arel::Table, Arel::Nodes::TableAlias].exclude?(node.class)
+          raise "could not find arel table in current scope"
+        end
       end
     end
 
-    def partition_key_as_arel
-      arel_column = arel_table[partition_column]
+    def current_alias
+      arel_node = current_arel_table
 
-      if partition_cast
-        quoted_cast = connection.quote_column_name(partition_cast)
-
-        Arel::Nodes::NamedFunction.new("CAST", [arel_column.as(quoted_cast)])
-      else
-        arel_column
+      case arel_node
+      when Arel::Table
+        arel_node.name
+      when Arel::Nodes::TableAlias
+        arel_node.right
       end
     end
+
+    def complex_partition_key_query(clause, *interpolated_values)
+      subquery = base_class
+        .unscoped
+        .select("*")
+        .where(clause, *interpolated_values)
+
+      from(subquery, current_alias)
+    end
   end
 end

data/lib/pg_party/model_injector.rb

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
+
 module PgParty
   class ModelInjector
     def initialize(model, key)
       @model = model
       @key = key
-
-      @column, @cast = key.to_s.split("::")
     end
 
     def inject_range_methods
@@ -33,15 +33,18 @@ module PgParty
     def create_class_attributes
       @model.class_attribute(
         :partition_key,
-        :partition_column,
-        :partition_cast,
+        :complex_partition_key,
         instance_accessor: false,
         instance_predicate: false
       )
 
-      @model.partition_key = @key
-      @model.partition_column = @column
-      @model.partition_cast = @cast
+      if @key.is_a?(Proc)
+        @model.partition_key = @key.call
+        @model.complex_partition_key = true
+      else
+        @model.partition_key = @key
+        @model.complex_partition_key = false
+      end
     end
   end
 end

data/lib/pg_party/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PgParty
-  VERSION = "0.7.3"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_party
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Ryan Krage
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-16 00:00:00.000000000 Z
+date: 2019-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -19,7 +19,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,21 +29,21 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
-  name: pg
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.20'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.20'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -59,131 +59,131 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.15'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '10.0'
 - !ruby/object:Gem::Dependency
-  name: rspec-rails
+  name: combustion
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
+        version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: rspec-its
+  name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
-  name: pry-byebug
+  name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: 1.9.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: 1.9.1
 - !ruby/object:Gem::Dependency
-  name: rspec_junit_formatter
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '3.4'
 - !ruby/object:Gem::Dependency
-  name: appraisal
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '12.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '12.0'
 - !ruby/object:Gem::Dependency
-  name: combustion
+  name: rspec-its
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
-  name: database_cleaner
+  name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '3.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '3.6'
 - !ruby/object:Gem::Dependency
-  name: timecop
+  name: rspec_junit_formatter
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -198,6 +198,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.15'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 description: Migrations and model helpers for creating and managing PostgreSQL 10
   partitions
 email:
@@ -213,6 +227,7 @@ files:
 - lib/pg_party/adapter/postgresql_methods.rb
 - lib/pg_party/adapter_decorator.rb
 - lib/pg_party/cache.rb
+- lib/pg_party/hacks/schema_cache.rb
 - lib/pg_party/model/list_methods.rb
 - lib/pg_party/model/methods.rb
 - lib/pg_party/model/range_methods.rb
@@ -239,8 +254,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.8.11
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: ActiveRecord PostgreSQL Partitioning