pg_trunk 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d88867c31da4259d601293ec91a915c070cef21a29ebe82e97a18a7dd0c72931
-  data.tar.gz: c18bc215374043cf53bfdeae0245d537899dba92c9d665adda0dd7f05eba2890
+  metadata.gz: c7e02c0f3a19350a502afda3e8697421912161b9bd800eb6302738cc623eb3eb
+  data.tar.gz: c0108a41cabe1fd1eebc0695e222ceafeb27c195b9c8fe2766e1f4ced4142c63
 SHA512:
-  metadata.gz: 17b2ec446bf2e44a04d7a9bd2e09451730321de3c08b3ca9fdf4faeb5f10894d933721c58b617f4309a900df2abd50609c6ac2295254afad727d992de8107106
-  data.tar.gz: 11de4394260f0b6b1012c577b78ac344fd72ae78bc34f4465634557b6310b0982c54e29151a9a673b2f94bd11e889889ec16e7a69acf9e6c4e796eab94364ef9
+  metadata.gz: 7af9d03c65275a700408841a032cf2f074349943a8d131e54d5dff4f467b9e4bb3fadce657d70469ec2cb1471b41578bef68fc91a92771429d3da84b648161f8
+  data.tar.gz: 9a47edbac23bffb1db4c74f0108f42c06c5e9d7aa28b5d213fed05f908a8e738114db1ad4c38557fde7db7e2d514cabf6646d65a8193c7e5bf664b4d20bc38ff

data/CHANGELOG.md

@@ -4,6 +4,12 @@ The noteworthy changes for each PGTrunk version are included here.
 The format is based on [Keep a Changelog] and this project adheres to [Semantic Versioning].
 For a complete changelog, see the [commits] for each version via the version links.
 
+## [0.2.0] (2022-01-26)
+
+* Add support for sequences (nepalez)
+* Fix inheritance of attribute aliases (nepalez)
+* Fix documentation for rules (nepalez)
+
 ## [0.1.3] (2022-01-20)
 
 * Add support for rules (nepalez)

data/README.md

@@ -73,6 +73,7 @@ As of today we support creation, modification and dropping the following objects
 - composite types
 - domains types
 - rules
+- sequences
 
 For `tables` and `indexes` we reuse the ActiveRecord's native methods.
 For `check constraints` and `foreign keys` we support both the native definitions inside the table

data/lib/pg_trunk/core/operation/attributes.rb

@@ -51,7 +51,7 @@ class PGTrunk::Operation
       end
 
       def inherited(klass)
-        klass.instance_variable_set(:@attr_aliases, attr_aliases)
+        klass.instance_variable_set(:@attr_aliases, attr_aliases.dup)
         super
       end
     end

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

@@ -23,7 +23,7 @@ module PGTrunk::Operations::Rules
     validates :kind, inclusion: { in: %i[instead also] }, allow_nil: true
     validates :event, inclusion: { in: %i[insert update delete] }, allow_nil: true
 
-    # By default foreign keys are sorted by tables and names.
+    # By default rules are sorted by tables and names.
     def <=>(other)
       return unless other.is_a?(self.class)
 

data/lib/pg_trunk/operations/rules/create_rule.rb

@@ -14,7 +14,7 @@
 #     # @option options [String] :where (nil) The condition (SQL) for the rule to be applied.
 #     # @option options [String] :command (nil) The SQL command to be added by the rule.
 #     # @yield [r] the block with the rule's definition
-#     # @yieldparam Object receiver of methods specifying the procedure
+#     # @yieldparam Object receiver of methods specifying the rule
 #     # @return [void]
 #     #
 #     # @notice `SELECT` rules are not supported by the gem.

data/lib/pg_trunk/operations/rules/drop_rule.rb

@@ -16,7 +16,7 @@
 #     # @option options [String] :where (nil) The condition (SQL) for the rule to be applied.
 #     # @option options [String] :command (nil) The SQL command to be added by the rule.
 #     # @yield [r] the block with the rule's definition
-#     # @yieldparam Object receiver of methods specifying the procedure
+#     # @yieldparam Object receiver of methods specifying the rule
 #     # @return [void]
 #     #
 #     # The rule can be identified by the table and explicit name
@@ -59,7 +59,7 @@
 #     # ```
 #     #
 #     # With the `force: :cascade` option the operation would remove
-#     # all the objects that use the type.
+#     # all the objects that use the rule.
 #     #
 #     # ```ruby
 #     # drop_rule :users, force: :cascade do |r|

data/lib/pg_trunk/operations/rules/rename_rule.rb

