tablature 0.1.1 → 1.0.0.pre2

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/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,13 +19,17 @@ 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,
               c.relname AS table_name,
-              p.partstrat AS type,
-              (i.inhrelid::REGCLASS)::TEXT AS partition_name
+              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
               LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -36,22 +40,30 @@ module Tablature
               AND n.nspname = ANY (current_schemas(false))
             ORDER BY c.oid
           SQL
+
+          result.to_a
         end
+        # rubocop:enable Metrics/MethodLength
 
-        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
-          partioning_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
+          # 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, partioning_method: partioning_method, partitions: partitions
+            name: table_name, partitioning_strategy: partitioning_strategy,
+            partitions: rows, partition_key: partition_key
           )
         end
 

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

@@ -4,6 +4,11 @@ module Tablature
       # @api private
       module Quoting
         def quote_partition_key(key)
+          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
 

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

@@ -1,4 +1,74 @@
+require 'forwardable'
+
 module Tablature
   module Model
+    module ListPartitionMethods
+      def create_list_partition(options)
+        Tablature.database.create_list_partition_of(tablature_partition.name, options)
+      end
+    end
+
+    module RangePartitionMethods
+      def create_range_partition(options)
+        Tablature.database.create_range_partition_of(tablature_partition.name, options)
+      end
+    end
+
+    module ClassMethods
+      extend Forwardable
+
+      def_delegators :tablature_partition, :partitions, :partition_key, :partitioning_strategy
+
+      def partitioned?
+        begin
+          tablature_partition
+        rescue Tablature::MissingPartition
+          return false
+        end
+
+        true
+      end
+
+      def tablature_partition
+        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 @tablature_partition.nil?
+
+        @tablature_partition
+      end
+
+      def list_partition(partition_name = table_name)
+        setup_partition(partition_name)
+        extend(ListPartitionMethods)
+      end
+
+      def range_partition(partition_name = table_name)
+        setup_partition(partition_name)
+        extend(RangePartitionMethods)
+      end
+
+      # @api private
+      def inspect
+        return super unless partitioned?
+
+        # Copied from the Rails source.
+        attr_list = attribute_types.map { |name, type| "#{name}: #{type.type}" } * ', '
+        "#{self}(#{attr_list})"
+      end
+
+      private
+
+      def setup_partition(partition_name)
+        self.partition_name = partition_name
+      end
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+      klass.class_attribute(:partition_name)
+    end
   end
 end