tablature 0.1.1 → 1.0.0.pre2

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,29 +5,73 @@ 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 :partioning_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 partioning_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.
-    def initialize(name:, partioning_method:, partitions: [])
+    # @param partition_key [String] The partition key expression.
+    # @api private
+    def initialize(name:, partitioning_strategy:, partitions: [], partition_key:)
       @name = name
-      @partioning_method = partioning_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
+
+    PARTITION_METHOD_MAP = {
+      list: 'create_list_partition',
+      range: 'create_range_partition'
+    }.freeze
+    private_constant :PARTITION_METHOD_MAP
+
+    def to_schema
+      return nil unless PARTITION_METHOD_MAP.key?(partitioning_strategy)
+
+      creation_method = PARTITION_METHOD_MAP[partitioning_strategy]
+      <<-CONTENT
+        #{creation_method} #{name.inspect}, partition_key: #{partition_key.inspect} do |t|
+      CONTENT
+    end
+
+    def <=>(other)
+      name <=> other.name
     end
   end
 end

data/lib/tablature/schema_dumper.rb

@@ -1,22 +1,85 @@
+# TODO: Try to replace the creation methods in the main stream instead of dumping the partitioned
+# tables at the end of the schema.
 module Tablature
   # @api private
   module SchemaDumper
     def tables(stream)
       # Add partitions to the list of ignored tables.
       ActiveRecord::SchemaDumper.ignore_tables =
-        (ActiveRecord::SchemaDumper.ignore_tables || []) + partitions
+        (ActiveRecord::SchemaDumper.ignore_tables || []) +
+        dumpable_partitioned_tables.map(&:name) +
+        partitions
 
       super
+
+      partitioned_tables(stream)
+    end
+
+    def partitioned_tables(stream)
+      stream.puts if dumpable_partitioned_tables.any?
+
+      dumpable_partitioned_tables.each do |partitioned_table|
+        dump_partitioned_table(partitioned_table, stream)
+        dump_partition_indexes(partitioned_table, stream)
+        dump_foreign_keys(partitioned_table, stream)
+      end
     end
 
     private
 
+    attr_reader :connection
+    delegate :quote_table_name, :quote, to: :connection
+
+    PARTITION_METHOD_MAP = {
+      list: 'create_list_partition',
+      range: 'create_range_partition'
+    }.freeze
+    private_constant :PARTITION_METHOD_MAP
+
+    def dump_partitioned_table(partitioned_table, main_stream)
+      # Pretend the partitioned table is a regular table and dump it in an alternate stream.
+      stream = StringIO.new
+      table(partitioned_table.name, stream)
+
+      header = partitioned_table.to_schema
+      if header.nil?
+        main_stream.puts <<~MESSAGE
+          # Unknown partitioning strategy "#{partitioned_table.partitioning_strategy}" for partitioned table "#{partitioned_table.name}".
+          # Dumping table as a regular table.
+        MESSAGE
+        main_stream.puts(stream.tap(&:rewind).read)
+      else
+        content = stream.tap(&:rewind).read.gsub(/create_table.*/, header)
+        main_stream.puts(content)
+      end
+    end
+
+    # Delegate to the adapter the dumping of indexes.
+    def dump_partition_indexes(partitioned_table, stream)
+      return unless Tablature.database.respond_to?(:indexes_on)
+
+      indexes = Tablature.database.indexes_on(partitioned_table.name)
+      return if indexes.empty?
+
+      add_index_statements = indexes.map do |index|
+        table_name = remove_prefix_and_suffix(index.table).inspect
+        "  add_index #{([table_name] + index_parts(index)).join(', ')}"
+      end
+
+      stream.puts add_index_statements.sort.join("\n")
+      stream.puts
+    end
+
+    def dump_foreign_keys(partitioned_table, stream)
+      foreign_keys(partitioned_table.name, stream)
+    end
+
     def dumpable_partitioned_tables
-      Tablature.database.partitioned_tables
+      Tablature.database.partitioned_tables.sort
     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.1.1'.freeze
+  VERSION = '1.0.0.pre2'.freeze
 end

data/tablature.gemspec

@@ -14,16 +14,18 @@ Gem::Specification.new do |spec|
   spec.license       = 'MIT'
 
   spec.files = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
+    f.match(%r{^(bin|test|spec|features)/})
   end
   spec.bindir        = 'exe'
   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.1.1
+  version: 1.0.0.pre2
 platform: ruby
 authors:
 - Aliou Diallo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-05 00:00:00.000000000 Z
+date: 2020-06-06 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,18 +129,16 @@ 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
-- bin/console
-- bin/setup
 - lib/tablature.rb
 - lib/tablature/adapters/postgres.rb
 - lib/tablature/adapters/postgres/connection.rb
@@ -148,12 +146,14 @@ files:
 - lib/tablature/adapters/postgres/handlers/base.rb
 - lib/tablature/adapters/postgres/handlers/list.rb
 - lib/tablature/adapters/postgres/handlers/range.rb
+- lib/tablature/adapters/postgres/indexes.rb
 - lib/tablature/adapters/postgres/partitioned_tables.rb
 - lib/tablature/adapters/postgres/quoting.rb
 - lib/tablature/adapters/postgres/uuid.rb
 - 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
@@ -172,15 +172,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