@@ -11,7 +11,7 @@
 #     # @yieldparam Object receiver of methods specifying the constraint
 #     # @return [void]
 #     #
-#     # A constraint can be identified by the table and explicit name
+#     # A rule can be identified by the table and explicit name
 #     #
 #     # ```ruby
 #     # rename_rule :users, "_forbid_insertion", to: "_skip_insertion"

data/lib/pg_trunk/operations/rules.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # nodoc
-module PGTrunk::Rules
+module PGTrunk::Operations
   # @private
   # Namespace for operations with rules
   module Rules

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: false
+
+module PGTrunk::Operations::Sequences
+  # @abstract
+  # @private
+  # Base class for operations with sequences
+  class Base < PGTrunk::Operation
+    attribute :type, :string, aliases: :as
+    attribute :increment_by, :integer
+    attribute :min_value, :integer
+    attribute :max_value, :integer
+    attribute :start_with, :integer
+    attribute :cache, :integer
+    attribute :cycle, :boolean
+    attribute :table, :string
+    attribute :column, :string
+
+    def owned_by(table, column)
+      self.table = table
+      self.column = column
+    end
+
+    # Ensure correctness of present values
+    # The table must be defined because the name only
+    # is not enough to identify the constraint.
+    validates :name, presence: true
+    validates :cache, numericality: { greater_than_or_equal_to: 1 }, allow_nil: true
+    validate { errors.add :base, "Increment must not be zero" if increment_by&.zero? }
+    validate do
+      next unless table.present? ^ column.present?
+
+      errors.add :base, "Both table and column must be set"
+    end
+    validate do
+      next if min_value.blank? || max_value.blank? || min_value <= max_value
+
+      errors.add :base, "Min value must not exceed max value"
+    end
+    validate do
+      next if start_with.blank? || min_value.blank? || start_with >= min_value
+
+      errors.add :base, "start value cannot be less than min value"
+    end
+    validate do
+      next if start_with.blank? || max_value.blank? || start_with <= max_value
+
+      errors.add :base, "start value cannot be greater than max value"
+    end
+
+    # Use comparison by name from pg_trunk operations base class (default)
+    # Support name as the only positional argument (default)
+
+    # Snippet to be used in all operations with rules
+    ruby_snippet do |s|
+      s.ruby_param(name.lean) if name.present?
+      s.ruby_param(as: type) if type.present? && from_type.blank?
+      s.ruby_param(to: new_name) if new_name.present?
+      s.ruby_param(if_exists: true) if if_exists
+      s.ruby_param(if_not_exists: true) if if_not_exists
+      s.ruby_param(force: :cascade) if force == :cascade
+
+      s.ruby_line(:type, type, from: from_type) if from_type.present?
+      s.ruby_line(:owned_by, table, column) if table.present? || column.present?
+      s.ruby_line(:increment_by, increment_by, from: from_increment_by) if increment_by&.!= 1
+      s.ruby_line(:min_value, min_value, from: from_min_value) if min_value.present?
+      s.ruby_line(:max_value, max_value, from: from_max_value) if max_value.present?
+      s.ruby_line(:start_with, start_with, from: from_start_with) if custom_start?
+      s.ruby_line(:cache, cache, from: from_cache) if cache&.!= 1
+      s.ruby_line(:cycle, cycle) unless cycle.nil?
+      s.ruby_line(:comment, comment, from: from_comment) if comment.present?
+    end
+
+    private
+
+    def custom_start?
+      increment_by&.<(0) ? start_with&.!=(max_value) : start_with&.!=(min_value)
+    end
+  end
+end

