tablature 1.0.0.pre → 1.0.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8db9f3d3c82e1667d5931739f53bdc0c218f01281c56e3e1cd2541b51264ae4f
-  data.tar.gz: 45fa5efd4a15199e22d5d15b8d0f84114de3ed634121171bb561ff206c5bcc28
+  metadata.gz: a72b6d120e1af25bf4b044347d02c552898ede4de5082a01f8b4ec3e24f4f6b0
+  data.tar.gz: e011684eadd4c9f39b83db417c6ef282f5291ed947c23651e8e5c70fcb76aa53
 SHA512:
-  metadata.gz: d30f66c7398da2249edc10d3b4a5d2239aa017647f78c266fb07708abc943ee9d79f950d57e93a508c1d4211a408de17d7f97c96b092e9237a8962abdcfba58d
-  data.tar.gz: db95e1b650a5337be05a61986ae99ed4adb829d9dd2d98642b34907bdd71416da8dbfe1f8ec66bdc9caa2ec0e0b178b433ec39afa625928afe6d1708c4912558
+  metadata.gz: 9b49e89742a179e6f50ccf28789bdb66999f5edb56a4cdcf57c273abc055b5bdc9bb6cbbb754639831613d0b90c034d9ee16c07ea6f56e14ca276a819081296f
+  data.tar.gz: 540d21c49ac1f7e74da0abb9c697cfbc94c72452408acfb891edaf377a5b199bda57ae670dfd051cf266e8c4da86ea51e699a5e4bc25b6e3f0cfc9ade27f378c

data/Gemfile

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

data/lib/tablature/adapters/postgres.rb

@@ -4,6 +4,7 @@ require_relative 'postgres/connection'
 require_relative 'postgres/errors'
 require_relative 'postgres/handlers/list'
 require_relative 'postgres/handlers/range'
+require_relative 'postgres/indexes'
 require_relative 'postgres/partitioned_tables'
 
 module Tablature
@@ -185,6 +186,17 @@ module Tablature
         PartitionedTables.new(connection).all
       end
 
+      # Indexes on the Partitioned Table.
+      #
+      # @param name [String] The name of the partitioned table we want indexes from.
+      # @return [Array<ActiveRecord::ConnectionAdapters::IndexDefinition>]
+      def indexes_on(partitioned_table)
+        return [] if Gem::Version.new(Rails.version) >= Gem::Version.new('6.0.3')
+        return [] unless connection.supports_indexes_on_partitioned_tables?
+
+        Indexes.new(connection).on(partitioned_table)
+      end
+
       private
 
       attr_reader :connectable

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

@@ -38,6 +38,13 @@ module Tablature
           postgresql_version >= 110_000
         end
 
+        # True if the connection supports indexes on partitioned tables.
+        #
+        # @return [Boolean]
+        def supports_indexes_on_partitioned_tables?
+          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/indexes.rb

