tablature 0.3.1 → 1.0.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d2ff14d9d94a6ab38483d133cfc3679a1647888683ca767e8201f5ca1db5357
-  data.tar.gz: dd65acaba0dae0cc4d659e3d9505c02483dac1bc5ae04d701741db3fad74f2ad
+  metadata.gz: 8db9f3d3c82e1667d5931739f53bdc0c218f01281c56e3e1cd2541b51264ae4f
+  data.tar.gz: 45fa5efd4a15199e22d5d15b8d0f84114de3ed634121171bb561ff206c5bcc28
 SHA512:
-  metadata.gz: 25d6f5d66c1b72e7887eeae052476a2bdd161c59023c882edbc2cfe52673d279448102092810119990f9057ff6844c8f887921e7d5093903c5ebb2cabe333447
-  data.tar.gz: 65aa6da3dbcd404efb155665f4ce88481b3dbe6858170b6259292d09563880718656ea22eff17a885c7d74120337a8d05d38927b1c68f36d09f00d7d0389af8a
+  metadata.gz: d30f66c7398da2249edc10d3b4a5d2239aa017647f78c266fb07708abc943ee9d79f950d57e93a508c1d4211a408de17d7f97c96b092e9237a8962abdcfba58d
+  data.tar.gz: db95e1b650a5337be05a61986ae99ed4adb829d9dd2d98642b34907bdd71416da8dbfe1f8ec66bdc9caa2ec0e0b178b433ec39afa625928afe6d1708c4912558

data/.github/workflows/ci.yml