data/lib/pg_trunk/operations/sequences/change_sequence.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: false
+
+# @!parse
+#   class ActiveRecord::Migration
+#     # Modify a sequence
+#     #
+#     # @param [#to_s] name (nil) The qualified name of the sequence.
+#     # @option options [Boolean] :if_exists (false) Suppress the error when the sequence is absent.
+#     # @yield [s] the block with the sequence's definition.
+#     # @yieldparam Object receiver of methods specifying the sequence.
+#     # @return [void]
+#     #
+#     # The operation enables to alter a sequence without recreating it.
+#     # PostgreSQL allows any setting to be modified. The comment can be
+#     # changed as well.
+#     #
+#     # ```ruby
+#     # change_sequence "my_schema.global_id" do |s|
+#     #   s.owned_by "", "", from: %w[users gid]
+#     #   s.type "smallint", from: "integer"
+#     #   s.iterate_by 1, from: 2
+#     #   s.min_value 1, from: 0
+#     #   s.max_value 2000, from: 1999
+#     #   s.start_with 2, from: 1
+#     #   s.cache 1, from: 10
+#     #   s.cycle false
+#     #   s.comment "Identifier", from: "Global identifier"
+#     # end
+#     # ```
+#     #
+#     # As in the snippet above, to make the change invertible,
+#     # you have to define from option for every changed attribute,
+#     # except for the boolean `cycle`.
+#     #
+#     # With the `if_exists: true` option, the operation won't raise
+#     # when the sequence is absent.
+#     #
+#     # ```ruby
+#     # change_sequence "my_schema.global_id", if_exists: true do |s|
+#     #   s.type "smallint"
+#     #   s.iterate_by 1
+#     #   s.min_value 1
+#     #   s.max_value 2000
+#     #   s.start_with 2
+#     #   s.cache 1
+#     #   s.cycle false
+#     #   s.comment "Identifier"
+#     # end
+#     # ```
+#     #
+#     # This option makes a migration irreversible due to uncertainty
+#     # of the previous state of the database. That's why in the last
+#     # example no `from:` option was added (they are useless).
+#     def change_sequence(name, **options, &block); end
+#   end
+module PGTrunk::Operations::Sequences
+  # @private
+  class ChangeSequence < Base
+    # Operation-specific validations
+    validate { errors.add :base, "Changes can't be blank" if changes.blank? }
+    validates :force, :if_not_exists, :new_name, absence: true
+
+    def owned_by(table, column, from: nil)
+      self.table = table
+      self.column = column
+      self.from_table, self.from_column = Array(from)
+    end
+
+    def to_sql(_version)
+      [*alter_sequence, *update_comment].join(" ")
+    end
+
+    def invert
+      irreversible!("if_exists: true") if if_exists
+      undefined = inversion.select { |_, v| v.nil? }.keys.join(", ").presence
+      raise IrreversibleMigration.new(self, nil, <<~MSG.squish) if undefined
+        Undefined values to revert #{undefined}.
+      MSG
+
+      self.class.new(name: name, **inversion) if inversion.any?
+    end
+
+    private
+
+    INF = (2**63) - 1
+
+    def changes
+      @changes ||= attributes.symbolize_keys.except(:name, :if_exists).compact
+    end
+
+    def inversion
+      @inversion ||= changes.each_with_object({}) do |(key, val), obj|
+        obj[key] = send(:"from_#{key}")
+        obj[key] = !val if [true, false].include?(val)
+      end
+    end
+
+    def alter_sequence
+      return if changes.except(:comment).blank?
+
+      sql = "ALTER SEQUENCE"
+      sql << " IF EXISTS" if if_exists
+      sql << " #{name.to_sql}"
+      sql << " AS #{type}" if type.present?
+      sql << " INCREMENT BY #{increment_by}" if increment_by.present?
+      sql << " MINVALUE #{min_value}" if min_value&.>(-INF)
+      sql << " NO MINVALUE" if min_value&.<=(-INF)
+      sql << " MAXVALUE #{max_value}" if max_value&.<(INF)
+      sql << " NO MAXVALUE" if max_value&.>=(INF)
+      sql << " START WITH #{start_with}" if start_with.present?
+      sql << " CACHE #{cache}" if cache.present?
+      sql << " OWNED BY #{table}.#{column}" if table.present? && column.present?
+      sql << " OWNED BY NONE" if table == "" || column == ""
+      sql << " CYCLE" if cycle
+      sql << " NO CYCLE" if cycle == false
+      sql << ";"
+    end
+
+    def update_comment
+      return unless comment
+      return <<~SQL.squish unless if_exists
+        COMMENT ON SEQUENCE #{name.to_sql} IS $comment$#{comment}$comment$;
+      SQL
+
+      # change the comment conditionally
+      <<~SQL.squish
+        DO $$
+          BEGIN
+            IF EXISTS (
+              SELECT FROM pg_sequence s JOIN pg_class c ON c.oid = s.seqrelid
+              WHERE c.relname = #{name.quoted}
+                AND c.relnamespace = #{name.namespace}
+            ) THEN
+              COMMENT ON SEQUENCE #{name.to_sql}
+                IS $comment$#{comment}$comment$;
+            END IF;
+          END
+        $$;
+      SQL
+    end
+  end
+end

