pg_trunk 0.1.0

data/lib/pg_trunk/operations/materialized_views/rename_materialized_view.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#rename_materialized_view(name, **options)
+# Change the name and/or schema of a materialized view
+#
+# @param [#to_s] :name (nil) The qualified name of the view
+# @option [#to_s] :to (nil) The new qualified name for the view
+# @option [Boolean] :if_exists (false) Suppress the error when the view is absent
+#
+# A materialized view can be renamed by changing both the name
+# and the schema (namespace) it belongs to.
+#
+#   rename_materialized_view "views.admin_users", to: "admins"
+#
+# With the `if_exists: true` option, the operation won't fail
+# even when the view wasn't existed.
+#
+#   rename_materialized_view "admin_users",
+#                            to: "admins",
+#                            if_exists: true
+#
+# At the same time, the option makes a migration irreversible
+# due to uncertainty of the previous state of the database.
+
+module PGTrunk::Operations::MaterializedViews
+  # @private
+  class RenameMaterializedView < Base
+    validates :new_name, presence: true
+    validates :algorithm, :cluster_on, :columns, :force, :with_data, :comment,
+              :if_not_exists, :sql_definition, :tablespace, :version,
+              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 MATERIALIZED VIEW"
+      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 MATERIALIZED VIEW"
+      sql << " IF EXISTS" if if_exists
+      sql << " #{moved.to_sql} RENAME TO #{new_name.name.inspect};"
+    end
+  end
+end

