pg_party 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ceb308a34accd65263dc633ad43e2effabf750e8
-  data.tar.gz: 88fbc43ccc1e6228c3dbfa4b00fcb45bebcc4d12
+  metadata.gz: 820e7b5d4a74330f2871d8e8d5e278974001dd1f
+  data.tar.gz: 80a59da979fa45c339aa3abe0201c154809a4eb4
 SHA512:
-  metadata.gz: 27cec43797b297e82dc378d465cf1586fe9c74d91538c2ea9f9d5d93efb8a01f4c5ab38e56edd5ef4dabed25265f4d1f5d94fe3a4c0717a1ae1696a0b06d4773
-  data.tar.gz: 77ef5c1668d4cafe1101f859445ed49faa0e3053e30b62413a6c3c0db3c2dc8c95ddafb9ca92c30d6f6f1cae1956bb0822c243616edd24db98ef15da269392ec
+  metadata.gz: 4e14b35c529df6ea91d093e444962be64d65a112ab706b67bdce500904fb74eb88c31fd944aa06c9386f8cd365286841723ea71ecb883086604912ce6484d6db
+  data.tar.gz: 622f8c66614c01ef3a2a649f6e0c9123b07a7d73d8adbd74ef2428215ff70d78a70e554f5bd4b98e246beb2327d174b5badce0131d6127c19b59234f9bf10022

data/README.md