data/lib/pg_trunk/operations/sequences/create_sequence.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: false
+
+# @!parse
+#   class ActiveRecord::Migration
+#     # Create a sequence
+#     #
+#     # @param [#to_s] name (nil) The qualified name of the sequence
+#     # @option options [#to_s] :as ("bigint") The type of the sequence's value
+#     #   Supported values: "bigint" (or "int8", default), "integer" (or "int4"), "smallint" ("int2").
+#     # @option options [Boolean] :if_not_exists (false)
+#     #   Suppress the error when the sequence already existed.
+#     # @option options [Integer] :increment_by (1) Non-zero step of the sequence (either positive or negative).
+#     # @option options [Integer] :min_value (nil) Minimum value of the sequence.
+#     # @option options [Integer] :max_value (nil) Maximum value of the sequence.
+#     # @option options [Integer] :start_with (nil) The first value of the sequence.
+#     # @option options [Integer] :cache (1) The number of values to be generated and cached.
+#     # @option options [Boolean] :cycle (false) If the sequence should be reset to start
+#     #   after its value reaches min/max value.
+#     # @option options [#to_s] :comment (nil) The comment describing the sequence.
+#     # @yield [s] the block with the sequence's definition
+#     # @yieldparam Object receiver of methods specifying the sequence
+#     # @return [void]
+#     #
+#     # The sequence can be created by its qualified name only
+#     #
+#     # ```ruby
+#     # create_sequence "my_schema.global_id"
+#     # ```
+#     #
+#     # we also support all PostgreSQL settings for the sequence:
+#     #
+#     # ```ruby
+#     # create_sequence "my_schema.global_id", as: "integer" do |s|
+#     #   s.iterate_by 2
+#     #   s.min_value 0
+#     #   s.max_value 1999
+#     #   s.start_with 1
+#     #   s.cache 10
+#     #   s.cycle true
+#     #   s.comment "Global identifier"
+#     # end
+#     # ```
+#     #
+#     # Using a block method `s.owned_by` you can bind the sequence to
+#     # some table's column. This means the sequence is dependent from
+#     # the column and will be dropped along with it. Notice that the
+#     # name of the table is NOT qualified because the table MUST belong
+#     # to the same schema as the sequence itself.
+#     #
+#     # ```ruby
+#     # create_table "users" do |t|
+#     #   t.bigint :gid
+#     # end
+#     #
+#     # create_sequence "my_schema.global_id" do |s|
+#     #   s.owned_by "users", "gid"
+#     # end
+#     # ```
+#     #
+#     # With the `if_not_exists: true` option the operation wouldn't raise
+#     # an exception in case the sequence has been already created.
+#     #
+#     # ```ruby
+#     # create_sequence "my_schema.global_id", if_not_exists: true
+#     # ```
+#     #
+#     # This option makes the migration irreversible due to uncertainty
+#     # of the previous state of the database.
+#     def create_sequence(name, **options, &block); end
+#   end
+module PGTrunk::Operations::Sequences
+  # @private
+  class CreateSequence < Base
+    validates :if_exists, :force, :new_name, absence: true
+
+    from_sql do |_server_version|
+      <<~SQL
+        SELECT
+          c.oid,
+          (c.relnamespace::regnamespace || '.' || c.relname) AS name,
+          p.refobjid::regclass AS table,
+          a.attname AS column,
+          (
+            CASE WHEN s.seqtypid != 'int8'::regtype THEN format_type(s.seqtypid, 0) END
+          ) AS type,
+          ( CASE WHEN s.seqincrement != 1 THEN s.seqincrement END ) AS increment_by,
+          (
+            CASE
+            WHEN s.seqincrement > 0 THEN
+              CASE WHEN s.seqmin != 1 THEN s.seqmin END
+            ELSE
+              CASE
+              WHEN s.seqtypid = 'int2'::regtype AND s.seqmin = -32768 THEN NULL
+              WHEN s.seqtypid = 'int4'::regtype AND s.seqmin = -2147483648 THEN NULL
+              WHEN s.seqtypid = 'int8'::regtype AND s.seqmin = -9223372036854775808 THEN NULL
+              ELSE s.seqmin
+              END
+            END
+          ) AS min_value,
+          (
+            CASE
+            WHEN s.seqincrement < 0 THEN
+              CASE WHEN s.seqmax != -1 THEN s.seqmax END
+            ELSE
+              CASE
+              WHEN s.seqtypid = 'int2'::regtype AND s.seqmax = 32767 THEN NULL
+              WHEN s.seqtypid = 'int4'::regtype AND s.seqmax = 2147483647 THEN NULL
+              WHEN s.seqtypid = 'int8'::regtype AND s.seqmax = 9223372036854775807 THEN NULL
+              ELSE s.seqmax
+              END
+            END
+          ) AS max_value,
+          (
+            CASE
+            WHEN s.seqincrement > 0 AND s.seqstart = s.seqmin THEN NULL
+            WHEN s.seqincrement < 0 AND s.seqstart = s.seqmax THEN NULL
+            ELSE s.seqstart
+            END
+          ) AS start_with,
+          ( CASE WHEN s.seqcache != 1 THEN s.seqcache END ) AS cache,
+          ( CASE WHEN s.seqcycle THEN true END ) AS cycle,
+          d.description AS comment
+        FROM pg_sequence s
+          JOIN pg_class c ON c.oid = s.seqrelid
+          JOIN pg_trunk t ON t.oid = c.oid
+            AND t.classid = 'pg_sequence'::regclass
+          LEFT JOIN pg_depend p ON p.objid = c.oid
+            AND p.classid = 'pg_class'::regclass
+            AND p.refclassid = 'pg_class'::regclass
+            AND p.objsubid = 0 AND p.refobjsubid !=0
+          LEFT JOIN pg_attribute a ON a.attrelid = p.refobjid
+            AND a.attnum = p.refobjsubid
+          LEFT JOIN pg_description d ON d.objoid = c.oid;
+      SQL
+    end
+
+    def to_sql(_server_version)
+      [create_sequence, *comment_sequence, register_sequence].join(" ")
+    end
+
+    def invert
+      irreversible!("if_not_exists: true") if if_not_exists
+      DropSequence.new(**to_h.except(:if_not_exists))
+    end
+
+    private
+
+    def create_sequence
+      sql = "CREATE SEQUENCE"
+      sql << " IF NOT EXISTS" if if_not_exists
+      sql << " #{name.to_sql}"
+      sql << " AS #{type}" if type.present?
+      sql << " INCREMENT BY #{increment_by}" if increment_by.present?
+      sql << " MINVALUE #{min_value}" if min_value.present?
+      sql << " MAXVALUE #{max_value}" if max_value.present?
+      sql << " START WITH #{start_with}" if start_with.present?
+      sql << " CACHE #{cache}" if cache.present?
+      sql << " OWNED BY #{table}.#{column}" if table.present? && column.present?
+      sql << " CYCLE" if cycle
+      sql << ";"
+    end
+
+    def comment_sequence
+      <<~SQL.squish if comment.present?
+        COMMENT ON SEQUENCE #{name.to_sql} IS $comment$#{comment}$comment$;
+      SQL
+    end
+
+    def register_sequence
+      <<~SQL.squish
+        INSERT INTO pg_trunk (oid, classid)
+          SELECT c.oid, 'pg_sequence'::regclass
+          FROM pg_sequence s JOIN pg_class c ON c.oid = s.seqrelid
+          WHERE c.relname = #{name.quoted}
+            AND c.relnamespace = #{name.namespace}
+        ON CONFLICT DO NOTHING;
+      SQL
+    end
+  end
+end

