pg_trunk 0.1.0

data/lib/pg_trunk/operations/check_constraints/drop_check_constraint.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#drop_check_constraint(table, expression = nil, **options, &block)
+# Remove a check constraint from the table
+#
+# @param [#to_s] table (nil) The qualified name of the table
+# @param [#to_s] expression (nil) The SQL expression
+# @option [Boolean] :if_exists (false) Suppress the error when the constraint is absent
+# @option [#to_s] :name (nil) The optional name of the constraint
+# @option [Boolean] :inherit (true) If the constraint should be inherited by subtables
+# @option [#to_s] :comment (nil) The comment describing the constraint
+# @yield [Proc] the block with the constraint's definition
+# @yieldparam The receiver of methods specifying the constraint
+#
+# Definition for the `drop_check_constraint` operation
+#
+# The constraint can be identified by the table and explicit name
+#
+#   drop_check_constraint :users, name: "phone_is_long_enough"
+#
+# Alternatively the name can be got from the expression.
+# Be careful! the expression must have exactly the same form
+# as stored in the database:
+#
+#   drop_check_constraint :users, "length((phone::text) > 10)"
+#
+# To made operation reversible the expression must be provided:
+#
+#   drop_check_constraint "users" do |c|
+#     c.expression "length((phone::text) > 10)"
+#     c.inherit false
+#     c.comment "The phone is 10+ chars long"
+#   end
+#
+# The operation can be called with `if_exists` option.
+#
+#   drop_check_constraint :users,
+#                         name: "phone_is_long_enough",
+#                         if_exists: true
+#
+# In this case the operation is always irreversible due to
+# uncertainty of the previous state of the database.
+
+module PGTrunk::Operations::CheckConstraints
+  # @private
+  class DropCheckConstraint < Base
+    validates :new_name, absence: true
+
+    def to_sql(_version)
+      sql = "ALTER TABLE #{table.to_sql} DROP CONSTRAINT"
+      sql << " IF EXISTS" if if_exists
+      sql << " #{name.name.inspect};"
+    end
+
+    def invert
+      irreversible!("if_exists: true") if if_exists
+      AddCheckConstraint.new(**to_h)
+    end
+  end
+end

data/lib/pg_trunk/operations/check_constraints/rename_check_constraint.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#rename_check_constraint(table, expression = nil, **options, &block)
+# Rename a check constraint
+#
+# @param [#to_s] table (nil) The qualified name of the table
+# @param [#to_s] expression (nil) The SQL expression
+# @option [#to_s] :name (nil) The current name of the constraint
+# @option [#to_s] :to (nil) The new name for the constraint
+# @yield [Proc] the block with the constraint's definition
+# @yieldparam The receiver of methods specifying the constraint
+#
+# A constraint can be identified by the table and explicit name
+#
+#   rename_check_constraint :users,
+#                           name: "phone_is_long_enough",
+#                           to: "phones.long_enough"
+#
+# Alternatively the name can be got from the expression.
+# Be careful! the expression must have exactly the same form
+# as stored in the database:
+#
+#   rename_check_constraint :users, "length((phone::text) > 10)",
+#                           to: "long_enough"
+#
+# The name can be reset to auto-generated when
+# the `:to` option is missed or blank:
+#
+#   rename_check_constraint :users, "phone_is_long_enough"
+#
+# The operation is always reversible.
+
+module PGTrunk::Operations::CheckConstraints
+  # @private
+  class RenameCheckConstraint < Base
+    # Reset the name to default when `to:` option is missed or set to `nil`
+    after_initialize { self.new_name = generated_name if new_name.blank? }
+
+    validates :new_name, presence: true
+    validates :if_exists, :force, :comment, absence: true
+
+    def to_sql(_version)
+      <<~SQL.squish
+        ALTER TABLE #{table.to_sql}
+        RENAME CONSTRAINT #{name.name.inspect}
+        TO #{new_name.name.inspect};
+      SQL
+    end
+
+    def invert
+      self.class.new(**to_h, name: new_name, to: name)
+    end
+  end
+end