@@ -0,0 +1,68 @@
+name: CI
+
+on:
+  push:
+    branches: master
+  pull_request:
+    branches: "*"
+
+jobs:
+  build:
+    name: Ruby ${{ matrix.ruby }}, Rails ${{ matrix.rails }}, Postgres ${{ matrix.postgres }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ["2.5", "2.7"]
+        rails: ["5.2", "6.0", "master"]
+        postgres: ["10.12", "11.7", "12.2"]
+        include:
+          - postgres: "10.12"
+            rspec_tag: --tag ~postgres_11
+          - rails: "master"
+            continue-on-error: true
+
+    runs-on: ubuntu-latest
+
+    services:
+      postgres:
+        image: postgres:${{ matrix.postgres }}-alpine
+        env:
+          POSTGRES_PASSWORD: postgres
+        ports:
+          - 5432:5432
+        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+
+    env:
+      RAILS_VERSION: ${{ matrix.rails }}
+      POSTGRES_USER: "postgres"
+      POSTGRES_PASSWORD: "postgres"
+      CI: "true"
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Install dependent libraries
+        run: sudo apt-get install libpq-dev
+
+      - name: Install Ruby ${{ matrix.ruby }}
+        uses: ruby/setup-ruby@v1.31.0
+        with:
+          ruby-version: ${{ matrix.ruby }}
+
+      - name: Generate lockfile
+        run: bundle lock
+
+      - name: Cache dependencies
+        uses: actions/cache@v1
+        with:
+          path: vendor/bundle
+          key: bundle-${{ hashFiles('Gemfile.lock') }}
+
+      - name: Set up Tablature
+        run: bin/setup
+
+      - name: Run tests
+        run: bundle exec rspec ${{ matrix.rspec_tag }}
+        continue-on-error: ${{ matrix.continue-on-error }}

data/.gitignore

@@ -9,3 +9,5 @@
 
 # rspec failure tracking
 .rspec_status
+
+Gemfile.lock

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.5
 
 Metrics/BlockLength:
   Exclude:

data/.yardopts

@@ -0,0 +1 @@
+-m markdown

data/Gemfile

@@ -1,3 +1,15 @@
+source "https://rubygems.org"
 gemspec
 
 gem 'pry'
+gem 'rubocop'
+
+rails_version = ENV.fetch("RAILS_VERSION", "6.0")
+
+if rails_version == "master"
+  rails_constraint = { github: "rails/rails" }
+else
+  rails_constraint = "~> #{rails_version}.0"
+end
+
+gem "rails", rails_constraint

data/README.md

@@ -7,7 +7,7 @@ It ships with Postgres support and can easily supports other databases through a
 
 ##### Requirements
 
-Tablature requires Rails 5+ and Postgres 10+.
+Tablature requires Ruby 2.5+, Rails 5+ and Postgres 10+.
 
 ##### Installation
 
@@ -67,7 +67,6 @@ end
 
 ### Having a partition back a model
 
-
 In your migration:
 ```ruby
 # db/migrate/create_events.rb
@@ -93,7 +92,7 @@ end
 
 In your model, calling one of `range_partition` or `list_partition` to inject
 methods:
-```
+```ruby
 # app/models/event.rb
 class Event < ApplicationRecord
   range_partition
@@ -118,6 +117,49 @@ You can also create new partitions directly from the model :
 # => ["events_y2018m12", "events_y2019m01", "events_y2019m02"]
 ```
 
+### Partitioning an existing table
+Start by renaming your table and create the partition table:
+```ruby
+class PartitionEvents < ActiveRecord::Migration
+  def change
+    # Get the bounds of the events.
+    min_month = Event.minimum(:timestamp).beginning_of_month.to_date
+    max_month = Event.maximum(:timestamp).beginning_of_month.to_date
+
+    # Create the partition bounds based on the existing data. In this example,
+    # we generate an array with the ranges.
+    months = min_month.upto(max_month).uniq(&:beginning_of_month)
+
+    # Rename the existing table.
+    rename_table :events, :old_events
+
+    # Create the partitioned table.
+    create_range_partition :events, partition_key: -> { '(timestamp::DATE)' } do |t|
+      t.string :event_type, null: false
+      t.integer :value, null: false
+      t.datetime :timestamp, null: false
+      t.timestamps
+    end
+
+    # Create the partitions based on the bounds generated before:
+    months.each do |month|
+      # Creates a name like "events_y2018m12"
+      partition_name = "events_y#{month.year}m#{month.month}"
+
+      create_range_partition_of :events,
+        name: partition_name, range_start: month, range_end: month.next_month
+    end
+
+    # Finally, add the rows from the old table to the new partitioned table.
+    # This might take some time depending on the size of your old table.
+    execute(<<~SQL)
+      INSERT INTO events
+      SELECT * FROM old_events
+    SQL
+  end
+end
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.

data/lib/tablature/adapters/postgres/connection.rb

@@ -31,6 +31,13 @@ module Tablature
           postgresql_version >= 110_000
         end
 
+        # True if the connection supports default partitions.
+        #
+        # @return [Boolean]
+        def supports_default_partitions?
+          postgresql_version >= 110_000
+        end
+
         # An integer representing the version of Postgres we're connected to.
         #
         # +postgresql_version+ is public in Rails 5, but protected in earlier

data/lib/tablature/adapters/postgres/errors.rb

@@ -1,6 +1,23 @@
 module Tablature
   module Adapters
     class Postgres
+      # Raised when a setting a partition as default  on a database
+      # version that does not support default partitions.
+      #
+      # Default partitions are supported on Postgres 11 or newer.
+      class DefaultPartitionNotSupportedError < StandardError
+        def initialize
+          super('Default partitions require Postgres 11 or newer')
+        end
+      end
+
+      # Raised when trying to attach or detach a partition without supplying a name.
+      class MissingPartitionName < StandardError
+        def initialize
+          super('Missing partition name')
+        end
+      end
+
       # Raised when a list partition operation is attempted on a database
       # version that does not support list partitions.
       #
@@ -15,7 +32,7 @@ module Tablature
       # key.
       class MissingListPartitionValuesError < StandardError
         def initialize
-          super('Missing values for of list partition')
+          super('Missing values for list partition')
         end
       end
 
@@ -33,7 +50,7 @@ module Tablature
       # key.
       class MissingRangePartitionBoundsError < StandardError
         def initialize
-          super('Missing bounds for of range partition')
+          super('Missing bounds for range partition')
         end
       end
     end

data/lib/tablature/adapters/postgres/handlers/base.rb

@@ -13,6 +13,10 @@ module Tablature
 
           protected
 
+          def raise_unless_default_partition_supported
+            raise DefaultPartitionNotSupportedError unless connection.supports_default_partitions?
+          end
+
           def create_partition(table_name, id_options, table_options, &block)
             create_table(table_name, table_options) do |td|
               # TODO: Handle the id things here (depending on the postgres version)

data/lib/tablature/adapters/postgres/handlers/list.rb

@@ -29,15 +29,50 @@ module Tablature
 
           def create_list_partition_of(parent_table, options)
             values = options.fetch(:values, [])
-            raise MissingListPartitionValuesError if values.blank?
+            as_default = options.fetch(:default, false)
+
+            raise_unless_default_partition_supported if as_default
+            raise MissingListPartitionValuesError if values.blank? && !as_default
 
             name = options.fetch(:name, partition_name(parent_table, values))
             # TODO: Call `create_table` here instead of running the query.
             # TODO: Pass the options to `create_table` to allow further configuration of the table,
             # e.g. sub-partitioning the table.
-            query = <<~SQL.strip
+
+            query = <<~SQL
               CREATE TABLE #{quote_table_name(name)} PARTITION OF #{quote_table_name(parent_table)}
-              FOR VALUES IN (#{quote_collection(values)})
+            SQL
+
+            query += if as_default
+                       'DEFAULT'
+                     else
+                       "FOR VALUES IN (#{quote_collection(values)})"
+                     end
+
+            execute(query)
+          end
+
+          def attach_to_list_partition(parent_table, options)
+            values = options.fetch(:values, [])
+            as_default = options.fetch(:default, false)
+
+            raise_unless_default_partition_supported if as_default
+            raise MissingListPartitionValuesError if values.blank? && !as_default
+
+            name = options.fetch(:name) { raise MissingPartitionName }
+
+            if as_default
+              attach_default_partition(parent_table, name)
+            else
+              attach_partition(parent_table, name, values)
+            end
+          end
+
+          def detach_from_list_partition(parent_table, options)
+            name = options.fetch(:name) { raise MissingPartitionName }
+            query = <<~SQL.strip
+              ALTER TABLE #{quote_table_name(parent_table)}
+              DETACH PARTITION #{quote_table_name(name)}
             SQL
 
             execute(query)
@@ -59,6 +94,25 @@ module Tablature
             key = values.inspect
             "#{parent_table}_#{Digest::MD5.hexdigest(key)[0..6]}"
           end
+
+          def attach_default_partition(parent_table, partition_name)
+            query = <<~SQL.strip
+              ALTER TABLE #{quote_table_name(parent_table)}
+              ATTACH PARTITION #{quote_table_name(partition_name)} DEFAULT
+            SQL
+
+            execute(query)
+          end
+
+          def attach_partition(parent_table, partition_name, values)
+            query = <<~SQL.strip
+              ALTER TABLE #{quote_table_name(parent_table)}
+              ATTACH PARTITION #{quote_table_name(partition_name)}
+              FOR VALUES IN (#{quote_collection(values)})
+            SQL
+
+            execute(query)
+          end
         end
       end
     end

data/lib/tablature/adapters/postgres/handlers/range.rb

@@ -31,16 +31,56 @@ module Tablature
           def create_range_partition_of(parent_table, options)
             range_start = options.fetch(:range_start, nil)
             range_end = options.fetch(:range_end, nil)
+            as_default = options.fetch(:default, false)
 
-            raise MissingRangePartitionBoundsError if range_start.nil? || range_end.nil?
+            raise_unless_default_partition_supported if as_default
+            if (range_start.nil? || range_end.nil?) && !as_default
+              raise MissingRangePartitionBoundsError
+            end
 
             name = options.fetch(:name, partition_name(parent_table, range_start, range_end))
             # TODO: Call `create_table` here instead of running the query.
             # TODO: Pass the options to `create_table` to allow further configuration of the table,
             # e.g. sub-partitioning the table.
-            query = <<~SQL.strip
+
+            query = <<~SQL
               CREATE TABLE #{quote_table_name(name)} PARTITION OF #{quote_table_name(parent_table)}
-              FOR VALUES FROM (#{quote(range_start)}) TO (#{quote(range_end)});
+            SQL
+
+            query += if as_default
+                       'DEFAULT'
+                     else
+                       "FOR VALUES FROM (#{quote(range_start)}) TO (#{quote(range_end)})"
+                     end
+
+            execute(query)
+          end
+
+          def attach_to_range_partition(parent_table, options)
+            range_start = options.fetch(:range_start, nil)
+            range_end = options.fetch(:range_end, nil)
+            as_default = options.fetch(:default, false)
+
+            raise_unless_default_partition_supported if as_default
+            if (range_start.nil? || range_end.nil?) && !as_default
+              raise MissingRangePartitionBoundsError
+            end
+
+            name = options.fetch(:name) { raise MissingPartitionName }
+
+            if as_default
+              attach_default_partition(parent_table, name)
+            else
+              attach_partition(parent_table, name, range_start, range_end)
+            end
+          end
+
+          def detach_from_range_partition(parent_table, options)
+            name = options.fetch(:name) { raise MissingPartitionName }
+
+            query = <<~SQL.strip
+              ALTER TABLE #{quote_table_name(parent_table)}
+              DETACH PARTITION #{quote_table_name(name)}
             SQL
 
             execute(query)
@@ -61,6 +101,25 @@ module Tablature
             key = [range_start, range_end].join(', ')
             "#{parent_table}_#{Digest::MD5.hexdigest(key)[0..6]}"
           end
+
+          def attach_default_partition(parent_table, partition_name)
+            query = <<~SQL.strip
+              ALTER TABLE #{quote_table_name(parent_table)}
+              ATTACH PARTITION #{quote_table_name(partition_name)} DEFAULT
+            SQL
+
+            execute(query)
+          end
+
+          def attach_partition(parent_table, partition_name, range_start, range_end)
+            query = <<~SQL.strip
+              ALTER TABLE #{quote_table_name(parent_table)}
+              ATTACH PARTITION #{quote_table_name(partition_name)}
+              FOR VALUES FROM (#{quote(range_start)}) TO (#{quote(range_end)})
+            SQL
+
+            execute(query)
+          end
         end
       end
     end

data/lib/tablature/adapters/postgres/partitioned_tables.rb

@@ -23,9 +23,11 @@ module Tablature
           connection.execute(<<-SQL)
             SELECT
               c.oid,
+              i.inhrelid,
               c.relname AS table_name,
-              p.partstrat AS type,
+              p.partstrat AS strategy,
               (i.inhrelid::REGCLASS)::TEXT AS partition_name,
+              #{connection.supports_default_partitions? ? 'i.inhrelid = p.partdefid AS is_default_partition,' : ''}
               pg_get_partkeydef(c.oid) AS partition_key_definition
             FROM pg_class c
               INNER JOIN pg_partitioned_table p ON c.oid = p.partrelid
@@ -39,26 +41,25 @@ module Tablature
           SQL
         end
 
-        METHOD_MAP = {
+        STRATEGY_MAP = {
           'l' => :list,
           'r' => :range,
           'h' => :hash
         }.freeze
-        private_constant :METHOD_MAP
+        private_constant :STRATEGY_MAP
 
         def to_tablature_table(table_name, rows)
           result = rows.first
-          partitioning_method = METHOD_MAP.fetch(result['type'])
-          partitions = rows.map { |row| row['partition_name'] }.compact.map(&method(:unquote))
+          partitioning_strategy = STRATEGY_MAP.fetch(result['strategy'])
           # This is very fragile code. This makes the assumption that:
           # - Postgres will always have a function `pg_get_partkeydef` that returns the partition
-          # method with the partition key
-          # - Postgres will never have a partition method with two words in its name.
+          # strategy with the partition key
+          # - Postgres will never have a partition strategy with two words in its name.
           _, partition_key = result['partition_key_definition'].split(' ', 2)
 
           Tablature::PartitionedTable.new(
-            name: table_name, partitioning_method: partitioning_method,
-            partitions: partitions, partition_key: partition_key
+            name: table_name, partitioning_strategy: partitioning_strategy,
+            partitions: rows, partition_key: partition_key
           )
         end
 

data/lib/tablature/adapters/postgres.rb

@@ -68,14 +68,44 @@ module Tablature
       # @option options [String, Symbol] :values The values appearing in the partition.
       # @option options [String, Symbol] :name The name of the partition. If it is not given, this
       #   will be randomly generated.
+      # @option options [Boolean] :default Whether the partition is the default partition or not.
       #
       # @example
       #   # With a table :events partitioned using the list method on the partition key `date`:
       #   create_list_partition_of :events, name: "events_2018-W49", values: [
-      #     "2018-12-03", "2018-12-04", "2018-12-05", "2018-12-06", "2018-12-07", "2018-12-08", "2018-12-09"
+      #     "2018-12-03", "2018-12-04", "2018-12-05", "2018-12-06", "2018-12-07", "2018-12-08",
+      #     "2018-12-09"
       #   ]
       delegate :create_list_partition_of, to: :list_handler
 
+      # @!method attach_to_list_partition(parent_table_name, options)
+      # Attaches a partition to a parent by specifying the key values appearing in the partition.
+      #
+      # @param parent_table_name [String, Symbol] The name of the parent table.
+      # @param [Hash] options The options to attach the partition.
+      # @option options [String, Symbol] :name The name of the partition.
+      # @option options [String, Symbol] :values The values appearing in the partition.
+      #
+      # @example
+      #   # With a table :events partitioned using the list method on the partition key `date`:
+      #   attach_to_list_partition :events, name: "events_2018-W49", values: [
+      #     "2018-12-03", "2018-12-04", "2018-12-05", "2018-12-06", "2018-12-07", "2018-12-08",
+      #     "2018-12-09"
+      #   ]
+      delegate :attach_to_list_partition, to: :list_handler
+
+      # @!method detach_from_list_partition(parent_table_name, options)
+      # Detaches a partition from a parent.
+      #
+      # @param parent_table_name [String, Symbol] The name of the parent table.
+      # @param [Hash] options The options to create the partition.
+      # @option options [String, Symbol] :name The name of the partition.
+      #
+      # @example
+      #   # With a table :events partitioned using the list method on the partition key `date`:
+      #   detach_from_list_partition :events, name: "events_2018-W49"
+      delegate :detach_from_list_partition, to: :list_handler
+
       # @!method create_range_partition(table_name, options, &block)
       # Creates a partitioned table using the range partition method.
       #
@@ -102,12 +132,13 @@ module Tablature
       #
       # @param parent_table_name [String, Symbol] The name of the parent table.
       # @param [Hash] options The options to create the partition.
+      # @option options [String, Symbol] :name The name of the partition. If it is not given, this
+      #   will be randomly generated.
       # @option options [String, Symbol] :range_start The start of the range of values appearing in
       #   the partition.
       # @option options [String, Symbol] :range_end The end of the range of values appearing in
       #   the partition.
-      # @option options [String, Symbol] :name The name of the partition. If it is not given, this
-      #   will be randomly generated.
+      # @option options [Boolean] :default Whether the partition is the default partition or not.
       #
       # @example
       #   # With a table :events partitioned using the range method on the partition key `date`:
@@ -115,6 +146,35 @@ module Tablature
       #                                                               range_end: '2018-12-10'
       delegate :create_range_partition_of, to: :range_handler
 
+      # @!method attach_to_range_partition(parent_table_name, options)
+      # Attaches a partition to a parent by specifying the key values appearing in the partition.
+      #
+      # @param parent_table_name [String, Symbol] The name of the parent table.
+      # @param [Hash] options The options to create the partition.
+      # @option options [String, Symbol] :name The name of the partition.
+      # @option options [String, Symbol] :range_start The start of the range of values appearing in
+      #   the partition.
+      # @option options [String, Symbol] :range_end The end of the range of values appearing in
+      #   the partition.
+      # @option options [Boolean] :default Whether the partition is the default partition or not.
+      #
+      # @example
+      #   # With a table :events partitioned using the range method on the partition key `date`:
+      #   attach_to_range_partition :events, name: "events_2018-W49", range_start: '2018-12-03',
+      #                                                               range_end: '2018-12-10'
+      delegate :attach_to_range_partition, to: :range_handler
+
+      # @!method detach_from_range_partition(parent_table_name, options)
+      # Detaches a partition from a parent.
+      #
+      # @param parent_table_name [String, Symbol] The name of the parent table.
+      # @param [Hash] options The options to detach the partition.
+      # @option options [String, Symbol] :name The name of the partition.
+      #
+      # @example
+      #   detach_from_range_partition :events, name: "events_2018-W49"
+      delegate :detach_from_range_partition, to: :range_handler
+
       # Returns an array of partitioned tables in the database.
       #
       # This collection of tables is used by the [Tablature::SchemaDumper] to populate the schema.rb

data/lib/tablature/command_recorder.rb

@@ -1,4 +1,97 @@
 module Tablature
+  # @api private
   module CommandRecorder
+    def create_list_partition(*args)
+      record(:create_list_partition, args)
+    end
+
+    def create_list_partition_of(*args)
+      record(:create_list_partition_of, args)
+    end
+
+    def attach_to_list_partition(*args)
+      record(:attach_to_list_partition, args)
+    end
+
+    def detach_from_list_partition(*args)
+      record(:detach_from_list_partition, args)
+    end
+
+    def create_range_partition(*args)
+      record(:create_range_partition, args)
+    end
+
+    def create_range_partition_of(*args)
+      record(:create_range_partition_of, args)
+    end
+
+    def attach_to_range_partition(*args)
+      record(:attach_to_range_partition, args)
+    end
+
+    def detach_from_range_partition(*args)
+      record(:detach_from_range_partition, args)
+    end
+
+    def invert_create_partition(args)
+      [:drop_table, [args.first]]
+    end
+
+    alias :invert_create_list_partition :invert_create_partition
+    alias :invert_create_range_partition :invert_create_partition
+
+    def invert_create_partition_of(args)
+      _parent_table_name, options = args
+      partition_name = options[:name]
+
+      [:drop_table, [partition_name]]
+    end
+
+    alias :invert_create_list_partition_of :invert_create_partition_of
+    alias :invert_create_range_partition_of :invert_create_partition_of
+
+    def invert_attach_to_range_partition(args)
+      [:detach_from_range_partition, args]
+    end
+
+    def invert_detach_from_range_partition(args)
+      parent_table_name, options = args
+      options ||= {}
+      _partition_name = options[:name]
+
+      range_start = options[:range_start]
+      range_end = options[:range_end]
+      default = options[:default]
+
+      if (range_start.nil? || range_end.nil?) && default.blank?
+        message = <<-MESSAGE
+          invert_detach_from_range_partition is reversible only if given bounds or the default option
+        MESSAGE
+        raise ActiveRecord::IrreversibleMigration, message
+      end
+
+      [:attach_to_range_partition, [parent_table_name, options]]
+    end
+
+    def invert_attach_to_list_partition(args)
+      [:detach_from_list_partition, args]
+    end
+
+    def invert_detach_from_list_partition(args)
+      partitioned_table, options = args
+      options ||= {}
+
+      default = options[:default]
+      values = options[:values] || []
+
+      if values.blank? && default.blank?
+        message = <<-MESSAGE
+          invert_detach_from_list_partition is reversible only if given the value list or the default option
+        MESSAGE
+        raise ActiveRecord::IrreversibleMigration, message
+      end
+
+      [:attach_to_list_partition, [partitioned_table, options]]
+    end
   end
 end

data/lib/tablature/model.rb

@@ -15,7 +15,7 @@ module Tablature
     module ClassMethods
       extend Forwardable
 
-      def_delegators :tablature_partition, :partitions, :partition_key, :partitioning_method
+      def_delegators :tablature_partition, :partitions, :partition_key, :partitioning_strategy
 
       def partitioned?
         begin
@@ -28,12 +28,14 @@ module Tablature
       end
 
       def tablature_partition
-        partition = Tablature.database.partitioned_tables.find do |pt|
+        return @tablature_partition if defined?(@tablature_partition)
+
+        @tablature_partition = Tablature.database.partitioned_tables.find do |pt|
           pt.name == partition_name.to_s
         end
-        raise Tablature::MissingPartition if partition.nil?
+        raise Tablature::MissingPartition if @tablature_partition.nil?
 
-        partition
+        @tablature_partition
       end
 
       def list_partition(partition_name = table_name)

data/lib/tablature/partition.rb

@@ -0,0 +1,23 @@
+module Tablature
+  # The in-memory representation of a partition.
+  #
+  # **This object is used internally by adapters and the schema dumper and is
+  # not intended to be used by application code. It is documented here for
+  # use by adapter gems.**
+  #
+  # @api private
+  class Partition
+    attr_reader :name
+    attr_reader :parent_table_name
+
+    def initialize(name:, parent_table_name:, default_partition: false)
+      @name = name
+      @parent_table_name = parent_table_name
+      @default_partition = default_partition
+    end
+
+    def default_partition?
+      @default_partition
+    end
+  end
+end

data/lib/tablature/partitioned_table.rb

@@ -5,35 +5,54 @@ module Tablature
   # not intended to be used by application code. It is documented here for
   # use by adapter gems.**
   #
-  # @api extension
+  # @api private
   class PartitionedTable
     # The name of the partitioned table
     # @return [String]
+    # @api private
     attr_reader :name
 
-    # The partitioning method of the table
+    # The partitioning strategy of the table
     # @return [Symbol]
-    attr_reader :partitioning_method
+    # @api private
+    attr_reader :partitioning_strategy
 
     # The partitions of the table.
     # @return [Array]
+    # @api private
     attr_reader :partitions
 
     # The partition key expression.
     # @return [String]
+    # @api private
     attr_reader :partition_key
 
     # Returns a new instance of PartitionTable.
     #
     # @param name [String] The name of the view.
-    # @param partitioning_method [:symbol] One of :range, :list or :hash
+    # @param partitioning_strategy [:symbol] One of :range, :list or :hash
     # @param partitions [Array] The partitions of the table.
     # @param partition_key [String] The partition key expression.
-    def initialize(name:, partitioning_method:, partitions: [], partition_key:)
+    # @api private
+    def initialize(name:, partitioning_strategy:, partitions: [], partition_key:)
       @name = name
-      @partitioning_method = partitioning_method
-      @partitions = partitions
+      @partitioning_strategy = partitioning_strategy
+      @partitions = partitions.map do |row|
+        Tablature::Partition.new(
+          name: row['partition_name'],
+          parent_table_name: row['table_name'],
+          default_partition: row['is_default_partition']
+        )
+      end
       @partition_key = partition_key
     end
+
+    # Returns the representation of the default partition if present.
+    #
+    # @return [Tablature::Partition]
+    # @api private
+    def default_partition
+      partitions.find(&:default_partition?)
+    end
   end
 end

data/lib/tablature/schema_dumper.rb

@@ -16,7 +16,7 @@ module Tablature
     end
 
     def partitions
-      dumpable_partitioned_tables.flat_map(&:partitions)
+      dumpable_partitioned_tables.flat_map { |t| t.partitions.map(&:name) }
     end
   end
 end

data/lib/tablature/statements.rb

@@ -3,15 +3,15 @@ module Tablature
   module Statements
     # Creates a partitioned table using the list partition method.
     #
-    # @param name [String, Symbol] The name of the partition.
+    # @param table_name [String, Symbol] The name of the partition.
     # @param options [Hash] The options to create the partition.
     # @yield [td] A TableDefinition object. This allows creating the table columns the same way
     #   as Rails's +create_table+ does.
     # @see Tablature::Adapters::Postgres#create_list_partition
-    def create_list_partition(name, options, &block)
+    def create_list_partition(table_name, options, &block)
       raise ArgumentError, 'partition_key must be defined' if options[:partition_key].nil?
 
-      Tablature.database.create_list_partition(name, options, &block)
+      Tablature.database.create_list_partition(table_name, options, &block)
     end
 
     # Creates a partition of a parent by specifying the key values appearing in the partition.
@@ -21,23 +21,52 @@ module Tablature
     #
     # @see Tablature::Adapters::Postgres#create_list_partition_of
     def create_list_partition_of(parent_table_name, options)
-      raise ArgumentError, 'values must be defined' if options[:values].nil?
+      if options[:values].blank? && options[:default].blank?
+        raise ArgumentError, 'values or default must be defined'
+      end
 
       Tablature.database.create_list_partition_of(parent_table_name, options)
     end
 
+    # Attaches a partition to a parent by specifying the key values appearing in the partition.
+    #
+    # @param parent_table_name [String, Symbol] The name of the parent table.
+    # @param [Hash] options The options to attach the partition.
+    #
+    # @see Tablature::Adapters::Postgres#attach_to_list_partition
+    def attach_to_list_partition(parent_table_name, options)
+      raise ArgumentError, 'name must be defined' if options[:name].blank?
+
+      Tablature.database.attach_to_list_partition(parent_table_name, options)
+    end
+
+    # Detaches a partition from a parent.
+    #
+    # @param parent_table_name [String, Symbol] The name of the parent table.
+    # @param [Hash] options The options to create the partition.
+    #
+    # @see Tablature::Adapters::Postgres#detach_from_list_partition
+    def detach_from_list_partition(parent_table_name, options)
+      raise ArgumentError, 'name must be defined' if options[:name].blank?
+      if options[:values].blank? && options[:default].blank?
+        raise ArgumentError, 'values or default must be defined'
+      end
+
+      Tablature.database.attach_to_list_partition(parent_table_name, options)
+    end
+
     # Creates a partitioned table using the range partition method.
     #
-    # @param name [String, Symbol] The name of the partition.
+    # @param table_name [String, Symbol] The name of the partition.
     # @param options [Hash] The options to create the partition.
     # @yield [td] A TableDefinition object. This allows creating the table columns the same way
     #   as Rails's +create_table+ does.
     #
     # @see Tablature::Adapters::Postgres#create_range_partition
-    def create_range_partition(name, options, &block)
+    def create_range_partition(table_name, options, &block)
       raise ArgumentError, 'partition_key must be defined' if options[:partition_key].nil?
 
-      Tablature.database.create_range_partition(name, options, &block)
+      Tablature.database.create_range_partition(table_name, options, &block)
     end
 
     # Creates a partition of a parent by specifying the key values appearing in the partition.
@@ -46,12 +75,39 @@ module Tablature
     # @param [Hash] options The options to create the partition.
     #
     # @see Tablature::Adapters::Postgres#create_range_partition_of
-    def create_range_partition_of(parent_table, options)
-      if options[:range_start].nil? || options[:range_end].nil?
-        raise ArgumentError, 'range_start and range_end must be defined'
+    def create_range_partition_of(parent_table_name, options)
+      if (options[:range_start].nil? || options[:range_end].nil?) && options[:default].blank?
+        raise ArgumentError, 'range_start and range_end or default must be defined'
       end
 
-      Tablature.database.create_range_partition_of(parent_table, options)
+      Tablature.database.create_range_partition_of(parent_table_name, options)
+    end
+
+    # Attaches a partition to a parent by specifying the key values appearing in the partition.
+    #
+    # @param parent_table_name [String, Symbol] The name of the parent table.
+    # @param [Hash] options The options to create the partition.
+    #
+    # @see Tablature::Adapters::Postgres#attach_to_range_partition
+    def attach_to_range_partition(parent_table_name, options)
+      raise ArgumentError, 'name must be defined' if options[:name].blank?
+      if (options[:range_start].nil? || options[:range_end].nil?) && options[:default].blank?
+        raise ArgumentError, 'range_start and range_end or default must be defined'
+      end
+
+      Tablature.database.attach_to_range_partition(parent_table_name, options)
+    end
+
+    # Detaches a partition from a parent.
+    #
+    # @param parent_table_name [String, Symbol] The name of the parent table.
+    # @param [Hash] options The options to detach the partition.
+    #
+    # @see Tablature::Adapters::Postgres#detach_from_range_partition
+    def detach_from_range_partition(parent_table_name, options)
+      raise ArgumentError, 'name must be defined' if options[:name].blank?
+
+      Tablature.database.detach_from_range_partition(parent_table_name, options)
     end
   end
 end

data/lib/tablature/version.rb

@@ -1,3 +1,3 @@
 module Tablature
-  VERSION = '0.3.1'.freeze
+  VERSION = '1.0.0.pre'.freeze
 end

data/lib/tablature.rb

@@ -2,6 +2,7 @@ require 'tablature/adapters/postgres'
 require 'tablature/command_recorder'
 require 'tablature/configuration'
 require 'tablature/model'
+require 'tablature/partition'
 require 'tablature/partitioned_table'
 require 'tablature/railtie'
 require 'tablature/schema_dumper'

data/tablature.gemspec

@@ -20,10 +20,12 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.required_ruby_version = '>= 2.5.0'
+
+  spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'database_cleaner'
-  spec.add_development_dependency 'pg', '~> 0.19'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'pg', '~> 1.1'
+  spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rspec-instafail'
 

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: tablature
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 1.0.0.pre
 platform: ruby
 authors:
 - Aliou Diallo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-18 00:00:00.000000000 Z
+date: 2020-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
@@ -44,28 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.19'
+        version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.19'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -129,13 +129,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".circleci/config.yml"
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".travis.yml"
+- ".yardopts"
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -152,6 +152,7 @@ files:
 - lib/tablature/command_recorder.rb
 - lib/tablature/configuration.rb
 - lib/tablature/model.rb
+- lib/tablature/partition.rb
 - lib/tablature/partitioned_table.rb
 - lib/tablature/railtie.rb
 - lib/tablature/schema_dumper.rb
@@ -170,15 +171,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Rails + Postgres Partitions

data/.circleci/config.yml

@@ -1,81 +0,0 @@
-# TODO: Simplify this
-version: 2
-jobs:
-  postgres_10:
-    working_directory: ~/tablature-rb
-    docker:
-      - image: circleci/ruby:2.4
-        environment:
-          DATABASE_URL: "postgres://postgres@localhost:5432/dummy_test"
-      - image: circleci/postgres:10-alpine
-        environment:
-          POSTGRES_USER: postgres
-          POSTGRES_DB: dummy_test
-          POSTGRES_PASSWORD: ""
-    steps:
-      - checkout
-
-      - type: cache-restore
-        name: Restore bundle cache
-        key: tablature-{{ checksum "tablature.gemspec" }}-{{ checksum "Gemfile" }}
-
-      - run:
-          name: Install dependencies
-          command: bundle install --path vendor/bundle
-
-      - type: cache-save
-        name: Store bundle cache
-        key: tablature-{{ checksum "tablature.gemspec" }}-{{ checksum "Gemfile" }}
-        paths:
-          - vendor/bundle
-
-      - run:
-          name: Wait for Postgres
-          command: dockerize -wait tcp://localhost:5432 -timeout 1m
-
-      - run:
-          name: Run tests
-          command: bundle exec rspec --tag ~postgres_11
-
-  postgres_11:
-    working_directory: ~/tablature-rb
-    docker:
-      - image: circleci/ruby:2.4
-        environment:
-          DATABASE_URL: "postgres://postgres@localhost:5432/dummy_test"
-      - image: circleci/postgres:11-alpine
-        environment:
-          POSTGRES_USER: postgres
-          POSTGRES_DB: dummy_test
-          POSTGRES_PASSWORD: ""
-    steps:
-      - checkout
-
-      - type: cache-restore
-        name: Restore bundle cache
-        key: tablature-{{ checksum "tablature.gemspec" }}-{{ checksum "Gemfile" }}
-
-      - run:
-          name: Install dependencies
-          command: bundle install --path vendor/bundle
-
-      - type: cache-save
-        name: Store bundle cache
-        key: tablature-{{ checksum "tablature.gemspec" }}-{{ checksum "Gemfile" }}
-        paths:
-          - vendor/bundle
-
-      - run:
-          name: Wait for Postgres
-          command: dockerize -wait tcp://localhost:5432 -timeout 1m
-
-      - run:
-          name: Run tests
-          command: bundle exec rspec
-
-workflows:
-  version: 2
-  tablature:
-    jobs:
-      - postgres_10
-      - postgres_11

data/Gemfile.lock

@@ -1,106 +0,0 @@
-PATH
-  remote: .
-  specs:
-    tablature (0.3.1)
-      activerecord (>= 5.0.0)
-      railties (>= 5.0.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    actionpack (5.2.2)
-      actionview (= 5.2.2)
-      activesupport (= 5.2.2)
-      rack (~> 2.0)
-      rack-test (>= 0.6.3)
-      rails-dom-testing (~> 2.0)
-      rails-html-sanitizer (~> 1.0, >= 1.0.2)
-    actionview (5.2.2)
-      activesupport (= 5.2.2)
-      builder (~> 3.1)
-      erubi (~> 1.4)
-      rails-dom-testing (~> 2.0)
-      rails-html-sanitizer (~> 1.0, >= 1.0.3)
-    activemodel (5.2.2)
-      activesupport (= 5.2.2)
-    activerecord (5.2.2)
-      activemodel (= 5.2.2)
-      activesupport (= 5.2.2)
-      arel (>= 9.0)
-    activesupport (5.2.2)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-    arel (9.0.0)
-    builder (3.2.3)
-    coderay (1.1.2)
-    concurrent-ruby (1.1.4)
-    crass (1.0.4)
-    database_cleaner (1.7.0)
-    diff-lcs (1.3)
-    erubi (1.8.0)
-    i18n (1.5.1)
-      concurrent-ruby (~> 1.0)
-    loofah (2.2.3)
-      crass (~> 1.0.2)
-      nokogiri (>= 1.5.9)
-    method_source (0.9.0)
-    mini_portile2 (2.4.0)
-    minitest (5.11.3)
-    nokogiri (1.10.1)
-      mini_portile2 (~> 2.4.0)
-    pg (0.21.0)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    rack (2.0.6)
-    rack-test (1.1.0)
-      rack (>= 1.0, < 3)
-    rails-dom-testing (2.0.3)
-      activesupport (>= 4.2.0)
-      nokogiri (>= 1.6)
-    rails-html-sanitizer (1.0.4)
-      loofah (~> 2.2, >= 2.2.2)
-    railties (5.2.2)
-      actionpack (= 5.2.2)
-      activesupport (= 5.2.2)
-      method_source
-      rake (>= 0.8.7)
-      thor (>= 0.19.0, < 2.0)
-    rake (10.5.0)
-    rspec (3.7.0)
-      rspec-core (~> 3.7.0)
-      rspec-expectations (~> 3.7.0)
-      rspec-mocks (~> 3.7.0)
-    rspec-core (3.7.1)
-      rspec-support (~> 3.7.0)
-    rspec-expectations (3.7.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-instafail (1.0.0)
-      rspec
-    rspec-mocks (3.7.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-support (3.7.1)
-    thor (0.20.3)
-    thread_safe (0.3.6)
-    tzinfo (1.2.5)
-      thread_safe (~> 0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler (~> 1.16)
-  database_cleaner
-  pg (~> 0.19)
-  pry
-  rake (~> 10.0)
-  rspec (~> 3.0)
-  rspec-instafail
-  tablature!
-
-BUNDLED WITH
-   1.17.2