@@ -0,0 +1,96 @@
+module Tablature
+  module Adapters
+    class Postgres
+      # Fetches indexes on objects from the Postgres connection.
+      #
+      # @api private
+      class Indexes
+        def initialize(connection)
+          @connection = connection
+        end
+
+        def on(name)
+          indexes_on(name).map(&method(:index_from_database))
+        end
+
+        private
+
+        attr_reader :connection
+
+        def indexes_on(name)
+          connection.exec_query(<<-SQL, 'SCHEMA').to_a
+            SELECT DISTINCT
+              i.relname AS index_name,
+              d.indisunique AS is_unique,
+              d.indkey AS index_keys,
+              pg_get_indexdef(d.indexrelid) AS definition,
+              t.oid AS oid,
+              pg_catalog.obj_description(i.oid, 'pg_class') AS comment,
+              t.relname AS table_name,
+              string_agg(a.attname, ',') OVER (PARTITION BY i.relname) AS column_names
+            FROM pg_class t
+            INNER JOIN pg_index d ON t.oid = d.indrelid
+            INNER JOIN pg_class i ON d.indexrelid = i.oid
+            LEFT JOIN pg_namespace n ON n.oid = i.relnamespace
+            LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY (d.indkey)
+            WHERE i.relkind = 'I'
+              AND d.indisprimary = 'f'
+              AND t.relname = '#{name}'
+              AND n.nspname = ANY (current_schemas(false))
+            ORDER BY i.relname
+          SQL
+        end
+
+        def index_from_database(result)
+          result = format_result(result)
+
+          if rails_version >= Gem::Version.new('5.2')
+            ActiveRecord::ConnectionAdapters::IndexDefinition.new(
+              result['table_name'], result['index_name'], result['is_unique'], result['columns'],
+              lengths: {}, orders: result['orders'], opclasses: result['opclasses'],
+              where: result['where'], using: result['using'].to_sym,
+              comment: result['comment'].presence
+            )
+          elsif rails_version >= Gem::Version.new('5.0')
+            ActiveRecord::ConnectionAdapters::IndexDefinition.new(
+              result['table_name'], result['index_name'], result['is_unique'], result['columns'],
+              {}, result['orders'], result['where'], nil, result['using'].to_sym,
+              result['comment'].presence
+            )
+          end
+        end
+
+        INDEX_PATTERN = /(?<column>\w+)"?\s?(?<opclass>\w+_ops)?\s?(?<desc>DESC)?\s?(?<nulls>NULLS (?:FIRST|LAST))?/.freeze
+        private_constant :INDEX_PATTERN
+
+        USING_PATTERN = / USING (\w+?) \((.+?)\)(?: WHERE (.+))?\z/m.freeze
+        private_constant :USING_PATTERN
+
+        def format_result(result)
+          result['index_keys'] = result['index_keys'].split.map(&:to_i)
+          result['column_names'] = result['column_names'].split(',')
+          result['using'], expressions, result['where'] = result['definition'].scan(USING_PATTERN).flatten
+          result['columns'] = result['index_keys'].include?(0) ? expressions : result['column_names']
+
+          result['orders'] = {}
+          result['opclasses'] = {}
+
+          expressions.scan(INDEX_PATTERN).each do |column, opclass, desc, nulls|
+            result['opclasses'][column] = opclass.to_sym if opclass
+            if nulls
+              result['orders'][column] = [desc, nulls].compact.join(' ')
+            elsif desc
+              result['orders'][column] = :desc
+            end
+          end
+
+          result
+        end
+
+        def rails_version
+          @rails_version ||= Gem::Version.new(Rails.version)
+        end
+      end
+    end
+  end
+end

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

@@ -19,8 +19,9 @@ module Tablature
 
         attr_reader :connection
 
+        # rubocop:disable Metrics/MethodLength
         def partitions
-          connection.execute(<<-SQL)
+          result = connection.exec_query(<<-SQL, 'SCHEMA')
             SELECT
               c.oid,
               i.inhrelid,
@@ -39,7 +40,10 @@ module Tablature
               AND n.nspname = ANY (current_schemas(false))
             ORDER BY c.oid
           SQL
+
+          result.to_a
         end
+        # rubocop:enable Metrics/MethodLength
 
         STRATEGY_MAP = {
           'l' => :list,

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

@@ -4,11 +4,12 @@ module Tablature
       # @api private
       module Quoting
         def quote_partition_key(key)
-          if key.respond_to?(:call)
-            key.call.to_s
-          else
-            key.to_s.split('::').map(&method(:quote_column_name)).join('::')
-          end
+          return key.call.to_s if key.respond_to?(:call)
+          # Don't bother quoting the key if it is already quoted (when loading the schema for
+          # example).
+          return key if key.to_s.include?("'") || key.to_s.include?('"')
+
+          key.to_s.split('::').map(&method(:quote_column_name)).join('::')
         end
 
         def quote_collection(values)

data/lib/tablature/model.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 module Tablature
   module Model
     module ListPartitionMethods

data/lib/tablature/partitioned_table.rb

@@ -54,5 +54,24 @@ module Tablature
     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,18 +1,81 @@
+# 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

data/lib/tablature/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tablature
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre
+  version: 1.0.0.pre2
 platform: ruby
 authors:
 - Aliou Diallo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-10 00:00:00.000000000 Z
+date: 2020-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -146,6 +146,7 @@ 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