pg_trunk 0.1.0

data/lib/pg_trunk/operations/foreign_keys/drop_foreign_key.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#drop_foreign_key(table, reference, **options, &block)
+# Drops a foreign key constraint
+#
+# @param [#to_s] table (nil) The qualified name of the table
+# @param [#to_s] reference (nil) The qualified name of the reference table
+# @option [#to_s] :name (nil) The current name of the foreign key
+# @option [Boolean] :if_exists (false) Suppress the error when the constraint is absent
+# @option [#to_s] :to (nil) The new name for the foreign key
+# @option [Array<#to_s>] :columns ([]) The list of columns of the table
+# @option [#to_s] :column (nil) An alias for :columns for the case of single-column keys
+# @option [Array<#to_s>] :primary_key ([]) The list of columns of the reference table
+# @option [Symbol] :match (:full) Define how to match rows
+#   Supported values: :full (default), :partial, :simple
+# @option [Symbol] :on_delete (:restrict)
+#   Define how to handle the deletion of the referred row.
+#   Supported values: :restrict (default), :cascade, :nullify, :reset
+# @option [Symbol] :on_update (:restrict)
+#   Define how to handle the update of the referred row.
+#   Supported values: :restrict (default), :cascade, :nullify, :reset
+# @yield [Proc] the block with the key's definition
+# @yieldparam The receiver of methods specifying the foreign key
+#
+# The key can be identified by table/name (not invertible):
+#
+#   drop_foreign_key "users", name: "user_roles_fk"
+#
+# To make it invertible use the same options like
+# in the `add_foreign_key` operation.
+#
+#   drop_foreign_key do |c|
+#     c.table "users"
+#     c.reference "roles"
+#     c.column "role_id"
+#     c.primary_key "id"
+#     c.on_update :cascade
+#     c.on_delete :cascade
+#     c.comment "Phone is 10+ chars long"
+#   end
+#
+# Notice that the name can be skipped, in this case we would
+# find it in the database.
+#
+# The operation can be called with `if_exists` option.
+#
+#   drop_foreign_key "users", name: "user_roles_fk", if_exists: true
+#
+# In this case the operation is always irreversible due to
+# uncertainty of the previous state of the database.
+
+module PGTrunk::Operations::ForeignKeys
+  # @private
+  class DropForeignKey < Base
+    # The name can be looked for in the database.
+    # This is necessary because the name generated by `rails` inside the table
+    # is different from the name generated by the `add_foreign_key`.
+    after_initialize { self.name = current_name if name.blank? }
+    # This prevents a validation error in case there's no fk found in the db
+    # by reference, columns and primary key.
+    after_initialize { self.name = generated_name if if_exists }
+
+    validates :if_not_exists, absence: true
+
+    def to_sql(_version)
+      sql = "ALTER TABLE #{table.to_sql} DROP CONSTRAINT"
+      sql << " IF EXISTS" if if_exists
+      sql << " #{name.lean.inspect};"
+    end
+
+    def invert
+      irreversible!("if_exists: true") if if_exists
+      AddForeignKey.new(**to_h)
+    end
+  end
+end

