pg_trunk 0.1.0 → 0.2.0

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/statistics/create_statistics.rb

@@ -1,61 +1,72 @@
 # frozen_string_literal: false
 
-# @!method ActiveRecord::Migration#create_statistics(name, **options, &block)
-# Create a custom statistics
-#
-# @param [#to_s] name (nil) The qualified name of the statistics
-# @option [Boolean] :if_not_exists (false)
-#   Suppress the error when the statistics is already exist
-# @option [#to_s] table (nil)
-#   The qualified name of the table whose statistics will be collected
-# @option [Array<Symbol>] kinds ([:dependencies, :mcv, :ndistinct])
-#   The kinds of statistics to be collected (all by default).
-#   Supported values in the array: :dependencies, :mcv, :ndistinct
-# @option [#to_s] :comment The description of the statistics
-# @yield [Proc] the block with the statistics' definition
-# @yieldparam The receiver of methods specifying the statistics
-#
-# The statistics can be created with explicit name:
-#
-#   create_statistics "users_stats" do |s|
-#     s.table "users"
-#     s.columns "family", "name"
-#     s.kinds :dependencies, :mcv, :ndistinct
-#     s.comment "Statistics for users' names and families"
-#   SQL
-#
-# The name can be generated as well:
-#
-#   create_statistics do |s|
-#     s.table "users"
-#     s.columns "family", "name"
-#     s.kinds :dependencies, :mcv, :ndistinct
-#     s.comment "Statistics for users' names and families"
-#   SQL
-#
-# Since v14 PostgreSQL have supported expressions in addition to columns:
-#
-#   create_statistics "users_stats" do |s|
-#     s.table "users"
-#     s.columns "family"
-#     s.expression "length(name)"
-#     s.kinds :dependencies, :mcv, :ndistinct
-#     s.comment "Statistics for users' name lengths and families"
-#   SQL
-#
-# as well as statistics for the sole expression (kinds must be blank)
-# by columns of some table.
-#
-#   create_statistics "users_stats" do |s|
-#     s.table "users"
-#     s.expression "length(name || ' ' || family)"
-#     s.comment "Statistics for full name lengths"
-#   SQL
-#
-# Use `if_not_exists: true` to suppress error in case the statistics
-# has already been created. This option, though, makes the migration
-# irreversible due to uncertainty of the previous state of the database.
-
+# @!parse
+#   class ActiveRecord::Migration
+#     # Create a custom statistics
+#     #
+#     # @param [#to_s] name (nil) The qualified name of the statistics
+#     # @option options [Boolean] :if_not_exists (false)
+#     #   Suppress the error when the statistics is already exist
+#     # @option options [#to_s] table (nil)
+#     #   The qualified name of the table whose statistics will be collected
+#     # @option options [Array<Symbol>] kinds ([:dependencies, :mcv, :ndistinct])
+#     #   The kinds of statistics to be collected (all by default).
+#     #   Supported values in the array: :dependencies, :mcv, :ndistinct
+#     # @option options [#to_s] :comment The description of the statistics
+#     # @yield [s] the block with the statistics' definition
+#     # @yieldparam Object receiver of methods specifying the statistics
+#     # @return [void]
+#     #
+#     # The statistics can be created with explicit name:
+#     #
+#     # ```ruby
+#     # create_statistics "users_stats" do |s|
+#     #   s.table "users"
+#     #   s.columns "family", "name"
+#     #   s.kinds :dependencies, :mcv, :ndistinct
+#     #   s.comment "Statistics for users' names and families"
+#     # SQL
+#     # ```
+#     #
+#     # The name can be generated as well:
+#     #
+#     # ```ruby
+#     # create_statistics do |s|
+#     #   s.table "users"
+#     #   s.columns "family", "name"
+#     #   s.kinds :dependencies, :mcv, :ndistinct
+#     #   s.comment "Statistics for users' names and families"
+#     # SQL
+#     # ```
+#     #
+#     # Since v14 PostgreSQL have supported expressions in addition to columns:
+#     #
+#     # ```ruby
+#     # create_statistics "users_stats" do |s|
+#     #   s.table "users"
+#     #   s.columns "family"
+#     #   s.expression "length(name)"
+#     #   s.kinds :dependencies, :mcv, :ndistinct
+#     #   s.comment "Statistics for users' name lengths and families"
+#     # SQL
+#     # ```
+#     #
+#     # as well as statistics for the sole expression (kinds must be blank)
+#     # by columns of some table.
+#     #
+#     # ```ruby
+#     # create_statistics "users_stats" do |s|
+#     #   s.table "users"
+#     #   s.expression "length(name || ' ' || family)"
+#     #   s.comment "Statistics for full name lengths"
+#     # SQL
+#     # ```
+#     #
+#     # Use `if_not_exists: true` to suppress error in case the statistics
+#     # has already been created. This option, though, makes the migration
+#     # irreversible due to uncertainty of the previous state of the database.
+#     def create_statistics(name, **options, &block); end
+#   end
 module PGTrunk::Operations::Statistics
   # SQL snippet to fetch statistics in v10-13
   SQL_V10 = <<~SQL.freeze