pg_trunk 0.1.0 → 0.2.0

data/lib/pg_trunk/operations/procedures/drop_procedure.rb

@@ -1,50 +1,61 @@
 # frozen_string_literal: false
 
-# @!method ActiveRecord::Migration#drop_procedure(name, **options, &block)
-# Drop a procedure
-#
-# @param [#to_s] name (nil)
-#   The qualified name of the procedure with arguments and returned value type
-# @option [Boolean] :if_exists (false) Suppress the error when the procedure is absent
-# @option [#to_s] :language ("sql") The language (like "sql" or "plpgsql")
-# @option [#to_s] :body (nil) The body of the procedure
-# @option [Symbol] :security (:invoker) Define the role under which the procedure is invoked
-#   Supported values: :invoker (default), :definer
-# @option [#to_s] :comment The description of the procedure
-# @yield [Proc] the block with the procedure's definition
-# @yieldparam The receiver of methods specifying the procedure
-#
-# A procedure can be dropped by a plain name:
-#
-#   drop_procedure "set_foo"
-#
-# If several overloaded procedures have the name,
-# then you must specify the signature having
-# types of attributes at least:
-#
-#   drop_procedure "set_foo(int)"
-#
-# In both cases above the operation is irreversible. To make it
-# inverted you have to provide a full signature along with
-# the body definition. The other options are supported as well:
-#
-#   drop_procedure "metadata.set_foo(a int)" do |p|
-#     p.language "sql" # (default)
-#     p.body <<~SQL
-#       SET foo = a
-#     SQL
-#     p.security :invoker # (default), also :definer
-#     p.comment "Multiplies 2 integers"
-#   SQL
-#
-# The operation can be called with `if_exists` option. In this case
-# it would do nothing when no procedure existed.
-#
-#   drop_procedure "metadata.set_foo(a int)", if_exists: true
-#
-# Notice, that this option make the operation irreversible because of
-# uncertainty about the previous state of the database.
-
+# @!parse
+#   class ActiveRecord::Migration
+#     # Drop a procedure
+#     #
+#     # @param [#to_s] name (nil)
+#     #   The qualified name of the procedure with arguments and returned value type
+#     # @option options [Boolean] :if_exists (false) Suppress the error when the procedure is absent
+#     # @option options [#to_s] :language ("sql") The language (like "sql" or "plpgsql")
+#     # @option options [#to_s] :body (nil) The body of the procedure
+#     # @option options [Symbol] :security (:invoker) Define the role under which the procedure is invoked
+#     #   Supported values: :invoker (default), :definer
+#     # @option options [#to_s] :comment The description of the procedure
+#     # @yield [p] the block with the procedure's definition
+#     # @yieldparam Object receiver of methods specifying the procedure
+#     # @return [void]
+#     #
+#     # A procedure can be dropped by a plain name:
+#     #
+#     # ```ruby
+#     # drop_procedure "set_foo"
+#     # ```
+#     #
+#     # If several overloaded procedures have the name,
+#     # then you must specify the signature having
+#     # types of attributes at least:
+#     #
+#     # ```ruby
+#     # drop_procedure "set_foo(int)"
+#     # ```
+#     #
+#     # In both cases above the operation is irreversible. To make it
+#     # inverted you have to provide a full signature along with
+#     # the body definition. The other options are supported as well:
+#     #
+#     # ```ruby
+#     # drop_procedure "metadata.set_foo(a int)" do |p|
+#     #   p.language "sql" # (default)
+#     #   p.body <<~SQL
+#     #     SET foo = a
+#     #   SQL
+#     #   p.security :invoker # (default), also :definer
+#     #   p.comment "Multiplies 2 integers"
+#     # SQL
+#     # ```
+#     #
+#     # The operation can be called with `if_exists` option. In this case
+#     # it would do nothing when no procedure existed.
+#     #
+#     # ```ruby
+#     # drop_procedure "metadata.set_foo(a int)", if_exists: true
+#     # ```
+#     #
+#     # Notice, that this option make the operation irreversible because of
+#     # uncertainty about the previous state of the database.
+#     def drop_procedure(name, **options, &block); end
+#   end
 module PGTrunk::Operations::Procedures
   # @private
   class DropProcedure < Base