data/lib/pg_trunk/operations/check_constraints/validate_check_constraint.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#validate_check_constraint(table, expression = nil, **options, &block)
+# Validate an invalid check constraint
+#
+# @param [#to_s] table (nil) The qualified name of the table
+# @param [#to_s] expression (nil) The SQL expression
+# @option [#to_s] :name (nil) The optional name of the constraint
+# @yield [Proc] the block with the constraint's definition
+# @yieldparam The receiver of methods specifying the constraint
+#
+# The invalid constraint can be identified by table and explicit name:
+#
+#   validate_check_constraint :users, name: "phone_is_long_enough"
+#
+# Alternatively it can be specified by expression. In this case
+# you must ensure the expression has the same form as it is stored
+# in the database (after parsing the source).
+#
+#   validate_check_constraint :users, "length((phone::text) > 10)"
+#
+# Notice that it is invertible but the inverted operation does nothing.
+
+module PGTrunk::Operations::CheckConstraints
+  # @private
+  class ValidateCheckConstraint < Base
+    validates :if_exists, :force, :new_name, :comment, :new_name, :inherit,
+              absence: true
+
+    def to_sql(_version)
+      <<~SQL.squish
+        ALTER TABLE #{table.to_sql} VALIDATE CONSTRAINT #{name.name.inspect};
+      SQL
+    end
+
+    # The operation is invertible but the inversion does nothing
+    def invert; end
+  end
+end

data/lib/pg_trunk/operations/check_constraints.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# nodoc
+module PGTrunk::Operations
+  # @private
+  # Definitions for check constraints
+  module CheckConstraints
+    require_relative "check_constraints/base"
+    require_relative "check_constraints/add_check_constraint"
+    require_relative "check_constraints/drop_check_constraint"
+    require_relative "check_constraints/rename_check_constraint"
+    require_relative "check_constraints/validate_check_constraint"
+  end
+end

data/lib/pg_trunk/operations/composite_types/base.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: false
+
+module PGTrunk::Operations::CompositeTypes
+  # @abstract
+  # @private
+  # Base class for operations with composite types
+  class Base < PGTrunk::Operation
+    # All columns that can be used by type-related commands
+    attribute :columns, :pg_trunk_array_of_hashes, default: []
+
+    # Populate columns from a block
+    def column(name, type, collation: nil)
+      columns << Column.new(name: name, type: type, collation: collation)
+    end
+
+    # Wrap column definitions to value objects
+    after_initialize { columns.map! { |a| Column.build(a) } }
+
+    validates :if_not_exists, absence: true
+    validates :name, presence: true
+    validates :columns, "PGTrunk/all_items_valid": true, allow_nil: true
+
+    # Use comparison by name from pg_trunk operations base class (default)
+    # Support name as the only positional argument (default)
+
+    ruby_snippet do |s|
+      s.ruby_param(name.lean) if name.present?
+      s.ruby_param(to: new_name.lean) if new_name.present?
+      s.ruby_param(if_exists: true) if if_exists
+      s.ruby_param(force: :cascade) if force == :cascade
+
+      columns.reject(&:change).each do |c|
+        s.ruby_line(
+          :column, c.name, c.type&.lean, collation: c.collation&.lean,
+        )
+      end
+      columns.select { |c| c.change == :add }.each do |c|
+        s.ruby_line(
+          :add_column, c.name, c.type&.lean, collation: c.collation&.lean,
+        )
+      end
+      columns.select { |c| c.change == :rename }.each do |c|
+        s.ruby_line(:rename_column, c.name, to: c.new_name)
+      end
+      columns.select { |c| c.change == :alter }.each do |c|
+        s.ruby_line(
+          :change_column, c.name, c.type&.lean,
+          collation: c.collation&.lean,
+          from_type: c.from_type&.lean,
+          from_collation: c.from_collation&.lean,
+        )
+      end
+      columns.select { |c| c.change == :drop }.each do |c|
+        s.ruby_line(
+          :drop_column, c.name, *c.type&.lean, collation: c.collation&.lean,
+        )
+      end
+      s.ruby_line(:comment, comment, from: from_comment) if comment
+    end
+  end
+end