data/lib/pg_trunk/operations/sequences/drop_sequence.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: false
+
+# @!parse
+#   class ActiveRecord::Migration
+#     # Drop a sequence
+#     #
+#     # @param [#to_s] name (nil) The qualified name of the sequence
+#     # @option options [#to_s] :as ("bigint") The type of the sequence's value
+#     #   Supported values: "bigint" (or "int8", default), "integer" (or "int4"), "smallint" ("int2").
+#     # @option options [Boolean] :if_exists (false) Suppress the error when the sequence is absent.
+#     # @option options [Symbol] :force (:restrict) Define how to process dependent objects
+#     #   Supported values: :restrict (default), :cascade.
+#     # @option options [Integer] :increment_by (1) Non-zero step of the sequence (either positive or negative).
+#     # @option options [Integer] :min_value (nil) Minimum value of the sequence.
+#     # @option options [Integer] :max_value (nil) Maximum value of the sequence.
+#     # @option options [Integer] :start_with (nil) The first value of the sequence.
+#     # @option options [Integer] :cache (1) The number of values to be generated and cached.
+#     # @option options [Boolean] :cycle (false) If the sequence should be reset to start
+#     #   after its value reaches min/max value.
+#     # @option options [#to_s] :comment (nil) The comment describing the sequence.
+#     # @yield [s] the block with the sequence's definition
+#     # @yieldparam Object receiver of methods specifying the sequence
+#     # @return [void]
+#     #
+#     # The sequence can be dropped by its qualified name only
+#     #
+#     # ```ruby
+#     # drop_sequence "global_number"
+#     # ```
+#     #
+#     # For inversion provide options for the `create_sequence` operation as well:
+#     #
+#     # ```ruby
+#     # drop_sequence "global_id", as: "int2" do |s|
+#     #   s.iterate_by 2
+#     #   s.min_value 0
+#     #   s.max_value 1999
+#     #   s.start_with 1
+#     #   s.cache 10
+#     #   s.cycle true
+#     #   s.comment "Global identifier"
+#     # end
+#     # ```
+#     #
+#     # The operation can be called with `if_exists` option to suppress
+#     # the exception in case when the sequence is absent:
+#     #
+#     # ```ruby
+#     # drop_sequence "global_number", if_exists: true
+#     # ```
+#     #
+#     # With the `force: :cascade` option the operation would remove
+#     # all the objects that use the sequence.
+#     #
+#     # ```ruby
+#     # drop_sequence "global_number", force: :cascade
+#     # ```
+#     #
+#     # In both cases the operation becomes irreversible due to
+#     # uncertainty of the previous state of the database.
+#     def drop_sequence(name, **options, &block); end
+#   end
+module PGTrunk::Operations::Sequences
+  # @private
+  class DropSequence < Base
+    validates :if_not_exists, :new_name, absence: true
+
+    def to_sql(_version)
+      sql = "DROP SEQUENCE"
+      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
+      CreateSequence.new(**to_h.except(:if_exists, :force))
+    end
+  end
+end