data/lib/pg_trunk/operations/foreign_keys/rename_foreign_key.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#rename_foreign_key(table, reference, **options, &block)
+# Rename a foreign key
+#
+# @param [#to_s] table (nil) The qualified name of the table
+# @param [#to_s] reference (nil) The qualified name of the reference table
+# @option [#to_s] :name (nil) The current name of the foreign key
+# @option [#to_s] :to (nil) The new name for the foreign key
+# @option [Array<#to_s>] :columns ([]) The list of columns of the table
+# @option [#to_s] :column (nil) An alias for :columns for the case of single-column keys
+# @option [Array<#to_s>] :primary_key ([]) The list of columns of the reference table
+# @yield [Proc] the block with the key's definition
+# @yieldparam The receiver of methods specifying the foreign key
+#
+# You can rename the foreign key constraint identified by its explicit name:
+#
+#   rename_foreign_key :users,
+#                      name: "user_roles_fk",
+#                      to: "constraints.users_by_roles_fk"
+#
+# The key can also be found in the database by table/reference/columns/pk
+#
+#   rename_foreign_key :users, :roles, primary_key: "name", to: "user_roles"
+#
+# If a new name is missed, then the name will be reset to the auto-generated one:
+#
+#   rename_foreign_key :users, "user_roles_fk"
+#
+# The operation is always reversible.
+
+module PGTrunk::Operations::ForeignKeys
+  #
+  # Definition for the `rename_foreign_key` operation
+  #
+  class RenameForeignKey < Base
+    # The name can be looked for in the database.
+    # This is necessary because the name generated by `rails` inside the table
+    # is different from the name generated by the `add_foreign_key`.
+    after_initialize { self.name = current_name if name.blank? }
+    # Reset the name to default when `to:` option is missed or set to `nil`
+    after_initialize { self.new_name = generated_name if new_name.blank? }
+
+    validates :new_name, presence: true
+    validates :if_exists, :if_not_exists, :match, absence: true
+
+    def to_sql(_version)
+      <<~SQL.squish
+        ALTER TABLE #{table.to_sql}
+        RENAME CONSTRAINT #{name.name.inspect}
+        TO #{new_name.name.inspect};
+      SQL
+    end
+
+    def invert
+      self.class.new(
+        **to_h,
+        name: (new_name if custom_name?(new_name)),
+        to: (name if name != current_name),
+      )
+    end
+  end
+end

data/lib/pg_trunk/operations/foreign_keys.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# nodoc
+module PGTrunk::Operations
+  # @private
+  # Definitions for foreign keys
+  #
+  # We overload only add/drop operations to support features
+  # like composite keys along with anonymous key deletion.
+  module ForeignKeys
+    require_relative "foreign_keys/base"
+    require_relative "foreign_keys/add_foreign_key"
+    require_relative "foreign_keys/drop_foreign_key"
+    require_relative "foreign_keys/rename_foreign_key"
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: false
+
+module PGTrunk::Operations::Functions
+  # @abstract
+  # @private
+  # Base class for operations with functions
+  class Base < PGTrunk::Operation
+    # All attributes that can be used by function-related commands
+    attribute :body, :pg_trunk_multiline_text
+    attribute :cost, :float
+    attribute :language, :pg_trunk_lowercase_string
+    attribute :leakproof, :boolean
+    attribute :parallel, :pg_trunk_symbol
+    attribute :replace_existing, :boolean
+    attribute :rows, :integer
+    attribute :security, :pg_trunk_symbol
+    attribute :strict, :boolean
+    attribute :volatility, :pg_trunk_symbol
+    attribute :version, :pg_trunk_multiline_text
+
+    # Ensure correctness of present values
+    validates :if_not_exists, absence: true
+    validates :volatility, inclusion: { in: %i[volatile stable immutable] }, allow_nil: true
+    validates :security, inclusion: { in: %i[invoker definer] }, allow_nil: true
+    validates :parallel, inclusion: { in: %i[safe unsafe] }, allow_nil: true
+    validates :cost, numericality: { greater_than: 0 }, allow_nil: true
+    validates :rows, numericality: { greater_than_or_equal_to: 0 }, allow_nil: 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(force: :cascade) if force == :cascade
+      s.ruby_param(replace_existing: true) if replace_existing
+
+      s.ruby_line(:language, language) if language&.!= "sql"
+      s.ruby_line(:volatility, volatility, from: from_volatility) if volatility.present?
+      s.ruby_line(:leakproof, true) if leakproof
+      s.ruby_line(:strict, true) if strict
+      s.ruby_line(:security, security) if security.present?
+      s.ruby_line(:parallel, parallel, from: from_parallel) unless parallel.nil?
+      s.ruby_line(:cost, cost, from: from_cost) if cost.present?
+      s.ruby_line(:rows, rows, from: from_rows) if rows.present?
+      s.ruby_line(:body, body, from: from_body) if body.present?
+      s.ruby_line(:comment, comment, from: from_comment) if comment
+    end
+  end
+end