data/lib/pg_trunk/operations/composite_types/change_composite_type.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#change_composite_type(name, **options, &block)
+# Modify a composite type
+#
+# @param [#to_s] name (nil) The qualified name of the type
+# @option [Symbol] :force (:restrict) How to process dependent objects (`:cascade` or `:restrict`)
+# @option [#to_s] :comment (nil) The comment describing the constraint
+# @yield [Proc] the block with the type's definition
+# @yieldparam The receiver of methods specifying the type
+#
+# The operation can be used to add, drop, rename or change columns.
+# The comment can be changed as well.
+#
+# Providing a type "paint.colored_point":
+#
+#   create_composite_type "paint.colored_point" do |t|
+#     t.column "color", "text", collation: "en_US"
+#     t.column "x", "integer"
+#     t.column "z", "integer"
+#   end
+#
+# After the following change:
+#
+#   change_composite_type "paint.colored_point" do |t|
+#     t.change_column "color", "text", collation: "ru_RU", from_collation: "en_US"
+#     t.change_column "x", "bigint", from_type: "integer"
+#     t.drop_column "z", "integer"
+#     t.add_column "Y", "bigint"
+#     t.rename_column "x", to: "X"
+#     t.comment "2D point with a color", from: "2D point"
+#   end
+#
+# The definition became:
+#
+#   create_composite_type "paint.colored_point" do |t|
+#     t.column "color", "text", collation: "ru_RU"
+#     t.column "X", "bigint"
+#     t.column "Y", "integer"
+#   end
+#
+# Notice, that all renames will be done AFTER other changes,
+# so in `change_column` you should use the old names.
+#
+# In several cases the operation is not invertible:
+#
+# - when a column was dropped
+# - when `force: :cascade` option is used (to update
+#   objects that use the type)
+# - when `if_exists: true` is added to the `drop_column` clause
+# - when a previous state of the column type, collation or comment
+#   is not specified.
+
+module PGTrunk::Operations::CompositeTypes
+  # @private
+  class ChangeCompositeType < Base
+    # Methods to populate `columns` from the block
+    def add_column(name, type, collation: nil)
+      columns << Column.new(
+        name: name, type: type, collation: collation, change: :add, force: force,
+      )
+    end
+
+    def drop_column(name, type = nil, **opts)
+      opts = opts.slice(:if_exists, :collation)
+      columns << Column.new(
+        name: name, type: type, force: force, **opts, change: :drop,
+      )
+    end
+
+    def change_column(name, type, **opts)
+      opts = opts.slice(:collation, :from_type, :from_collation)
+      columns << Column.new(
+        name: name, type: type, force: force, change: :alter, **opts,
+      )
+    end
+
+    def rename_column(name, to:)
+      columns << Column.new(
+        name: name, new_name: to, force: force, change: :rename,
+      )
+    end
+
+    validates :if_exists, :new_name, absence: true
+    validate { errors.add :base, "There are no changes" if change.blank? }
+
+    def to_sql(_version)
+      [*change_columns, *rename_columns, *change_comment].join(" ")
+    end
+
+    def invert
+      keys = inversion.select { |_, v| v.nil? }.keys.join(", ").presence
+      errors = columns.map(&:inversion_error).compact
+      errors << "Can't invert #{keys}" if keys.present?
+      errors << "Can't invert dropped columns" if columns.any? { |c| c.change == :drop }
+      raise IrreversibleMigration.new(self, nil, *errors) if errors.any?
+
+      self.class.new(**to_h, **inversion)
+    end
+
+    private
+
+    def change_columns
+      list = columns.select { |c| c.change&.!= :rename }
+      return if list.blank?
+
+      "ALTER TYPE #{name.to_sql} #{list.map(&:to_sql).join(', ')};"
+    end
+
+    def rename_columns
+      columns.select { |c| c.change == :rename }.map do |c|
+        "ALTER TYPE #{name.to_sql} #{c.to_sql};"
+      end
+    end
+
+    def change_comment
+      <<~SQL.squish if comment
+        COMMENT ON TYPE #{name.to_sql} IS $comment$#{comment}$comment$;
+      SQL
+    end
+
+    def change
+      @change ||= {
+        comment: comment,
+        columns: columns.select(&:change).map(&:to_h).presence,
+      }.compact
+    end
+
+    def inversion
+      @inversion ||= {
+        comment: from_comment,
+        columns: columns.reverse.map(&:invert).presence,
+      }.slice(*change.keys)
+    end
+  end
+end