@@ -2,11 +2,20 @@
 
 [![Gem Version](https://badge.fury.io/rb/pg_party.svg)][rubygems]
 [![Build Status](https://circleci.com/gh/rkrage/pg_party.svg?&style=shield)][circle]
+[![Code Climate](https://codeclimate.com/github/rkrage/pg_party/badges/gpa.svg)][climate]
 
 [rubygems]: https://rubygems.org/gems/pg_party
 [circle]:   https://circleci.com/gh/rkrage/pg_party
+[climate]:  https://codeclimate.com/github/rkrage/pg_party
 
-Active Record migrations and model helpers for creating and managing PostgreSQL 10 partitions!
+[Active Record](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
+
+Note: PostgreSQL 10 is currently in beta. This gem should not be used in production environments (yet).
 
 ## Installation
 
@@ -26,11 +35,176 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Full API documentation is in progress.
+
+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
+
+### Migration Examples
+
+Create range partition on `created_at::date` with two child 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|
+      t.text :some_value
+      t.timestamps
+    end
+
+    create_range_partition_of \
+      :some_range_records,
+      partition_key: "created_at::date",
+      start_range: current_date,
+      end_range: current_date + 1.day
+
+     create_range_partition_of \
+       :some_range_records,
+       partition_key: "created_at::date",
+       start_range: current_date + 1.day,
+       end_range: current_date + 2.days
+  end
+end
+```
+
+Create list partition on `id` with two child partitions:
+
+```ruby
+class CreateSomeListRecord < ActiveRecord::Migration[5.1]
+  def up
+    create_list_partition :some_list_records, partition_key: :id do |t|
+      t.text :some_value
+      t.timestamps
+    end
+
+    create_list_partition_of \
+      :some_list_records,
+      partition_key: :id,
+      values: (1..100).to_a
+
+     create_list_partition_of \
+       :some_list_records,
+       partition_key: :id,
+       values: (100..200).to_a
+  end
+end
+```
+
+Attach an existing table to a range partition:
+
+```ruby
+class AttachRangePartition < ActiveRecord::Migration[5.1]
+  def up
+    attach_range_partition("parent_table", "child_table")
+  end
+end
+```
+
+Attach an existing table to a list partition:
+
+```ruby
+class AttachListPartition < ActiveRecord::Migration[5.1]
+  def up
+    attach_list_partition("parent_table", "child_table")
+  end
+end
+```
+
+Detach a child table from any partition:
+
+```ruby
+class DetachPartition < ActiveRecord::Migration[5.1]
+  def up
+    detach_partition("parent_table", "child_table")
+  end
+end
+```
+
+### Model Examples
+
+Define model that is backed by a range partition:
+
+```ruby
+class SomeRangeRecord < ApplicationRecord
+  range_partition_by "created_at::date"
+end
+ ```
+
+Define model that is backed by a list partition:
+
+```ruby
+class SomeListRecord < ApplicationRecord
+  list_partition_by :id
+end
+```
+
+Create child partition from range partition model:
+
+```ruby
+current_date = Date.current
+
+SomeRangeRecord.create_partition(start_range: current_date + 1.day, end_range: current_date + 2.days)
+```
+
+Create child partition from list partition model:
+
+```ruby
+SomeListRecord.create_partition(values: (200..300).to_a)
+```
+
+Query for records within partition range:
+
+```ruby
+SomeRangeRecord.partition_key_in("2017-01-01".to_date, "2017-02-01".to_date)
+```
+
+Query for records in partition list:
+
+```ruby
+SomeListRecord.partition_key_in(1, 2, 3, 4)
+```
+
+Query for records matching partition key:
+
+```ruby
+SomeRangeRecord.partition_key_eq(Date.current)
+
+SomeListRecord.partition_key_eq(100)
+```
+
+Query for records by partition name:
+
+```ruby
+# returns a collection of anonymous ActiveRecord::Base subclassed instances
+SomeRangeRecord.in_partition("some_range_records_partition_name")
+
+# returns a collection of anonymous ActiveRecord::Base subclassed instances
+SomeListRecord.in_partition("some_list_records_partition_name")
+```
 
 ## Development
 
-TODO: Write development instructions here
+The development / test environment relies heavily on [Docker](https://docs.docker.com).
+
+Start the containers in the background:
+
+    $ docker-compose up -d
+
+Install dependencies:
+
+    $ bin/de bundle
+    $ bin/de appraisal
+
+Run the tests:
+
+    $ bin/de rake
+
+Open a Pry console to play around with the sample Rails app:
+
+    $ bin/de console
 
 ## Contributing
 

data/lib/pg_party/{connection_adapters/abstract_adapter.rb → adapter/abstract_methods.rb}

@@ -1,31 +1,31 @@
 module PgParty
-  module ConnectionAdapters
-    module AbstractAdapter
-      def create_range_partition(*args)
+  module Adapter
+    module AbstractMethods
+      def create_range_partition(*)
         raise NotImplementedError, "#create_range_partition is not implemented"
       end
 
-      def create_list_partition(*args)
+      def create_list_partition(*)
         raise NotImplementedError, "#create_list_partition is not implemented"
       end
 
-      def create_range_partition_of(*args)
+      def create_range_partition_of(*)
         raise NotImplementedError, "#create_range_partition_of is not implemented"
       end
 
-      def create_list_partition_of(*args)
+      def create_list_partition_of(*)
         raise NotImplementedError, "#create_list_partition_of is not implemented"
       end
 
-      def attach_range_partition(*args)
+      def attach_range_partition(*)
         raise NotImplementedError, "#attach_range_partition is not implemented"
       end
 
-      def attach_list_partition(*args)
+      def attach_list_partition(*)
         raise NotImplementedError, "#attach_list_partition is not implemented"
       end
 
-      def detach_partition(*args)
+      def detach_partition(*)
         raise NotImplementedError, "#detach_partition is not implemented"
       end
     end

data/lib/pg_party/adapter/postgresql_methods.rb

@@ -0,0 +1,35 @@
+require "pg_party/adapter_decorator"
+
+module PgParty
+  module Adapter
+    module PostgreSQLMethods
+      def create_range_partition(*args, &blk)
+        PgParty::AdapterDecorator.new(self).create_range_partition(*args, &blk)
+      end
+
+      def create_list_partition(*args, &blk)
+        PgParty::AdapterDecorator.new(self).create_list_partition(*args, &blk)
+      end
+
+      def create_range_partition_of(*args)
+        PgParty::AdapterDecorator.new(self).create_range_partition_of(*args)
+      end
+
+      def create_list_partition_of(*args)
+        PgParty::AdapterDecorator.new(self).create_list_partition_of(*args)
+      end
+
+      def attach_range_partition(*args)
+        PgParty::AdapterDecorator.new(self).attach_range_partition(*args)
+      end
+
+      def attach_list_partition(*args)
+        PgParty::AdapterDecorator.new(self).attach_list_partition(*args)
+      end
+
+      def detach_partition(*args)
+        PgParty::AdapterDecorator.new(self).detach_partition(*args)
+      end
+    end
+  end
+end

data/lib/pg_party/adapter_decorator.rb

@@ -0,0 +1,133 @@
+require "digest"
+
+module PgParty
+  class AdapterDecorator < SimpleDelegator
+    def initialize(adapter)
+      super(adapter)
+
+      raise "Partitioning only supported in PostgreSQL >= 10.0" unless supports_partitions?
+    end
+
+    def create_range_partition(table_name, partition_key:, **options, &blk)
+      create_partition(table_name, :range, partition_key, **options, &blk)
+    end
+
+    def create_list_partition(table_name, partition_key:, **options, &blk)
+      create_partition(table_name, :list, partition_key, **options, &blk)
+    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)
+    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
+
+      constraint_clause = "IN (#{Array.wrap(values).map(&method(:quote)).join(",")})"
+
+      create_partition_of(table_name, child_table_name, constraint_clause, **options)
+    end
+
+    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)})
+      SQL
+    end
+
+    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(",")})
+      SQL
+    end
+
+    def detach_partition(parent_table_name, child_table_name)
+      execute(<<-SQL)
+        ALTER TABLE #{quote_table_name(parent_table_name)}
+        DETACH PARTITION #{quote_table_name(child_table_name)}
+      SQL
+    end
+
+    private
+
+    def create_partition(table_name, type, partition_key, **options)
+      modified_options = options.except(:id, :primary_key)
+      id               = options.fetch(:id, :bigserial)
+      primary_key      = options.fetch(:primary_key, :id)
+
+      raise ArgumentError, "composite primary key not supported" if primary_key.is_a?(Array)
+
+      modified_options[:id]      = false
+      modified_options[:options] = "PARTITION BY #{type.to_s.upcase} ((#{quote_partition_key(partition_key)}))"
+
+      create_table(table_name, modified_options) do |td|
+        if id == :uuid
+          td.send(id, primary_key, null: false, default: uuid_function)
+        elsif id
+          td.send(id, primary_key, null: false)
+        end
+
+        yield(td) if block_given?
+      end
+    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]
+
+      raise ArgumentError, "composite primary key not supported" if primary_key.is_a?(Array)
+
+      partition_clause = <<-SQL
+        PARTITION OF #{quote_table_name(table_name)}
+        FOR VALUES #{constraint_clause}
+      SQL
+
+      create_table(child_table_name, id: false, options: partition_clause)
+
+      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
+        add_index(child_table_name, "((#{quote_partition_key(partition_key)}))")
+      end
+
+      child_table_name
+    end
+
+    def quote_partition_key(key)
+      key.to_s.split("::").map(&method(:quote_column_name)).join("::")
+    end
+
+    def uuid_function
+      try(:supports_pgcrypto_uuid?) ? "gen_random_uuid()" : "uuid_generate_v4()"
+    end
+
+    def hashed_table_name(table_name, key)
+      "#{table_name}_#{Digest::MD5.hexdigest(key)[0..6]}"
+    end
+
+    def supports_partitions?
+      postgresql_version >= 100000
+    end
+  end
+end

data/lib/pg_party/model/list_methods.rb

@@ -0,0 +1,23 @@
+require "pg_party/model_decorator"
+
+module PgParty
+  module Model
+    module ListMethods
+      def create_partition(*args)
+        PgParty::ModelDecorator.new(self).create_list_partition(*args)
+      end
+
+      def in_partition(*args)
+        PgParty::ModelDecorator.new(self).in_partition(*args)
+      end
+
+      def partition_key_in(*args)
+        PgParty::ModelDecorator.new(self).list_partition_key_in(*args)
+      end
+
+      def partition_key_eq(*args)
+        PgParty::ModelDecorator.new(self).partition_key_eq(*args)
+      end
+    end
+  end
+end

data/lib/pg_party/model/methods.rb

@@ -0,0 +1,19 @@
+require "pg_party/model_injector"
+
+module PgParty
+  module Model
+    module Methods
+      def range_partition_by(key)
+        PgParty::ModelInjector.new(self, key).inject_range_methods
+      end
+
+      def list_partition_by(key)
+        PgParty::ModelInjector.new(self, key).inject_list_methods
+      end
+
+      def partitioned?
+        try(:partition_key).present?
+      end
+    end
+  end
+end

data/lib/pg_party/model/range_methods.rb

@@ -0,0 +1,23 @@
+require "pg_party/model_decorator"
+
+module PgParty
+  module Model
+    module RangeMethods
+      def create_partition(*args)
+        PgParty::ModelDecorator.new(self).create_range_partition(*args)
+      end
+
+      def in_partition(*args)
+        PgParty::ModelDecorator.new(self).in_partition(*args)
+      end
+
+      def partition_key_in(*args)
+        PgParty::ModelDecorator.new(self).range_partition_key_in(*args)
+      end
+
+      def partition_key_eq(*args)
+        PgParty::ModelDecorator.new(self).partition_key_eq(*args)
+      end
+    end
+  end
+end

data/lib/pg_party/model_decorator.rb

@@ -0,0 +1,62 @@
+module PgParty
+  class ModelDecorator < SimpleDelegator
+    def in_partition(table_name)
+      child_class(table_name).all
+    end
+
+    def partition_key_eq(value)
+      where(partition_key_as_arel.eq(value))
+    end
+
+    def range_partition_key_in(start_range, end_range)
+      node = partition_key_as_arel
+
+      where(node.gteq(start_range).and(node.lt(end_range)))
+    end
+
+    def list_partition_key_in(*values)
+      where(partition_key_as_arel.in(values.flatten))
+    end
+
+    def create_range_partition(start_range:, end_range:, **options)
+      modified_options = options.merge(
+        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)
+    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)
+    end
+
+    private
+
+    def child_class(table_name)
+      Class.new(__getobj__) do
+        self.table_name = table_name
+      end
+    end
+
+    def partition_key_as_arel
+      arel_column = arel_table[partition_column]
+
+      if partition_cast
+        quoted_cast = connection.quote_column_name(partition_cast)
+
+        Arel::Nodes::NamedFunction.new("CAST", [arel_column.as(quoted_cast)])
+      else
+        arel_column
+      end
+    end
+  end
+end

data/lib/pg_party/model_injector.rb

@@ -0,0 +1,39 @@
+module PgParty
+  class ModelInjector
+    def initialize(model, key)
+      @model = model
+      @key = key
+
+      @column, @cast = key.to_s.split("::")
+    end
+
+    def inject_range_methods
+      create_class_attributes
+
+      require "pg_party/model/range_methods"
+      @model.extend(PgParty::Model::RangeMethods)
+    end
+
+    def inject_list_methods
+      create_class_attributes
+
+      require "pg_party/model/list_methods"
+      @model.extend(PgParty::Model::ListMethods)
+    end
+
+    private
+
+    def create_class_attributes
+      @model.class_attribute(
+        :partition_key,
+        :partition_column,
+        :partition_cast,
+        instance_accessor: false
+      )
+
+      @model.partition_key = @key
+      @model.partition_column = @column
+      @model.partition_cast = @cast
+    end
+  end
+end

data/lib/pg_party/version.rb

@@ -1,3 +1,3 @@
 module PgParty
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/pg_party.rb

@@ -2,15 +2,20 @@ require "pg_party/version"
 require "active_support"
 
 ActiveSupport.on_load(:active_record) do
-  require "pg_party/connection_handling"
-  require "pg_party/model_methods"
+  require "pg_party/model/methods"
 
-  extend PgParty::ConnectionHandling
-  extend PgParty::ModelMethods
+  extend PgParty::Model::Methods
 
-  require "pg_party/connection_adapters/abstract_adapter"
+  require "pg_party/adapter/abstract_methods"
 
   ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval do
-    include PgParty::ConnectionAdapters::AbstractAdapter
+    include PgParty::Adapter::AbstractMethods
+  end
+
+  require "pg_party/adapter/postgresql_methods"
+  require "active_record/connection_adapters/postgresql_adapter"
+
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+    include PgParty::Adapter::PostgreSQLMethods
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_party
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Ryan Krage
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-16 00:00:00.000000000 Z
+date: 2017-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -189,13 +189,14 @@ files:
 - LICENSE.txt
 - README.md
 - lib/pg_party.rb
-- lib/pg_party/connection_adapters/abstract_adapter.rb
-- lib/pg_party/connection_adapters/postgresql_adapter.rb
-- lib/pg_party/connection_handling.rb
-- lib/pg_party/injected_list_model_methods.rb
-- lib/pg_party/injected_model_methods.rb
-- lib/pg_party/injected_range_model_methods.rb
-- lib/pg_party/model_methods.rb
+- lib/pg_party/adapter/abstract_methods.rb
+- lib/pg_party/adapter/postgresql_methods.rb
+- lib/pg_party/adapter_decorator.rb
+- lib/pg_party/model/list_methods.rb
+- lib/pg_party/model/methods.rb
+- lib/pg_party/model/range_methods.rb
+- lib/pg_party/model_decorator.rb
+- lib/pg_party/model_injector.rb
 - lib/pg_party/version.rb
 homepage: https://github.com/rkrage/pg_party
 licenses:
@@ -217,7 +218,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.8.11
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: ActiveRecord PostgreSQL Partitioning

data/lib/pg_party/connection_adapters/postgresql_adapter.rb

@@ -1,125 +0,0 @@
-require "digest"
-
-module PgParty
-  module ConnectionAdapters
-    module PostgreSQLAdapter
-      def create_range_partition(table_name, partition_key:, **options, &blk)
-        create_partition(table_name, :range, partition_key, **options, &blk)
-      end
-
-      def create_list_partition(table_name, partition_key:, **options, &blk)
-        create_partition(table_name, :list, partition_key, **options, &blk)
-      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)
-      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
-
-        constraint_clause = "IN (#{Array.wrap(values).map(&method(:quote)).join(",")})"
-
-        create_partition_of(table_name, child_table_name, constraint_clause, **options)
-      end
-
-      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)})
-        SQL
-      end
-
-      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(",")})
-        SQL
-      end
-
-      def detach_partition(parent_table_name, child_table_name)
-        execute(<<-SQL)
-          ALTER TABLE #{quote_table_name(parent_table_name)}
-          DETACH PARTITION #{quote_table_name(child_table_name)}
-        SQL
-      end
-
-      private
-
-      def create_partition(table_name, type, partition_key, **options)
-        modified_options = options.except(:id, :primary_key)
-        id               = options.fetch(:id, :bigserial)
-        primary_key      = options.fetch(:primary_key, :id)
-
-        raise ArgumentError, "composite primary key not supported" if primary_key.is_a?(Array)
-
-        modified_options[:id]      = false
-        modified_options[:options] = "PARTITION BY #{type.to_s.upcase} ((#{quote_partition_key(partition_key)}))"
-
-        create_table(table_name, modified_options) do |td|
-          if id == :uuid
-            td.send(id, primary_key, null: false, default: uuid_function)
-          elsif id
-            td.send(id, primary_key, null: false)
-          end
-
-          yield td if block_given?
-        end
-      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]
-
-        raise ArgumentError, "composite primary key not supported" if primary_key.is_a?(Array)
-
-        partition_clause = <<-SQL
-          PARTITION OF #{quote_table_name(table_name)}
-          FOR VALUES #{constraint_clause}
-        SQL
-
-        create_table(child_table_name, id: false, options: partition_clause)
-
-        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
-          add_index(child_table_name, "((#{quote_partition_key(partition_key)}))")
-        end
-
-        child_table_name
-      end
-
-      def quote_partition_key(key)
-        key.to_s.split("::").map(&method(:quote_column_name)).join("::")
-      end
-
-      def uuid_function
-        try(:supports_pgcrypto_uuid?) ? "gen_random_uuid()" : "uuid_generate_v4()"
-      end
-
-      def hashed_table_name(table_name, key)
-        "#{table_name}_#{Digest::MD5.hexdigest(key)[0..6]}"
-      end
-    end
-  end
-end

data/lib/pg_party/connection_handling.rb

@@ -1,15 +0,0 @@
-module PgParty
-  module ConnectionHandling
-    def establish_connection(*args)
-      super.tap do
-        if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
-          require "pg_party/connection_adapters/postgresql_adapter"
-
-          ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
-            include PgParty::ConnectionAdapters::PostgreSQLAdapter
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pg_party/injected_list_model_methods.rb

@@ -1,21 +0,0 @@
-require "pg_party/injected_model_methods"
-
-module PgParty
-  module InjectedListModelMethods
-    include InjectedModelMethods
-
-    def create_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)
-    end
-
-    def partition_key_in(*values)
-      where(partition_key_as_arel.in(values.flatten))
-    end
-  end
-end

data/lib/pg_party/injected_model_methods.rb

@@ -1,23 +0,0 @@
-module PgParty
-  module InjectedModelMethods
-    attr_reader :partition_key, :partition_column, :partition_cast
-
-    def partition_key_matching(value)
-      where(partition_key_as_arel.eq(value))
-    end
-
-    private
-
-    def partition_key_as_arel
-      arel_column = arel_table[partition_column]
-
-      if partition_cast
-        quoted_cast = connection.quote_column_name(partition_cast)
-
-        Arel::Nodes::NamedFunction.new("CAST", [arel_column.as(quoted_cast)])
-      else
-        arel_column
-      end
-    end
-  end
-end

data/lib/pg_party/injected_range_model_methods.rb

@@ -1,24 +0,0 @@
-require "pg_party/injected_model_methods"
-
-module PgParty
-  module InjectedRangeModelMethods
-    include InjectedModelMethods
-
-    def create_partition(start_range:, end_range:, **options)
-      modified_options = options.merge(
-        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)
-    end
-
-    def partition_key_in(start_range, end_range)
-      node = partition_key_as_arel
-
-      where(node.gteq(start_range).and(node.lt(end_range)))
-    end
-  end
-end

data/lib/pg_party/model_methods.rb

@@ -1,23 +0,0 @@
-module PgParty
-  module ModelMethods
-    def range_partition_by(key)
-      @partition_key = key
-      @partition_column, @partition_cast = key.to_s.split("::")
-
-      require "pg_party/injected_range_model_methods"
-      extend InjectedRangeModelMethods
-    end
-
-    def list_partition_by(key)
-      @partition_key = key
-      @partition_column, @partition_cast = key.to_s.split("::")
-
-      require "pg_party/injected_list_model_methods"
-      extend InjectedListModelMethods
-    end
-
-    def partitioned?
-      @partition_key.present?
-    end
-  end
-end