data/lib/pg_trunk/operations/materialized_views.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# nodoc
+module PGTrunk::Operations
+  # @private
+  # Namespace for operations with materialized views
+  module MaterializedViews
+    require_relative "materialized_views/column"
+    require_relative "materialized_views/base"
+
+    require_relative "materialized_views/change_materialized_view"
+    require_relative "materialized_views/create_materialized_view"
+    require_relative "materialized_views/drop_materialized_view"
+    require_relative "materialized_views/refresh_materialized_view"
+    require_relative "materialized_views/rename_materialized_view"
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: false
+
+module PGTrunk::Operations::Procedures
+  # @abstract
+  # @private
+  # Base class for operations with procedures
+  class Base < PGTrunk::Operation
+    # All attributes that can be used by procedure-related commands
+    attribute :body, :pg_trunk_multiline_text
+    attribute :language, :pg_trunk_lowercase_string
+    attribute :replace_existing, :boolean
+    attribute :security, :pg_trunk_symbol
+
+    # Ensure correctness of present values
+    validates :security, inclusion: { in: %i[invoker definer] }, allow_nil: true
+    validates :force, :if_not_exists, absence: true
+    validate do
+      errors.add :body, "can't contain SQL injection with $$" if body&.include?("$$")
+    end
+
+    # 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(replace_existing: true) if replace_existing
+
+      s.ruby_line(:language, language.downcase) if language&.!= "sql"
+      s.ruby_line(:security, security) if security&.!= :invoker
+      s.ruby_line(:body, body, from: from_body)
+      s.ruby_line(:comment, comment, from: from_comment)
+    end
+
+    private
+
+    def check_version!(version)
+      raise "Procedures are supported in PostgreSQL v11+" if version < "11"
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#change_procedure(name, **options, &block)
+# Modify a procedure
+#
+# @param [#to_s] name (nil) The qualified name of the procedure
+# @option [Boolean] :if_exists (false) Suppress the error when the procedure is absent
+# @yield [Proc] the block with the procedure's definition
+# @yieldparam The receiver of methods specifying the procedure
+#
+# The operation changes the procedure without dropping it
+# (which is useful when there are other objects
+# using the function and you don't want to change them all).
+#
+# You can change any property except for the name
+# (use `rename_function` instead) and `language`.
+#
+#   change_procedure "metadata.set_foo(a int)" do |p|
+#     p.body <<~SQL
+#       SET foo = a
+#     SQL
+#     p.security :invoker
+#     p.comment "Multiplies 2 integers"
+#   SQL
+#
+# The example above is not invertible because of uncertainty
+# about the previous state of body and comment.
+# To define them, use a from options (available in a block syntax only):
+#
+#   change_procedure "metadata.set_foo(a int)" do |p|
+#     p.body <<~SQL, from: <<~SQL
+#       SET foo = a
+#     SQL
+#       SET foo = -a
+#     SQL
+#     p.comment <<~MSG, from: <<~MSG
+#       Multiplies 2 integers
+#     MSG
+#       Multiplies ints
+#     MSG
+#     p.security :invoker
+#   SQL
+#
+# Like in the other operations, the procedure can be
+# identified by a qualified name (with types of arguments).
+# If it has no overloaded implementations,
+# the plain name is supported as well.
+
+module PGTrunk::Operations::Procedures
+  # @private
+  class ChangeProcedure < Base
+    validates :replace_existing, :language, :new_name, absence: true
+    validate { errors.add :base, "Changes can't be blank" if changes.blank? }
+    validate do
+      next if if_exists || name.blank? || create_procedure.present?
+
+      errors.add :base, "Procedure #{name.lean} can't be found"
+    end
+
+    def to_sql(version)
+      check_version!(version)
+
+      # Use `CREATE OR REPLACE FUNCTION` to make changes
+      create_procedure&.to_sql(version)
+    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(**inversion, name: name)
+    end
+
+    private
+
+    def create_procedure
+      return if name.blank?
+
+      @create_procedure ||= begin
+        list = CreateProcedure.select { |obj| name.maybe_eq?(obj.name) }
+        list.select! { |obj| name == obj.name } if list.size > 1 && name.args
+        list.first&.tap do |op|
+          op.attributes = { **changes, replace_existing: true }
+        end
+      end
+    end
+
+    def changes
+      @changes ||= {
+        body: body.presence,
+        comment: comment,
+        security: security,
+      }.compact
+    end
+
+    def inversion
+      @inversion ||= {
+        body: [body, from_body],
+        comment: [comment, from_comment],
+        security: [security, (%i[invoker definer] - [security]).first],
+      }.slice(*changes.keys).transform_values(&:last)
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#create_procedure(name, **options, &block)
+# Create a procedure
+#
+# @param [#to_s] name (nil)
+#   The qualified name of the procedure with arguments and returned value type
+# @option [Boolean] :replace_existing (false) If the procedure should overwrite an existing one
+# @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
+#
+# The syntax of the operation is the same as for `create_function`,
+# but with only `security` option available. Notice, that
+# procedures cannot return values so you're expected not to
+# define a returned value as well.
+#
+# The procedure can be created either using inline syntax
+#
+#   create_procedure "metadata.set_foo(a int)",
+#                    language: :sql,
+#                    body: "SET foo = a",
+#                    comment: "Sets foo value"
+#
+# or using a block:
+#
+#   create_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
+#
+# With a `replace_existing: true` option,
+# it 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 its previous definition.
+#
+#   create_procedure "set_foo(a int)",
+#                    body: "SET foo = a",
+#                    replace_existing: true
+#
+# A procedure without arguments is supported as well
+#
+#   # the same as "do_something()"
+#   create_procedure "do_something" do |p|
+#     # ...
+#   end
+
+module PGTrunk::Operations::Procedures
+  # @private
+  class CreateProcedure < Base
+    validates :body, presence: true
+    validates :if_exists, :new_name, absence: true
+
+    from_sql do |server_version|
+      # Procedures were added to PostgreSQL in v11
+      next if server_version < "11"
+
+      <<~SQL.squish
+        SELECT
+          p.oid,
+          (
+            p.pronamespace::regnamespace || '.' || p.proname || '(' ||
+            regexp_replace(
+              regexp_replace(
+                pg_get_function_arguments(p.oid), '^\s*IN\s+', '', 'g'
+              ), '[,]\s*IN\s+', ',', 'g'
+            ) || ')'
+          ) AS name,
+          p.prosrc AS body,
+          l.lanname AS language,
+          (
+            CASE
+              WHEN p.prosecdef THEN 'definer'
+              ELSE 'invoker'
+            END
+          ) AS security,
+          d.description AS comment
+        FROM pg_proc p
+          JOIN pg_trunk e ON e.oid = p.oid
+          JOIN pg_language l ON l.oid = p.prolang
+          LEFT JOIN pg_description d ON d.objoid = p.oid
+        WHERE e.classid = 'pg_proc'::regclass
+          AND p.prokind = 'p';
+      SQL
+    end
+
+    def to_sql(version)
+      # Procedures were added to PostgreSQL in v11
+      check_version!(version)
+
+      [create_proc, *comment_proc, register_proc].join(" ")
+    end
+
+    def invert
+      irreversible!("replace_existing: true") if replace_existing
+      DropProcedure.new(**to_h)
+    end
+
+    private
+
+    def create_proc
+      sql = "CREATE"
+      sql << " OR REPLACE" if replace_existing
+      sql << " PROCEDURE #{name.to_sql(true)}"
+      sql << " LANGUAGE #{language&.downcase || 'sql'}"
+      sql << " SECURITY DEFINER" if security == :definer
+      sql << " AS $$#{body}$$;"
+    end
+
+    def comment_proc
+      <<~SQL
+        COMMENT ON PROCEDURE #{name.to_sql(true)}
+        IS $comment$#{comment}$comment$;
+      SQL
+    end
+
+    # Register the most recent `oid` of procedures with this schema/name
+    # There can be several overloaded definitions, but we're interested
+    # in that one we created just now so we can skip checking its args.
+    def register_proc
+      <<~SQL.squish
+        WITH latest AS (
+          SELECT
+            oid,
+            (proname = #{name.quoted} AND pronamespace = #{name.namespace}) AS ok
+          FROM pg_proc
+          WHERE prokind = 'p'
+          ORDER BY oid DESC LIMIT 1
+        )
+        INSERT INTO pg_trunk (oid, classid)
+          SELECT oid, 'pg_proc'::regclass
+          FROM latest
+          WHERE ok
+        ON CONFLICT DO NOTHING;
+      SQL
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# 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.
+
+module PGTrunk::Operations::Procedures
+  # @private
+  class DropProcedure < Base
+    validates :replace_existing, :new_name, absence: true
+
+    def to_sql(version)
+      check_version!(version)
+
+      sql = "DROP PROCEDURE"
+      sql << " IF EXISTS" if if_exists
+      sql << " #{name.to_sql};"
+    end
+
+    def invert
+      irreversible!("if_exists: true") if if_exists
+      CreateProcedure.new(**to_h)
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# 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.
+
+module PGTrunk::Operations::Procedures
+  # @private
+  class RenameProcedure < Base
+    validates :new_name, presence: true
+    validates :body, :if_exists, :replace_existing, :language, :security, absence: true
+
+    def to_sql(version)
+      check_version!(version)
+
+      [*change_schema, *change_name].join("; ")
+    end
+
+    def invert
+      q_new_name = "#{new_name.schema}.#{new_name.routine}(#{name.args}) #{name.returns}"
+      self.class.new(**to_h, name: q_new_name.strip, to: name)
+    end
+
+    private
+
+    def change_schema
+      return if name.schema == new_name.schema
+
+      "ALTER PROCEDURE #{name.to_sql} SET SCHEMA #{new_name.schema.inspect};"
+    end
+
+    def change_name
+      return if new_name.routine == name.routine
+
+      changed_name = name.merge(schema: new_name.schema).to_sql
+      "ALTER PROCEDURE #{changed_name} RENAME TO #{new_name.routine.inspect};"
+    end
+  end
+end

data/lib/pg_trunk/operations/procedures.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# nodoc
+module PGTrunk::Operations
+  # @private
+  # Namespace for operations with procedures
+  module Procedures
+    require_relative "procedures/base"
+    require_relative "procedures/change_procedure"
+    require_relative "procedures/create_procedure"
+    require_relative "procedures/drop_procedure"
+    require_relative "procedures/rename_procedure"
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: false
+
+module PGTrunk::Operations::Statistics
+  # @abstract
+  # @private
+  # Base class for operations with check constraints
+  class Base < PGTrunk::Operation
+    # All attributes that can be used by statistics-related commands
+    attribute :columns, :pg_trunk_array_of_strings, default: []
+    attribute :expressions, :pg_trunk_array_of_strings, default: []
+    attribute :kinds, :pg_trunk_array_of_symbols, default: []
+    attribute :table, :pg_trunk_qualified_name
+
+    # Methods to populate multivariable attributes from a block
+
+    def expression(text)
+      expressions << text.strip
+    end
+
+    def column(name)
+      columns << name.strip
+    end
+
+    # Generate missed name from table & expression
+    after_initialize { self.name ||= generated_name }
+    after_initialize { expressions&.map!(&:strip) }
+
+    # 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
+    validate do
+      next if (kinds - %i[ndistinct dependencies mcv]).none?
+
+      errors.add :kinds, :invalid
+    end
+    validate do
+      next unless columns.blank? && expressions.size == 1
+
+      errors.add :kinds, :present if kinds.present?
+    end
+    validate do
+      next if expressions.present?
+
+      errors.add :base, "Add more columns or expressions" if columns.size == 1
+    end
+
+    # By default foreign keys are sorted by names.
+    # Support `table` only in positional arguments.
+
+    # Snippet to be used in all operations with check constraints
+    ruby_snippet do |s|
+      s.ruby_param(name.lean) if custom_name?
+      s.ruby_param(to: new_name.lean) if new_name.present?
+      s.ruby_param(if_not_exists: true) if if_not_exists
+      s.ruby_param(if_exists: true) if if_exists
+      s.ruby_param(force: :custom) if force == :custom
+
+      s.ruby_line(:table, table.lean) if table.present?
+      if columns.size > 3
+        columns.sort.each { |column| s.ruby_line(:column, column) }
+      elsif columns.present?
+        s.ruby_line(:columns, *columns.sort)
+      end
+      expressions.sort.each { |value| s.ruby_line(:expression, value) }
+      s.ruby_line(:kinds, *kinds.sort) if kinds.present?
+      s.ruby_line(:comment, comment) if comment.present?
+    end
+
+    private
+
+    def generated_name
+      return if table.blank? || parts.blank?
+
+      @generated_name ||= begin
+        key_options = { kinds: kinds, parts: parts }
+        identifier = "#{table.lean}_#{key_options}_stat"
+        hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
+        PGTrunk::QualifiedName.wrap("stat_rails_#{hashed_identifier}")
+      end
+    end
+
+    def custom_name?(qname = name)
+      qname&.differs_from?(/^stat_rails_\w+$/)
+    end
+
+    def parts
+      @parts ||= [
+        *columns.reject(&:blank?).map(&:inspect),
+        *expressions.reject(&:blank?).map { |ex| "(#{ex})" },
+      ]
+    end
+  end
+end