data/lib/pg_trunk/operations/composite_types/column.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: false
+
+module PGTrunk::Operations::CompositeTypes
+  # @private
+  # Definition for an column of a composite type
+  class Column
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::Validations
+
+    def self.build(data)
+      data.is_a?(self) ? data : new(**data)
+    end
+
+    attribute :change, :pg_trunk_symbol
+    attribute :collation, :pg_trunk_qualified_name
+    attribute :force, :pg_trunk_symbol
+    attribute :from_collation, :pg_trunk_qualified_name
+    attribute :from_type, :pg_trunk_qualified_name
+    attribute :if_exists, :boolean
+    attribute :name, :string
+    attribute :new_name, :string
+    attribute :type, :pg_trunk_qualified_name
+
+    validates :name, presence: true
+    validates :new_name, "PGTrunk/difference": { from: :name }, allow_nil: true
+    validates :change, inclusion: { in: %i[add alter drop rename] }, allow_nil: true
+    validates :force, inclusion: { in: %i[force restrict] }, allow_nil: true
+
+    def to_h
+      @to_h ||= attributes.compact.symbolize_keys
+    end
+
+    INVERTED = {
+      add: :drop, drop: :add, rename: :rename, alter: :alter,
+    }.freeze
+
+    def invert
+      @invert ||= {}.tap do |i|
+        i[:change] = INVERTED[change]
+        i[:name] = new_name.presence || name
+        i[:new_name] = name if new_name.present?
+        i[:type] = change == :add ? type : from_type
+        i[:collation] = change == :add ? collation : from_collation
+      end
+    end
+
+    def to_sql
+      case change
+      when :add    then add_sql
+      when :alter  then alter_sql
+      when :drop   then drop_sql
+      when :rename then rename_sql
+      else sql
+      end
+    end
+
+    def inversion_error
+      return <<~MSG.squish if if_exists
+        with `if_exists: true` option cannot be inverted
+        due to uncertainty of the previous state of the database.
+      MSG
+
+      return <<~MSG.squish if force == :cascade
+        with `force: :cascade` option cannot be inverted
+        due to uncertainty of the previous state of the database.
+      MSG
+
+      return <<~MSG.squish if change == :drop && type.blank?
+        undefined type of the dropped column #{name}
+      MSG
+
+      return <<~MSG.squish if change == :alter && type && !from_type
+        undefined a previous state of the type for column #{name}
+      MSG
+
+      return <<~MSG.squish if change == :alter && collation && !from_collation
+        undefined a previous state of the collation for column #{name}
+      MSG
+    end
+
+    private
+
+    def rename_sql
+      "RENAME ATTRIBUTE #{name.inspect} TO #{new_name.inspect}".tap do |sql|
+        sql << " CASCADE" if force == :cascade
+      end
+    end
+
+    def drop_sql
+      "DROP ATTRIBUTE".tap do |sql|
+        sql << " IF EXISTS" if if_exists
+        sql << " #{name.inspect}"
+        sql << " CASCADE" if force == :cascade
+      end
+    end
+
+    def add_sql
+      "ADD ATTRIBUTE #{name.inspect} #{type.lean}".tap do |sql|
+        sql << " COLLATE #{collation.to_sql}" if collation.present?
+        sql << " CASCADE" if force == :cascade
+      end
+    end
+
+    def alter_sql
+      "ALTER ATTRIBUTE #{name.inspect} SET DATA TYPE #{type.lean}".tap do |sql|
+        sql << " COLLATE #{collation.to_sql}" if collation.present?
+        sql << " CASCADE" if force == :cascade
+      end
+    end
+
+    def sql
+      "#{name.inspect} #{type.lean}".tap do |sql|
+        sql << " COLLATE #{collation.to_sql}" if collation
+      end
+    end
+  end
+end