data/lib/pg_trunk/operations/procedures/rename_procedure.rb

@@ -1,27 +1,34 @@
 # frozen_string_literal: false
 
-# @!method ActiveRecord::Migration#rename_procedure(name, to:)
-# Change the name and/or schema of a procedure
-#
-# @param [#to_s] :name (nil) The qualified name of the procedure
-# @option [#to_s] :to (nil) The new qualified name for the procedure
-#
-# A procedure can be renamed by changing both the name
-# and the schema (namespace) it belongs to.
-#
-# If there are no overloaded procedures, then you can use a plain name:
-#
-#   rename_procedure "math.set_foo", to: "public.foo_setup"
-#
-# otherwise the types of attributes must be explicitly specified.
-#
-#   rename_procedure "math.set_foo(int)", to: "public.foo_setup"
-#
-# Any specification of attributes in `to:` option
-# is ignored because they cannot be changed anyway.
-#
-# The operation is always reversible.
-
+# @!parse
+#   class ActiveRecord::Migration
+#     # Change the name and/or schema of a procedure
+#     #
+#     # @param [#to_s] :name (nil) The qualified name of the procedure
+#     # @option options [#to_s] :to (nil) The new qualified name for the procedure
+#     # @return [void]
+#     #
+#     # A procedure can be renamed by changing both the name
+#     # and the schema (namespace) it belongs to.
+#     #
+#     # If there are no overloaded procedures, then you can use a plain name:
+#     #
+#     # ```ruby
+#     # rename_procedure "math.set_foo", to: "public.foo_setup"
+#     # ```
+#     #
+#     # otherwise the types of attributes must be explicitly specified.
+#     #
+#     # ```ruby
+#     # rename_procedure "math.set_foo(int)", to: "public.foo_setup"
+#     # ```
+#     #
+#     # Any specification of attributes in `to:` option
+#     # is ignored because they cannot be changed anyway.
+#     #
+#     # The operation is always reversible.
+#     def rename_procedure(name, to:); end
+#   end
 module PGTrunk::Operations::Procedures
   # @private
   class RenameProcedure < Base

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: false
+
+module PGTrunk::Operations::Rules
+  # @abstract
+  # @private
+  # Base class for operations with rules
+  class Base < PGTrunk::Operation
+    attribute :command, :string
+    attribute :event, :pg_trunk_symbol
+    attribute :kind, :pg_trunk_symbol
+    attribute :replace_existing, :boolean
+    attribute :table, :pg_trunk_qualified_name
+    attribute :where, :string
+
+    # Generate missed name from table & expression
+    after_initialize { self.name = generated_name if name.blank? }
+
+    # Ensure correctness of present values
+    # The table must be defined because the name only
+    # is not enough to identify the constraint.
+    validates :if_not_exists, absence: true
+    validates :table, :name, presence: true
+    validates :kind, inclusion: { in: %i[instead also] }, allow_nil: true
+    validates :event, inclusion: { in: %i[insert update delete] }, allow_nil: true
+
+    # By default rules are sorted by tables and names.
+    def <=>(other)
+      return unless other.is_a?(self.class)
+
+      result = table <=> other.table
+      result.zero? ? super : result
+    end
+
+    # Support `table` and `name` in positional arguments
+    # @example
+    #   create_rule :users, "_do_nothing"
+    ruby_params :table, :name
+
+    # Snippet to be used in all operations with rules
+    ruby_snippet do |s|
+      s.ruby_param(table.lean) if table.present?
+      s.ruby_param(name.name) if custom_name?
+      s.ruby_param(if_exists: true) if if_exists
+      s.ruby_param(replace_existing: true) if replace_existing
+      s.ruby_param(force: :cascade) if force == :cascade
+
+      s.ruby_line(:event, event) if event.present?
+      s.ruby_line(:kind, :instead) if kind == :instead
+      s.ruby_line(:where, where) if where.present?
+      s.ruby_line(:command, command) if command.present?
+      s.ruby_line(:comment, comment) if comment.present?
+    end
+
+    private
+
+    # *************************************************************************
+    # Helpers for operation definitions
+    # *************************************************************************
+
+    def generated_name
+      return @generated_name if instance_variable_defined?(:@generated_name)
+
+      @generated_name = begin
+        return if table.blank? || event.blank?
+
+        key_options = { event: event, kind: (kind || :also) }
+        identifier = "#{table.lean}_#{key_options}_rule"
+        hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
+        PGTrunk::QualifiedName.wrap("rule_rails_#{hashed_identifier}")
+      end
+    end
+
+    def custom_name?(qname = name)
+      qname&.differs_from?(/^rule_rails_\w+$/)
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: false
+
+# @!parse
+#   class ActiveRecord::Migration
+#     # Create a rule
+#     #
+#     # @param [#to_s] table (nil) The qualified name of the table
+#     # @param [#to_s] name (nil) The name of the rule (unique within the table)
+#     # @option options [Boolean] :replace_existing (false) If the rule should overwrite an existing one
+#     # @option options [Symbol] :event (nil) The type of the query the rule is applied to.
+#     #   Supported values: :update, :insert, :delete
+#     # @option options [Symbol] :kind (:also) The kind of the rule (either :also or :instead).
+#     #   In case of `instead` the original query wouldn't be executed, only the `command` is.
+#     # @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 rule
+#     # @return [void]
+#     #
+#     # @notice `SELECT` rules are not supported by the gem.
+#     #
+#     # To create a rule you must define table, and event (operation) for the rule.
+#     # Usually you also supposed to define a command, but in case the `kind` is set
+#     # to `:instead`, missing the command would provide `INSTEAD DO NOTHING` rule.
+#     #
+#     # ```ruby
+#     # create_rule "users" do |r|
+#     #   r.event :insert
+#     #   r.kind :instead
+#     #   r.comment "Forbid insertion to the table"
+#     # SQL
+#     # ```
+#     #
+#     # By default the kind is set to `:also`, in this case the `command` is needed as well:
+#     #
+#     # ```ruby
+#     # create_rule "users", "_count_insertion" do |r|
+#     #   r.event :insert
+#     #   r.command <<~SQL
+#     #     UPDATE counters SET user_inserts = user_inserts + 1
+#     #   SQL
+#     #   r.comment "Count insertion to the table"
+#     # SQL
+#     # ```
+#     #
+#     # With a `when` option you can also specify a condition:
+#     #
+#     # ```ruby
+#     # create_rule "users", "_forbid_grants" do |r|
+#     #   r.event :update
+#     #   r.kind :instead
+#     #   r.where "NOT old.admin AND new.admin"
+#     #   r.comment "Forbid granting admin rights"
+#     # SQL
+#     # ```
+#     #
+#     # With a `replace_existing: true` option,
+#     # the rule will be created using the `CREATE OR REPLACE` clause.
+#     # In this case the migration is irreversible because we
+#     # don't know if and how to restore the previous definition.
+#     #
+#     # ```ruby
+#     # create_rule "users", "_forbid_insertion", replace_existing: true do |r|
+#     #   r.event :insert
+#     #   r.kind :instead
+#     #   r.comment "Forbid insertion to the table"
+#     # SQL
+#     # ```
+#     def create_rule(table, name = nil, **options, &block); end
+#   end
+module PGTrunk::Operations::Rules
+  # @private
+  class CreateRule < Base
+    validates :if_exists, :force, :new_name, absence: true
+    validates :event, presence: true
+    validate do
+      errors.add :command, :blank if kind != :instead && command.blank?
+    end
+
+    from_sql do |_server_version|
+      <<~SQL
+        SELECT
+          r.oid,
+          (c.relnamespace::regnamespace || '.' || c.relname) AS table,
+          r.rulename AS name,
+          (
+            CASE
+            WHEN r.ev_type = '1' THEN 'select'
+            WHEN r.ev_type = '2' THEN 'update'
+            WHEN r.ev_type = '3' THEN 'insert'
+            WHEN r.ev_type = '4' THEN 'delete'
+            END
+          ) AS event,
+          ( CASE WHEN r.is_instead THEN 'instead' ELSE 'also' END ) AS kind,
+          pg_get_expr(r.ev_qual, r.oid, true) AS "where",
+          regexp_replace(
+            regexp_replace(
+              pg_get_ruledef(r.oid, true),
+              '.+ DO +(INSTEAD +)?(ALSO +)?(NOTHING *)?| *;',
+              '',
+              'g'
+            ), '(\n|\s)+', ' ', 'g'
+          ) AS command,
+          d.description AS comment
+        FROM pg_rewrite r
+          JOIN pg_class c ON c.oid = r.ev_class
+          JOIN pg_trunk t ON t.oid = r.oid
+            AND t.classid = 'pg_rewrite'::regclass
+          LEFT JOIN pg_description d ON d.objoid = r.oid
+            AND d.classoid = 'pg_rewrite'::regclass
+      SQL
+    end
+
+    def to_sql(_server_version)
+      [create_rule, *comment_rule, register_rule].join(" ")
+    end
+
+    def invert
+      irreversible!("replace_existing: true") if replace_existing
+      DropRule.new(**to_h)
+    end
+
+    private
+
+    def create_rule
+      sql = "CREATE"
+      sql << " OR REPLACE" if replace_existing
+      sql << " RULE #{name.to_sql} AS ON #{event.to_s.upcase}"
+      sql << " TO #{table.to_sql}"
+      sql << " WHERE #{where}" if where.present?
+      sql << " DO #{kind == :instead ? 'INSTEAD' : 'ALSO'}"
+      sql << " #{command.presence || 'NOTHING'}"
+      sql << ";"
+    end
+
+    def comment_rule
+      <<~SQL.squish if comment.present?
+        COMMENT ON RULE #{name.to_sql} ON #{table.to_sql}#{' '}
+        IS $comment$#{comment}$comment$;
+      SQL
+    end
+
+    def register_rule
+      <<~SQL.squish
+        INSERT INTO pg_trunk (oid, classid)
+          SELECT r.oid, 'pg_rewrite'::regclass
+          FROM pg_rewrite r JOIN pg_class c ON c.oid = r.ev_class
+          WHERE r.rulename = #{name.quoted}
+            AND c.relname = '#{table.name}'
+            AND c.relnamespace = #{table.namespace}
+        ON CONFLICT DO NOTHING;
+      SQL
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: false
+
+# @!parse
+#   class ActiveRecord::Migration
+#     # Drop a rule
+#     #
+#     # @param [#to_s] table (nil) The qualified name of the table
+#     # @param [#to_s] name (nil) The name of the rule (unique within the table)
+#     # @option options [Boolean] :if_exists (false) Suppress the error when the rule is absent.
+#     # @option options [Symbol] :force (:restrict) Define how to process dependent objects
+#     #   Supported values: :restrict (default), :cascade (for cascade deletion)
+#     # @option options [Symbol] :event (nil) The type of the query the rule is applied to.
+#     #   Supported values: :update, :insert, :delete
+#     # @option options [Symbol] :kind (:also) The kind of the rule (either :also or :instead).
+#     #   In case of `instead` the original query wouldn't be executed, only the `command` is.
+#     # @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 rule
+#     # @return [void]
+#     #
+#     # The rule can be identified by the table and explicit name
+#     #
+#     # ```ruby
+#     # drop_rule :users, "_forbid_insertion"
+#     # ```
+#     #
+#     # Alternatively the name can be got from kind and event.
+#     #
+#     # ```ruby
+#     # drop_rule :users do |r|
+#     #   r.event :insert
+#     #   r.kind :instead
+#     #   r.comment "Forbid insertion to the table"
+#     # end
+#     # ```
+#     #
+#     # To made operation reversible all the necessary parameters must be provided
+#     # like in the `create_rule` operation:
+#     #
+#     # ```ruby
+#     # drop_rule "users", "_count_insertion" do |r|
+#     #   r.event :insert
+#     #   r.command <<~SQL
+#     #     UPDATE counters SET user_inserts = user_inserts + 1
+#     #   SQL
+#     #   r.comment "Count insertion to the table"
+#     # SQL
+#     # ```
+#     #
+#     # The operation can be called with `if_exists` option.
+#     #
+#     # ```ruby
+#     # drop_rule :users, if_exists: true do |r|
+#     #   # event and kind here are used to define a name
+#     #   r.event :insert
+#     #   r.kind :instead
+#     # end
+#     # ```
+#     #
+#     # With the `force: :cascade` option the operation would remove
+#     # all the objects that use the rule.
+#     #
+#     # ```ruby
+#     # drop_rule :users, force: :cascade do |r|
+#     #   r.event :insert
+#     #   r.kind :instead
+#     # end
+#     # ```
+#     #
+#     # In both cases the operation becomes irreversible due to
+#     # uncertainty of the previous state of the database.
+#     def drop_rule(table, name = nil, **options, &block); end
+#   end
+module PGTrunk::Operations::Rules
+  # @private
+  class DropRule < Base
+    validates :replace_existing, :new_name, absence: true
+
+    def to_sql(_version)
+      sql = "DROP RULE"
+      sql << " IF EXISTS" if if_exists
+      sql << " #{name.name.inspect} ON #{table.to_sql}"
+      sql << " CASCADE" if force == :cascade
+      sql << ";"
+    end
+
+    def invert
+      irreversible!("if_exists: true") if if_exists
+      irreversible!("force: :cascade") if force == :cascade
+      CreateRule.new(**to_h.except(:force))
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: false
+
+# @!parse
+#   class ActiveRecord::Migration
+#     # Rename a rule
+#     #
+#     # @param [#to_s] table (nil) The qualified name of the table
+#     # @param [#to_s] name (nil) The current name of the rule
+#     # @option options [#to_s] :to (nil) The new name for the rule
+#     # @yield [c] the block with the constraint's definition
+#     # @yieldparam Object receiver of methods specifying the constraint
+#     # @return [void]
+#     #
+#     # A rule can be identified by the table and explicit name
+#     #
+#     # ```ruby
+#     # rename_rule :users, "_forbid_insertion", to: "_skip_insertion"
+#     # ```
+#     #
+#     # Alternatively the name can be got from the event and kind.
+#     #
+#     # ```ruby
+#     # rename_rule :users, to: "_skip_insertion" do |r|
+#     #   r.event :insert
+#     #   r.kind :instead
+#     # end
+#     # ```
+#     #
+#     # The name can be reset to auto-generated when
+#     # the `:to` option is missed or blank:
+#     #
+#     # ```ruby
+#     # rename_rule :users, "_skip_insertion" do |r|
+#     #   r.event :insert
+#     #   r.kind :instead
+#     # end
+#     # ```
+#     #
+#     # The operation is always reversible.
+#     def rename_rule(table, name = nil, **options, &block); end
+#   end
+module PGTrunk::Operations::Rules
+  # @private
+  class RenameRule < Base
+    after_initialize { self.new_name = generated_name if new_name.blank? }
+
+    validates :new_name, presence: true
+    validates :where, :command, :replace_existing, :force, :if_exists,
+              absence: true
+
+    def to_sql(_version)
+      <<~SQL
+        ALTER RULE #{name.to_sql} ON #{table.to_sql}
+        RENAME TO #{new_name.to_sql};
+      SQL
+    end
+
+    def invert
+      self.class.new(**to_h, name: new_name, to: name)
+    end
+  end
+end

data/lib/pg_trunk/operations/rules.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# nodoc
+module PGTrunk::Operations
+  # @private
+  # Namespace for operations with rules
+  module Rules
+    require_relative "rules/base"
+    require_relative "rules/create_rule"
+    require_relative "rules/drop_rule"
+    require_relative "rules/rename_rule"
+  end
+end

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