data/lib/pg_trunk/operations/sequences/rename_sequence.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: false
+
+# @!parse
+#   class ActiveRecord::Migration
+#     # Rename a sequence
+#     #
+#     # @param [#to_s] name (nil) The current qualified name of the sequence
+#     # @option options [#to_s] :to (nil) The new qualified name for the sequence
+#     # @option options [Boolean] :if_exists (false) Suppress the error when the sequence is absent.
+#     # @return [void]
+#     #
+#     # The operation allows to change both name and schema
+#     #
+#     # ```ruby
+#     # rename_sequence "global_num", to: "sequences.global_number"
+#     # ```
+#     #
+#     # With the `if_exists: true` option the operation wouldn't raise
+#     # an exception in case the sequence hasn't been created yet.
+#     #
+#     # ```ruby
+#     # create_sequence "my_schema.global_id", if_exists: true
+#     # ```
+#     #
+#     # This option makes the migration irreversible due to uncertainty
+#     # of the previous state of the database.
+#     def rename_sequence(name, **options, &block); end
+#   end
+module PGTrunk::Operations::Sequences
+  # @private
+  class RenameSequence < Base
+    validates :new_name, presence: true
+    validates :if_not_exists, :force, :type, :increment_by, :min_value,
+              :max_value, :start_with, :cache, :cycle, :comment, absence: true
+
+    def to_sql(_version)
+      [*change_schema, *change_name].join(" ")
+    end
+
+    def invert
+      irreversible!("if_exists: true") if if_exists
+      self.class.new(**to_h, name: new_name, to: name)
+    end
+
+    private
+
+    def change_schema
+      return if name.schema == new_name.schema
+
+      sql = "ALTER SEQUENCE"
+      sql << " IF EXISTS" if if_exists
+      sql << " #{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)
+      sql = "ALTER SEQUENCE"
+      sql << " IF EXISTS" if if_exists
+      sql << " #{moved.to_sql} RENAME TO #{new_name.name.inspect};"
+    end
+  end
+end

data/lib/pg_trunk/operations/sequences.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# nodoc
+module PGTrunk::Operations
+  # @private
+  # Namespace for operations with sequences
+  module Sequences
+    require_relative "sequences/base"
+    require_relative "sequences/change_sequence"
+    require_relative "sequences/create_sequence"
+    require_relative "sequences/drop_sequence"
+    require_relative "sequences/rename_sequence"
+  end
+end

data/lib/pg_trunk/operations.rb

@@ -9,6 +9,7 @@ module PGTrunk
     require_relative "operations/enums"
     require_relative "operations/composite_types"
     require_relative "operations/domains"
+    require_relative "operations/sequences"
     require_relative "operations/tables"
     require_relative "operations/views"
     require_relative "operations/materialized_views"

data/lib/pg_trunk/version.rb