data/lib/pg_trunk/operations/functions/change_function.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#change_function(name, **options, &block)
+# Modify a function
+#
+# @param [#to_s] name (nil) The qualified name of the function
+# @option [Boolean] :if_exists (false) Suppress the error when the function is absent
+# @yield [Proc] the block with the function's definition
+# @yieldparam The receiver of methods specifying the function
+#
+# The operation changes the function without dropping it
+# (which can be necessary 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_function "math.mult(int, int)" do |f|
+#     f.volatility :immutable, from: :stable
+#     f.parallel :safe, from: :restricted
+#     f.security :invoker
+#     f.leakproof true
+#     f.strict true
+#     f.cost 5.0
+#     # f.rows 1 (supported for functions returning sets of rows)
+#   SQL
+#
+# The example above is not invertible because of uncertainty
+# about the previous volatility, parallelism, and cost.
+# To define them, use a from options (available in a block syntax only):
+#
+#   change_function "math.mult(a int, b int)" do |f|
+#     f.body <<~SQL, from: <<~SQL
+#       SELECT a * b;
+#     SQL
+#       SELECT min(a * b, 1);
+#     SQL
+#     f.volatility :immutable, from: :volatile
+#     f.parallel :safe, from: :unsafe
+#     f.leakproof true
+#     f.strict true
+#     f.cost 5.0, from: 100.0
+#     # f.rows 1, from: 0
+#   SQL
+#
+# Like in the other operations, the function 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::Functions
+  # @private
+  class ChangeFunction < Base
+    validates :force, :new_name, :language, :replace_existing, absence: true
+    validate { errors.add :base, "Changes can't be blank" if changes.blank? }
+    validate do
+      next if if_exists || name.blank? || create_function.present?
+
+      errors.add :base, "Function #{name.lean} can't be found"
+    end
+
+    def to_sql(server_version)
+      # Use `CREATE OR REPLACE FUNCTION` to make changes
+      create_function&.to_sql(server_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_function
+      return if name.blank?
+
+      @create_function ||= begin
+        list = CreateFunction.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 ||= to_h.except(:name).reject { |_, v| v.nil? || v == "" }
+    end
+
+    def inversion
+      @inversion ||= {
+        body: [body, from_body],
+        volatility: [volatility, from_volatility],
+        parallel: [parallel, from_parallel],
+        cost: [cost, from_cost],
+        rows: [rows, from_rows],
+        comment: [comment, from_comment],
+        security: [security, (security == :invoker ? :definer : :invoker)],
+        leakproof: [leakproof, !leakproof],
+        strict: [strict, !strict],
+      }.slice(*changes.keys).transform_values(&:last)
+    end
+  end
+end

data/lib/pg_trunk/operations/functions/create_function.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#create_function(name, **options, &block)
+# Create a function
+#
+# @param [#to_s] name (nil)
+#   The qualified name of the function with arguments and returned value type
+# @option [Boolean] :replace_existing (false) If the function 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 function
+# @option [Symbol] :volatility (:volatile) The volatility of the function.
+#   Supported values: :volatile (default), :stable, :immutable
+# @option [Symbol] :parallel (:unsafe) The safety of parallel execution.
+#   Supported values: :unsafe (default), :restricted, :safe
+# @option [Symbol] :security (:invoker) Define the role under which the function is invoked
+#   Supported values: :invoker (default), :definer
+# @option [Boolean] :leakproof (false) If the function is leakproof
+# @option [Boolean] :strict (false) If the function is strict
+# @option [Float] :cost (nil) The cost estimation for the function
+# @option [Integer] :rows (nil) The number of rows returned by a function
+# @option [#to_s] :comment The description of the function
+# @yield [Proc] the block with the function's definition
+# @yieldparam The receiver of methods specifying the function
+#
+# The function can be created either using inline syntax
+#
+#   create_function "math.mult(a int, b int) int",
+#                   language: :sql,
+#                   body: "SELECT a * b",
+#                   volatility: :immutable,
+#                   leakproof: true,
+#                   comment: "Multiplies 2 integers"
+#
+# or using a block:
+#
+#   create_function "math.mult(a int, b int) int" do |f|
+#     f.language "sql" # (default)
+#     f.body <<~SQL
+#       SELECT a * b;
+#     SQL
+#     f.volatility :immutable # :stable, :volatile (default)
+#     f.parallel :safe        # :restricted, :unsafe (default)
+#     f.security :invoker     # (default), also :definer
+#     f.leakproof true
+#     f.strict true
+#     f.cost 5.0
+#     # f.rows 1 (supported for functions returning sets of rows)
+#     f.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_function "math.mult(a int, b int) int",
+#                   body: "SELECT a * b",
+#                   replace_existing: true
+#
+# We presume a function without arguments should have
+# no arguments and return `void` like
+#
+#   # the same as "do_something() void"
+#   create_function "do_something" do |f|
+#     # ...
+#   end
+
+module PGTrunk::Operations::Functions
+  # @private
+  class CreateFunction < Base
+    # The definition must be either set explicitly
+    # or by reading the versioned snippet.
+    validate { errors.add :body, :blank if body.blank? && version.blank? }
+    validates :if_exists, :force, :new_name, absence: true
+
+    from_sql do |server_version|
+      plain_function = "NOT p.proisagg AND NOT p.proiswindow"
+      plain_function = "p.prokind = 'f'" 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'
+              )
+            ) || ')' || (
+              CASE
+                WHEN p.prorettype IS NULL THEN ''
+                ELSE ' ' || pg_get_function_result(p.oid)
+              END
+            )
+          ) AS name,
+          p.prosrc AS body,
+          l.lanname AS language,
+          (
+            CASE
+              WHEN p.provolatile = 'i' THEN 'immutable'
+              WHEN p.provolatile = 's' THEN 'stable'
+            END
+          ) AS volatility,
+          ( CASE WHEN p.proleakproof THEN true END ) AS leakproof,
+          ( CASE WHEN p.proisstrict THEN true END ) AS strict,
+          (
+            CASE
+              WHEN p.proparallel = 's' THEN 'safe'
+              WHEN p.proparallel = 'r' THEN 'restricted'
+            END
+          ) AS parallel,
+          ( CASE WHEN p.prosecdef THEN 'definer' END ) AS security,
+          ( CASE WHEN p.procost != 100 THEN p.procost END ) AS cost,
+          ( CASE WHEN p.prorows != 0 THEN p.prorows END ) AS rows,
+          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 #{plain_function};
+      SQL
+    end
+
+    def to_sql(version)
+      [
+        create_function,
+        *comment_function,
+        register_function(version),
+      ].join(" ")
+    end
+
+    def invert
+      irreversible!("replace_existing: true") if replace_existing
+      DropFunction.new(**to_h)
+    end
+
+    private
+
+    def create_function
+      sql = "CREATE"
+      sql << " OR REPLACE" if replace_existing
+      sql << " FUNCTION #{name.to_sql(true)}"
+      sql << " RETURNS #{name.returns}" if name.returns
+      sql << " RETURNS void" if name.returns.blank? && name.args.blank?
+      sql << " LANGUAGE #{language || 'sql'}"
+      sql << " IMMUTABLE" if volatility == :immutable
+      sql << " STABLE" if volatility == :stable
+      sql << " VOLATILE" if volatility.blank? || volatility == :volatile
+      sql << " LEAKPROOF" if leakproof
+      sql << " NOT LEAKPROOF" unless leakproof
+      sql << " STRICT" if strict
+      sql << " CALLED ON NULL INPUT" if strict == false
+      sql << " SECURITY DEFINER" if security == :definer
+      sql << " SECURITY INVOKER" if security == :invoker
+      sql << " PARALLEL SAFE" if parallel == :safe
+      sql << " PARALLEL RESTRICTED" if parallel == :restricted
+      sql << " PARALLEL UNSAFE" if parallel.blank? || parallel == :unsafe
+      sql << " COST #{cost}" if cost
+      sql << " ROWS #{rows}" if rows
+      sql << " AS $$#{body}$$;"
+    end
+
+    def comment_function
+      <<~SQL
+        COMMENT ON FUNCTION #{name.to_sql(true)}
+        IS $comment$#{comment}$comment$;
+      SQL
+    end
+
+    # Register the most recent `oid` of functions 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_function(version)
+      function_only = "NOT proisagg AND NOT proiswindow"
+      function_only = "prokind = 'f'" if version >= "11"
+
+      <<~SQL.squish
+        WITH latest AS (
+          SELECT
+            oid,
+            (
+              proname = #{name.quoted} AND pronamespace = #{name.namespace}
+            ) AS ok
+          FROM pg_proc
+          WHERE #{function_only}
+          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/functions/drop_function.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#drop_function(name, **options, &block)
+# Drop a function
+#
+# @param [#to_s] name (nil)
+#   The qualified name of the function with arguments and returned value type
+# @option [Boolean] :if_exists (false) Suppress the error when the function is absent
+# @option [Symbol] :force (:restrict) How to process dependent objects
+#   Supported values: :restrict (default), :cascade
+# @option [#to_s] :language ("sql") The language (like "sql" or "plpgsql")
+# @option [#to_s] :body (nil) The body of the function
+# @option [Symbol] :volatility (:volatile) The volatility of the function.
+#   Supported values: :volatile (default), :stable, :immutable
+# @option [Symbol] :parallel (:unsafe) The safety of parallel execution.
+#   Supported values: :unsafe (default), :restricted, :safe
+# @option [Symbol] :security (:invoker) Define the role under which the function is invoked
+#   Supported values: :invoker (default), :definer
+# @option [Boolean] :leakproof (false) If the function is leakproof
+# @option [Boolean] :strict (false) If the function is strict
+# @option [Float] :cost (nil) The cost estimation for the function
+# @option [Integer] :rows (nil) The number of rows returned by a function
+# @option [#to_s] :comment The description of the function
+# @yield [Proc] the block with the function's definition
+# @yieldparam The receiver of methods specifying the function
+#
+# A function can be dropped by a plain name:
+#
+#   drop_function "multiply"
+#
+# If several overloaded functions have the name,
+# then you must specify the signature having
+# types of attributes at least:
+#
+#   drop_function "multiply(int, 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_function "math.mult(a int, b int) int" do |f|
+#     f.language "sql" # (default)
+#     f.body <<~SQL
+#       SELECT a * b;
+#     SQL
+#     f.volatility :immutable # :stable, :volatile (default)
+#     f.parallel :safe        # :restricted, :unsafe (default)
+#     f.security :invoker     # (default), also :definer
+#     f.leakproof true
+#     f.strict true
+#     f.cost 5.0
+#     # f.rows 1 (supported for functions returning sets of rows)
+#     f.comment "Multiplies 2 integers"
+#   end
+#
+# The operation can be called with `if_exists` option. In this case
+# it would do nothing when no function existed.
+#
+#   drop_function "math.multiply(integer, integer)", if_exists: true
+#
+# Another operation-specific option `force: :cascade` enables
+# to drop silently any object depending on the function.
+#
+#   drop_function "math.multiply(integer, integer)", force: :cascade
+#
+# Both options make the operation irreversible because of
+# uncertainty about the previous state of the database.
+
+module PGTrunk::Operations::Functions
+  # @private
+  class DropFunction < Base
+    validates :replace_existing, :new_name, absence: true
+
+    def to_sql(_version)
+      sql = "DROP FUNCTION"
+      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
+      CreateFunction.new(**to_h.except(:force))
+    end
+  end
+end

data/lib/pg_trunk/operations/functions/rename_function.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#rename_function(name, to:)
+# Change the name and/or schema of a function
+#
+# @param [#to_s] :name (nil) The qualified name of the function
+# @option [#to_s] :to (nil) The new qualified name for the function
+#
+# A function can be renamed by changing both the name
+# and the schema (namespace) it belongs to.
+#
+# If there are no overloaded functions, then you can use a plain name:
+#
+#   rename_function "math.multiply", to: "public.product"
+#
+# otherwise the types of attributes must be explicitly specified.
+#
+#   rename_function "math.multiply(int, int)", to: "public.product"
+#
+# Any specification of attributes or returned values in `to:` option
+# is ignored because they cannot be changed anyway.
+#
+# The operation is always reversible.
+
+module PGTrunk::Operations::Functions
+  # @private
+  class RenameFunction < Base
+    validates :new_name, presence: true
+    validates :body, :cost, :force, :if_exists, :language, :leakproof,
+              :parallel, :replace_existing, :rows, :security, :strict,
+              :volatility, absence: true
+
+    def to_sql(_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 FUNCTION #{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 FUNCTION #{changed_name} RENAME TO #{new_name.routine.inspect};"
+    end
+  end
+end

data/lib/pg_trunk/operations/functions.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# nodoc
+module PGTrunk::Operations
+  # @private
+  # Namespace for operations with functions
+  module Functions
+    require_relative "functions/base"
+    require_relative "functions/create_function"
+    require_relative "functions/change_function"
+    require_relative "functions/drop_function"
+    require_relative "functions/rename_function"
+  end
+end