data/lib/pg_trunk/operations/composite_types/create_composite_type.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#create_composite_type(name, **options, &block)
+# Create a composite type
+#
+# @param [#to_s] name (nil) The qualified name of the type
+# @option [#to_s] :comment (nil) The comment describing the constraint
+# @yield [Proc] the block with the type's definition
+# @yieldparam The receiver of methods specifying the type
+#
+# @example
+#   create_composite_type "paint.colored_point" do |d|
+#     d.column "x", "integer"
+#     d.column "y", "integer"
+#     d.column "color", "text", collation: "en_US"
+#     d.comment <<~COMMENT
+#       2D point with color
+#     COMMENT
+#   end
+#
+# It is always reversible.
+
+module PGTrunk::Operations::CompositeTypes
+  # @private
+  class CreateCompositeType < Base
+    validates :force, :if_exists, :new_name, absence: true
+
+    from_sql do |_version|
+      <<~SQL
+        SELECT
+          t.oid,
+          (t.typnamespace::regnamespace || '.' || t.typname) AS name,
+          (
+            SELECT
+              json_agg(
+                json_build_object(
+                  'name', a.attname,
+                  'type', format_type(a.atttypid, a.atttypmod),
+                  'collation', (
+                    CASE
+                    WHEN c.collnamespace != 'pg_catalog'::regnamespace
+                      THEN c.collnamespace::regnamespace || '.' || c.collname
+                    WHEN c.collname != 'default'
+                      THEN c.collname
+                    END
+                  )
+                ) ORDER BY a.attnum
+              )
+            FROM pg_attribute a
+              LEFT JOIN pg_collation c ON c.oid = a.attcollation
+            WHERE a.attrelid = t.typrelid
+              AND EXISTS (SELECT FROM pg_type WHERE a.atttypid = pg_type.oid)
+          ) AS columns,
+          d.description AS comment
+        FROM pg_type t
+          JOIN pg_trunk e ON e.oid = t.oid
+            AND e.classid = 'pg_type'::regclass
+          LEFT JOIN pg_description d ON d.objoid = t.oid
+            AND d.classoid = 'pg_type'::regclass
+        WHERE t.typtype = 'c';
+      SQL
+    end
+
+    def to_sql(_version)
+      [create_type, *create_comment, register_type].join(" ")
+    end
+
+    def invert
+      DropCompositeType.new(**to_h)
+    end
+
+    private
+
+    def create_type
+      <<~SQL.squish
+        CREATE TYPE #{name.to_sql}
+        AS (#{columns.reject(&:change).map(&:to_sql).join(',')});
+      SQL
+    end
+
+    def create_comment
+      return if comment.blank?
+
+      "COMMENT ON TYPE #{name.to_sql} IS $comment$#{comment}$comment$;"
+    end
+
+    def register_type
+      <<~SQL.squish
+        INSERT INTO pg_trunk (oid, classid)
+          SELECT oid, 'pg_type'::regclass
+          FROM pg_type
+          WHERE typname = #{name.quoted}
+            AND typnamespace = #{name.namespace}
+            AND typtype = 'c'
+        ON CONFLICT DO NOTHING;
+      SQL
+    end
+  end
+end

data/lib/pg_trunk/operations/composite_types/drop_composite_type.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#drop_composite_type(name, **options, &block)
+# Drop a composite type
+#
+# @param [#to_s] name (nil) The qualified name of the type
+# @option [Boolean] :if_exists (false) Suppress the error when the type is absent
+# @option [Symbol] :force (:restrict) How to process dependent objects (`:cascade` or `:restrict`)
+# @option [#to_s] :comment (nil) The comment describing the constraint
+# @yield [Proc] the block with the type's definition
+# @yieldparam The receiver of methods specifying the type
+#
+# The operation drops a composite_type type identified by its
+# qualified name (it can include a schema).
+#
+# For inversion use the same options as in the
+# `create_composite_type` operation.
+#
+#   drop_composite_type "paint.colored_point" do |d|
+#     d.column "x", "integer"
+#     d.column "y", "integer"
+#     d.column "color", "text", collation: "en_US"
+#     d.comment <<~COMMENT
+#       2D point with color
+#     COMMENT
+#   end
+#
+# Notice, that the composite type creation can use no attributes.
+# That's why dropping it is always reversible; though the reversion
+# would provide a type without columns:
+#
+#   drop_composite_type "paint.colored_point"
+#
+# With the `force: :cascade` option the operation would remove
+# all objects using the type.
+#
+#   drop_composite_type "paint.colored_point", force: :cascade
+#
+# With the `if_exists: true` option the operation won't fail
+# even when the view was absent in the database.
+#
+#   drop_composite_type "paint.colored_point", if_exists: true
+#
+# Both options make a migration irreversible due to uncertainty
+# of the previous state of the database.
+
+module PGTrunk::Operations::CompositeTypes
+  # @private
+  class DropCompositeType < Base
+    # Forbid these columns
+    validates :new_name, absence: true
+
+    def to_sql(_version)
+      sql = "DROP TYPE"
+      sql << " IF EXISTS" if if_exists
+      sql << " #{name.to_sql}"
+      sql << " CASCADE" if force == :cascade
+      sql << ";"
+    end
+
+    def invert
+      irreversible!("if_exists: true") if if_exists
+      irreversible!("force: :cascade") if force == :cascade
+      CreateCompositeType.new(**to_h.except(:force, :if_exists))
+    end
+  end
+end

data/lib/pg_trunk/operations/composite_types/rename_composite_type.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#rename_composite_type(name, to:)
+# Change the name and/or schema of a composite type
+#
+# @param [#to_s] name (nil) The qualified name of the type
+# @option [#to_s] :to (nil) The new qualified name for the type
+#
+# @example
+#
+#   rename_composite_type "point", to: "paint.colored_point"
+#
+# The operation is always reversible.
+
+module PGTrunk::Operations::CompositeTypes
+  # @private
+  class RenameCompositeType < Base
+    validates :new_name, presence: true
+    validates :force, :if_exists, :columns, absence: true
+
+    def to_sql(_version)
+      [*change_schema, *change_name].join("; ")
+    end
+
+    def invert
+      self.class.new(**to_h, name: new_name, to: name)
+    end
+
+    private
+
+    def change_schema
+      return if name.schema == new_name.schema
+
+      "ALTER TYPE #{name.to_sql} SET SCHEMA #{new_name.schema.inspect};"
+    end
+
+    def change_name
+      return if new_name.name == name.name
+
+      moved = name.merge(schema: new_name.schema)
+      "ALTER TYPE #{moved.to_sql} RENAME TO #{new_name.name.inspect};"
+    end
+  end
+end