@@ -2,5 +2,5 @@
 
 module PGTrunk
   # @private
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/spec/operations/sequences/change_sequence_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#change_sequence" do
+  before { run_migration(old_snippet) }
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_sequence "global_num", as: "integer" do |s|
+        s.increment_by 2
+        s.min_value 0
+        s.max_value 2000
+        s.start_with 1
+        s.cache 10
+        s.cycle true
+        s.comment "Sequence for global numbers (odds then evens)"
+      end
+    RUBY
+  end
+
+  context "with reversible changes" do
+    let(:migration) do
+      <<~RUBY
+        change_sequence "global_num" do |s|
+          s.type "bigint", from: "integer"
+          s.increment_by 3, from: 2
+          s.min_value 1, from: 0
+          s.max_value 3000, from: 2000
+          s.start_with 2, from: 1
+          s.cache 20, from: 10
+          s.cycle false
+          s.comment "Global numbers", from: "Sequence for global numbers (odds then evens)"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_sequence "global_num" do |s|
+          s.increment_by 3
+          s.max_value 3000
+          s.start_with 2
+          s.cache 20
+          s.comment "Global numbers"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with irreversible changes" do
+    let(:migration) do
+      <<~RUBY
+        change_sequence "global_num" do |s|
+          s.type "bigint"
+          s.increment_by 3
+          s.min_value 1
+          s.max_value 3000
+          s.start_with 2
+          s.cache 20
+          s.cycle false
+          s.comment "Global numbers"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_sequence "global_num" do |s|
+          s.increment_by 3
+          s.max_value 3000
+          s.start_with 2
+          s.cache 20
+          s.comment "Global numbers"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    it { is_expected.to be_irreversible.because_of(/undefined values to revert/i) }
+  end
+
+  context "when sequence was absent" do
+    let(:old_snippet) { "" }
+
+    context "without the `:if_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          change_sequence "global_num" do |s|
+            s.comment "Global numbers"
+          end
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `if_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          change_sequence "global_num", if_exists: true do |s|
+            s.comment "Global numbers"
+          end
+        RUBY
+      end
+
+      its(:execution) { is_expected.not_to change_schema }
+      it { is_expected.to be_irreversible.because_of(/if_exists: true/i) }
+    end
+  end
+
+  context "without changes" do
+    let(:migration) do
+      <<~RUBY
+        change_sequence "global_num"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/changes can't be blank/i) }
+  end
+
+  context "without a name" do
+    let(:migration) do
+      <<~RUBY
+        change_sequence do |s|
+          s.comment "Global numbers"
+        end
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/sequences/create_sequence_spec.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#create_sequence" do
+  before_all do
+    run_migration <<~RUBY
+      create_schema :app
+
+      create_table :customers do |t|
+        t.bigint :global_num
+      end
+    RUBY
+  end
+
+  context "with a minimal definition" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "app.global_num"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a table-agnostic definition" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "app.global_num", as: "integer" do |s|
+          s.increment_by 2
+          s.min_value 0
+          s.max_value 2000
+          s.start_with 1
+          s.cache 10
+          s.cycle true
+          s.comment "Sequence for global numbers (odds then evens)"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a column-specific definition" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "global_num" do |s|
+          s.owned_by "customers", "global_num"
+          s.increment_by 2
+          s.min_value 0
+          s.max_value 2000
+          s.start_with 1
+          s.cache 10
+          s.cycle true
+          s.comment "Sequence for customers global_num"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when the sequence existed" do
+    before { run_migration(migration) }
+
+    context "without the `:if_not_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          create_sequence "app.global_num"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `if_not_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          create_sequence "app.global_num", if_not_exists: true
+        RUBY
+      end
+      let(:snippet) do
+        <<~RUBY
+          create_sequence "app.global_num"
+        RUBY
+      end
+
+      its(:execution) { is_expected.not_to change_schema }
+      it { is_expected.to be_irreversible.because_of(/if_not_exists: true/i) }
+    end
+  end
+
+  context "with a zero increment" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "app.global_number", increment_by: 0
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/increment must not be zero/i) }
+  end
+
+  context "with invalid min..max range" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "app.global_number", min_value: 2, max_value: 1
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/min value must not exceed max value/i) }
+  end
+
+  context "with start value out of min..max range" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "app.global_number",
+                        min_value: 0,
+                        max_value: 10,
+                        start_with: -1
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/start value cannot be less than min value/i) }
+  end
+
+  context "with a zero cache" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "app.global_number", cache: 0
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/cache must be greater than or equal to 1/i) }
+  end
+
+  context "with a wrong type" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "app.global_number", as: "text"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to raise_error(StandardError) }
+  end
+
+  context "without a name" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/sequences/drop_sequence_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#drop_sequence" do
+  before_all { run_migration("create_schema :app") }
+  before { run_migration(old_snippet) }
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_sequence "app.global_num", as: "integer" do |s|
+        s.increment_by 2
+        s.min_value 0
+        s.max_value 2000
+        s.start_with 1
+        s.cache 10
+        s.cycle true
+        s.comment "Sequence for global numbers (odds then evens)"
+      end
+    RUBY
+  end
+
+  context "with a full definition" do
+    let(:migration) do
+      <<~RUBY
+        drop_sequence "app.global_num", as: "integer" do |s|
+          s.increment_by 2
+          s.min_value 0
+          s.max_value 2000
+          s.start_with 1
+          s.cache 10
+          s.cycle true
+          s.comment "Sequence for global numbers (odds then evens)"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a minimal definition" do
+    let(:migration) do
+      <<~RUBY
+        drop_sequence "app.global_num"
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_sequence "app.global_num"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:inversion) { is_expected.to remove(old_snippet).from_schema }
+    its(:inversion) { is_expected.to insert(new_snippet).into_schema }
+  end
+
+  context "when the sequence was absent" do
+    before { run_migration(migration) }
+
+    context "without the `:if_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_sequence "app.global_num"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `if_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_sequence "app.global_num", if_exists: true
+        RUBY
+      end
+
+      its(:execution) { is_expected.not_to change_schema }
+      it { is_expected.to be_irreversible.because_of(/if_exists: true/i) }
+    end
+  end
+
+  context "with the force: :cascade option" do
+    let(:migration) do
+      <<~RUBY
+        drop_sequence "app.global_num", force: :cascade
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    it { is_expected.to be_irreversible.because_of(/force: :cascade/i) }
+  end
+
+  context "without a name" do
+    let(:migration) do
+      <<~RUBY
+        drop_sequence
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/sequences/rename_sequence_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#rename_sequence" do
+  before_all { run_migration "create_schema :seq" }
+  before { run_migration(old_snippet) }
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_sequence "global_num" do |s|
+        s.increment_by 2
+        s.min_value 0
+        s.max_value 2000
+        s.start_with 1
+        s.cache 10
+        s.cycle true
+        s.comment "Sequence for global numbers (odds then evens)"
+      end
+    RUBY
+  end
+
+  context "with a new name" do
+    let(:migration) do
+      <<~RUBY
+        rename_sequence "global_num", to: "seq.global_number"
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_sequence "seq.global_number" do |s|
+          s.increment_by 2
+          s.min_value 0
+          s.max_value 2000
+          s.start_with 1
+          s.cache 10
+          s.cycle true
+          s.comment "Sequence for global numbers (odds then evens)"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when sequence was absent" do
+    let(:old_snippet) { "" }
+
+    context "without the `:if_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          rename_sequence "global_num", to: "global_number"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `if_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          rename_sequence "global_num", to: "global_number", if_exists: true
+        RUBY
+      end
+
+      its(:execution) { is_expected.not_to change_schema }
+      it { is_expected.to be_irreversible.because_of(/if_exists: true/i) }
+    end
+  end
+
+  context "with the same name" do
+    let(:migration) do
+      <<~RUBY
+        rename_sequence "global_num", to: "global_num"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/new name must be different/i) }
+  end
+
+  context "without new name" do
+    let(:migration) do
+      <<~RUBY
+        rename_sequence "global_num"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/new name can't be blank/i) }
+  end
+
+  context "without current name" do
+    let(:migration) do
+      <<~RUBY
+        rename_sequence to: "seq.global_number"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_trunk
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrew Kozin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-20 00:00:00.000000000 Z
+date: 2022-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -174,6 +174,12 @@ files:
 - lib/pg_trunk/operations/rules/create_rule.rb
 - lib/pg_trunk/operations/rules/drop_rule.rb
 - lib/pg_trunk/operations/rules/rename_rule.rb
+- lib/pg_trunk/operations/sequences.rb
+- lib/pg_trunk/operations/sequences/base.rb
+- lib/pg_trunk/operations/sequences/change_sequence.rb
+- lib/pg_trunk/operations/sequences/create_sequence.rb
+- lib/pg_trunk/operations/sequences/drop_sequence.rb
+- lib/pg_trunk/operations/sequences/rename_sequence.rb
 - lib/pg_trunk/operations/statistics.rb
 - lib/pg_trunk/operations/statistics/base.rb
 - lib/pg_trunk/operations/statistics/create_statistics.rb
@@ -246,6 +252,10 @@ files:
 - spec/operations/rules/create_rule_spec.rb
 - spec/operations/rules/drop_rule_spec.rb
 - spec/operations/rules/rename_rule_spec.rb
+- spec/operations/sequences/change_sequence_spec.rb
+- spec/operations/sequences/create_sequence_spec.rb
+- spec/operations/sequences/drop_sequence_spec.rb
+- spec/operations/sequences/rename_sequence_spec.rb
 - spec/operations/statistics/create_statistics_spec.rb
 - spec/operations/statistics/drop_statistics_spec.rb
 - spec/operations/statistics/rename_statistics_spec.rb