arfi 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 072f0f4098aec38e2d25e6d3350502930f9be8b0c5b6396545239662c2651570
-  data.tar.gz: 8be6c8f4e5f8a38b381289c8fe127d07c9a23313aa87b24022ddb5457eb9429f
+  metadata.gz: 40e55ca1e1481bb0b4e2c0e52dba409acee9cab6dc52b175c8ea07c43a8ff480
+  data.tar.gz: 54cf735abda9f80045e1d5dd182993fdbe3b9a82f4b1280a5bd0f9ca96664551
 SHA512:
-  metadata.gz: ab81783efb65e023578c70e578248ea267ba3bac815726d9911ced210c139424da8e777160f75c903cdbc45e718d137772109581fe120ef886f73d31cd524f01
-  data.tar.gz: ce0c50d27cce3dedd894106ef50111d13b0424e00e690c2acd731c213863fcbd988d8e2a3fa7265962c58b874a320b3d04c6ab36b815524550c39472eca4b26e
+  metadata.gz: 47e45b99ccccac4149e6fe340b72ff1a418c245fb6f151890d473c2ef18c0ef7d435e0faf95483cafbeee64478db2d1265281dc1fff8a8b32f0a39a9df10caa4
+  data.tar.gz: 6c008777c326d7f15afab77e1a6473ce6a4f94525898e2392d55664ff5d6b4213d2ed5a06050fdfd44a9e8f183cb66278bd17e832b15f4b256591129a73c95eb

data/README.md

@@ -1,28 +1,35 @@
 # ARFI
 
+![Build status](https://img.shields.io/github/actions/workflow/status/unurgunite/arfi/main.yml "Build status")
+[![Gem Version](https://badge.fury.io/rb/arfi.svg)](https://badge.fury.io/rb/arfi)
+
 ![Alt](https://repobeats.axiom.co/api/embed/324b4f481b219890ef5a26e3c6fb73fff8929c93.svg "Repobeats analytics image")
 
 ---
 
 > [!WARNING]
-> This project only supports PostgreSQL databases, however, MySQL usage will also be available in upcoming updates.
-> Since SQLite3 does not support functional indexes with custom functions, support for this database will not be
-> available for a while, however, you can help the project by contributing to the open source.
+> This project only supports PostgreSQL and MySQL databases. SQLite3 will be supported in the future as well as other
+> databases supported by Rails.
 
 > [!NOTE]
-> This project requires Ruby 3.1.0+, it has not yet been tested on other versions, however, at the time of writing,
-> backward compatibility was maintained wherever possible.
+> This project requires Ruby 3.1.0+, in future updated 2.6+ Ruby versions will be supported.
 
 ---
 
 ARFI – *ActiveRecord Functional Indexes*
 
-ARFI gem brings you the ability to create and maintain functional indexes for your ActiveRecord models without
-transition to `structure.sql` (SQL-based schema).
+The ARFI gem provides the ability to create and maintain custom SQL functions for ActiveRecord models without switching
+to `structure.sql` (an SQL-based schema). You can use your own SQL functions in any part of the project, from migrations
+and models to everything else. There is a working example in
+the [demo project](https://github.com/unurgunite/poc_arfi_72). All instructions are described
+in [README](https://github.com/unurgunite/poc_arfi_72/blob/master/README.md). ARFI supports all types of database
+architectures implemented in Rails, suitable for both working with single databases and for simultaneous work with
+multiple databases in the same environment.
 
 * [ARFI](#arfi)
     * [Installation](#installation)
     * [Usage](#usage)
+        * [Internal documentation](#internal-documentation)
         * [CLI](#cli)
         * [Project creation](#project-creation)
         * [Index creation](#index-creation)
@@ -31,6 +38,13 @@ transition to `structure.sql` (SQL-based schema).
     * [Demo](#demo)
     * [Library features](#library-features)
     * [Roadmap](#roadmap)
+    * [Commands](#commands)
+        * [Function creation](#function-creation)
+        * [Function destroy](#function-destroy)
+            * [Options](#options)
+                * [`--template` option](#--template-option)
+                * [`--adapter` option](#--adapter-option)
+    * [Limitations](#limitations)
     * [Development](#development)
         * [Build from source](#build-from-source)
     * [Requirements](#requirements)
@@ -49,6 +63,10 @@ bundle add arfi
 
 ## Usage
 
+### Internal documentation
+
+Internal documentation available at https://github.com/unurgunite/arfi_docs.
+
 ### CLI
 
 ARFI uses Thor as a command line interface (CLI) instead of Rake, so it has a specific DSL.
@@ -56,17 +74,20 @@ ARFI uses Thor as a command line interface (CLI) instead of Rake, so it has a sp
 ### Project creation
 
 Firstly, run `bundle exec arfi project create` to create a new project. This command will create `db/functions`
-directory. ARFI uses `db/functions` directory to store your functional indexes.
+directory. ARFI uses `db/functions` directory to store your SQL functions.
 
-### Index creation
+### Function creation
 
-Run `bundle exec arfi f_idx create function_name` to create a new functional index. New index will be created in
-`db/functions` directory under `function_name_v01.sql` name. Edit you index and run `bundle exec rails db:migrate`. You
-can also use custom template for index. Type `bundle exec arfi f_idx help create` for additional info.
+Run `bundle exec arfi f_idx create function_name` to create a new function. New SQL function will be created in
+`db/functions` directory under `function_name_v01.sql` name. Edit your function and run `bundle exec rails db:migrate`.
+You can also use custom template for functions using `--template` flag, this behaviour is described below.
+Type `bundle exec arfi f_idx help create` for additional info.
 
-### Index destroy
+### Function destroy
 
-If you want to destroy your index, run `bundle exec arfi f_idx destroy function_name [revision (1 by default)]`
+If you want to destroy your function, run `bundle exec arfi f_idx destroy function_name [revision (default 1)]`. Please
+note that after deleting the function, it will still be available, but if you run "bundle exec rails db:migrate" again,
+an error will occur when using the function. Enter `bundle exec arfi f_idx help destroy` for more information.
 
 ### Additional help
 
@@ -79,40 +100,118 @@ README is also available.
 
 ## Library features
 
-1. ARFI supports all types of database initialization
+1. ARFI supports about all types of database initialization. It respects your database schema format and database
+   configuration.
 
-    | Task           | Completed          |
-    |----------------|--------------------|
-    | db:migrate     | :white_check_mark: |
-    | db:setup       | :white_check_mark: |
-    | db:prepare     | :white_check_mark: |
-    | db:schema:load | :white_check_mark: |
+   | Task             | Completed                                                    |
+   |------------------|--------------------------------------------------------------|
+   | db:migrate       | :white_check_mark:                                           |
+   | db:setup         | :white_check_mark:                                           |
+   | db:prepare       | :white_check_mark:                                           |
+   | db:schema:load   | :white_check_mark:                                           |
+   | db:reset         | :white_check_mark:                                           |
+   | db:setup:db_name | In progress (see [limitations][1]) :arrows_counterclockwise: |
 
-2. Database support
+2. Database support. ARFI supports PostgreSQL and MySQL databases and projects with multiple databases at the same time.
 
-    | DB adapter     | Tested                                                |
-    |----------------|-------------------------------------------------------|
-    | PostgreSQL     | 9+ :white_check_mark:                                 |
-    | MySQL          | In progress :arrows_counterclockwise:                 |
-    | SQLite3        | In progress (not primarily) :arrows_counterclockwise: |
+   | DB adapter | Tested                                |
+   |------------|---------------------------------------|
+   | PostgreSQL | :white_check_mark:                    |
+   | MySQL      | :white_check_mark:                    |
+   | SQLite3    | In progress :arrows_counterclockwise: |
 
 3. Rails support
 
    | Rails version | Tested                                |
    |---------------|---------------------------------------|
-   | 8             | In progress :arrows_counterclockwise: |
+   | 8             | :white_check_mark:                    |
    | 7             | :white_check_mark:                    |
    | 6             | In progress :arrows_counterclockwise: |
 
 ## Roadmap
 
 1. ~~Custom template for SQL functions using `--template` flag;~~
-2. Multidb support (Rails 6+ feature);
+2. ~~Multidb support (Rails 6+ feature);~~
 3. Add support for 4+ ActiveRecord;
 4. Add RSpec tests;
-5. Add separate YARD doc page;
-6. Update CI/CD;
-7. Add support for Ruby 2.6+. 
+5. ~~Add separate YARD doc page;~~
+6. ~~Update CI/CD;~~
+7. Add support for Ruby 2.6+.
+
+## Commands
+
+ARFI has a set of commands to work with SQL functions. Type `bundle exec arfi help` for additional help. As noted above,
+ARFI uses Thor as a command line interface.
+
+### Function creation
+
+ARFI supports creation of SQL functions. To create a new function, run `bundle exec arfi f_idx create function_name`.
+Also, there are some options:
+
+| Option name  | Description                                                                          | Possible values            | Default value                                                 |
+|--------------|--------------------------------------------------------------------------------------|----------------------------|---------------------------------------------------------------|
+| `--template` | use custom template                                                                  | path within you filesystem | nil (will be used default template for each type of adapters) |
+| `--adapter`  | adapter specific function creation due to syntax differences between different RDBMS | postgresql, mysql          | nil (function will be stored in generic `db/functions`)       |
+
+### Function destroy
+
+ARFI supports destroy of SQL functions. To destroy a function, run
+`bundle exec arfi f_idx destroy function_name [revision (1 by default)]`.
+
+| Option name  | Description                  | Possible values   | Default value                                              |
+|--------------|------------------------------|-------------------|------------------------------------------------------------|
+| `--revision` | Function revision to destroy | Integer           | 1                                                          |
+| `--adapter`  | adapter specific function    | postgresql, mysql | nil (function will be destroyed in generic `db/functions`) |
+
+#### Options
+
+##### `--template` option
+
+This option is used for creating an SQL function. In this case, the function will not be created with the default
+template, but with user defined. There are some rules for templates:
+
+1. The template must be written in a Ruby-compatible syntax: the function must be placed in a HEREDOC statement and must
+   use interpolation for variables. If you need to take a more comprehensive approach to the issue of function
+   generation, you can try using your own methods in the template file. No matter what you write there, the main rule is
+   that your main method should return a string with a function template, as described below.
+2. ARFI supports dynamic variables in templates, but only one at the moment. You need to specify `index_name`
+   variable as below. In feature updated ARFI will support more variables. Here are default templates in ARFI for
+   PostgreSQL and MySQL:
+
+   PostgreSQL:
+    ```ruby
+    <<~SQL
+      CREATE OR REPLACE FUNCTION #{index_name}() RETURNS TEXT[]
+      LANGUAGE SQL
+      IMMUTABLE AS
+      $$
+        -- Function body here
+      $$
+    SQL
+    ```
+   MySQL:
+    ```ruby
+    <<~SQL
+      CREATE FUNCTION #{index_name} ()
+      RETURNS return_type
+      BEGIN
+        -- Function body here
+      END;
+    SQL
+    ```
+3. By default ARFI uses PostgreSQL template.
+
+##### `--adapter` option
+
+This option is used both when destroying and when creating an SQL function. In this case, the function will not be
+created in the default directory `db/functions`, but in the child `db/functions/#{adapter}`. Supported adapters:
+`postgresql`and `mysql`, but there will be more in the future.
+
+## Limitations
+
+Currently, ARFI has a limitation for `db:setup:db_name` task due to the fact how Rails manage this rake task. More info
+here: [limitations][1]. This command will work, but it is not recommended to use it. Note that this limitation applies
+only to multi-db setup, default `db:setup` will work as expected.
 
 ## Development
 
@@ -126,7 +225,7 @@ git clone https://github.com/unurgunite/arfi.git
 cd arfi
 bundle install
 gem build arfi.gemspec
-gem install arfi-0.3.1.gem
+gem install arfi-0.5.0.gem
 ```
 
 Also, you can run `bin/setup` to automatically install everything needed.
@@ -142,12 +241,15 @@ ARFI is built on top of the following gems:
 | Thor         | For CLI development.                                                                       |
 | Rubocop      | For static code analysis.                                                                  |
 | Rake         | For patching built-in Rails Rake tasks.                                                    |
+| Steep        | For static type checking.                                                                  |
+| RBS          | For static type checking.                                                                  |
+| YARD         | For generating documentation.                                                              |
 
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/unurgunite/arfi. This project is intended to
 be a safe, welcoming space for collaboration, and contributors are expected to adhere to
-the [code of conduct](https://github.com/[USERNAME]/Arfi/blob/master/CODE_OF_CONDUCT.md).
+the [code of conduct](https://github.com/unurgunite/arfi/blob/master/CODE_OF_CONDUCT.md).
 
 ## Miscellaneous
 
@@ -160,4 +262,6 @@ The gem is available as open source under the terms of the [MIT License](https:/
 ## Code of Conduct
 
 Everyone interacting in the ARFI project's codebases, issue trackers, chat rooms and mailing lists is expected to follow
-the [code of conduct](https://github.com/[USERNAME]/Arfi/blob/master/CODE_OF_CONDUCT.md).
+the [code of conduct](https://github.com/unurgunite/arfi/blob/master/CODE_OF_CONDUCT.md).
+
+[1]: https://blog.saeloun.com/2021/10/27/rails-7-adds-database-specific-setup/#limitation

data/Steepfile

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# D = Steep::Diagnostic
+#
+target :lib do
+  signature 'sig'
+  # ignore_signature "sig/test"
+  # use "rbs_collection"
+  check 'lib' # Directory name
+  # check "path/to/source.rb"         # File name
+  # check "app/models/**/*.rb"        # Glob
+  # ignore "lib/templates/*.rb"
+  ignore 'lib/arfi/extensions/active_record/connection_adapters/postgresql/database_statements.rb'
+
+  # library "pathname"              # Standard libraries
+  # library "strong_json"           # Gems
+
+  # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
+  # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
+  # configure_code_diagnostics do |hash|             # You can setup everything yourself
+  #   hash[D::Ruby::NoMethod] = :information
+  # end
+end
+
+# target :test do
+#   unreferenced!                     # Skip type checking the `lib` code when types in `test` target is changed
+#   signature "sig/test"              # Put RBS files for tests under `sig/test`
+#   check "test"                      # Type check Ruby scripts under `test`
+#
+#   configure_code_diagnostics(D::Ruby.lenient)      # Weak type checking for test code
+#
+#   # library "pathname"              # Standard libraries
+# end

data/lib/arfi/cli.rb

@@ -4,13 +4,20 @@ require 'thor'
 require_relative 'commands/project'
 require_relative 'commands/f_idx'
 
+# steep:ignore:start
 module Arfi
   # Top level CLI class
   class CLI < Thor
     desc 'project [COMMAND]', 'Project specific commands.'
     subcommand 'project', Commands::Project
 
-    desc 'f_idx [COMMAND]', 'Command to handle functional indexes.'
+    desc 'f_idx [COMMAND]', 'Command to handle functions.'
     subcommand 'f_idx', Commands::FIdx
+
+    desc 'version', 'Print the version'
+    def version
+      $stdout.write(Arfi::VERSION, "\n")
+    end
   end
 end
+# steep:ignore:end

data/lib/arfi/commands/f_idx.rb

@@ -8,8 +8,18 @@ module Arfi
   module Commands
     # +Arfi::Commands::FIdx+ module contains commands for manipulating functional index in Rails project.
     class FIdx < Thor
-      desc 'create INDEX_NAME', 'Initialize the functional index'
-      option :template, type: :string, banner: 'template_file'
+      ADAPTERS = %i[postgresql mysql].freeze
+
+      # steep:ignore:start
+      desc 'create FUNCTION_NAME [--template=template_file --adapter=adapter]', 'Initialize the functional index'
+      option :template, type: :string, banner: 'template_file',
+                        desc: 'Path to the template file. See `README.md` for details.'
+      option :adapter, type: :string,
+                       desc: 'Specify database adapter, used for projects with multiple database architecture. ' \
+                             "Available adapters: #{ADAPTERS.join(', ')}",
+                       banner: 'adapter'
+      # steep:ignore:end
+
       # +Arfi::Commands::FIdx#create+                        -> void
       #
       # This command is used to create the functional index.
@@ -47,10 +57,18 @@ module Arfi
       def create(index_name)
         validate_schema_format!
         content = build_sql_function(index_name)
-        create_index_file(index_name, content)
+        create_function_file(index_name, content)
       end
 
-      desc 'destroy INDEX_NAME [REVISION]', 'Delete the functional index'
+      # steep:ignore:start
+      desc 'destroy INDEX_NAME [--revision=revision --adapter=adapter]', 'Delete the functional index.'
+      option :revision, type: :string, banner: 'revision', desc: 'Revision of the function.'
+      option :adapter, type: :string,
+                       desc: 'Specify database adapter, used for projects with multiple database architecture. ' \
+                             "Available adapters: #{ADAPTERS.join(', ')}",
+                       banner: 'adapter'
+      # steep:ignore:end
+
       # +Arfi::Commands::FIdx#destroy+                        -> void
       #
       # This command is used to delete the functional index.
@@ -58,30 +76,19 @@ module Arfi
       # @example
       #   bundle exec arfi f_idx destroy some_function [revision index (just an integer, 1 is by default)]
       # @param index_name [String] Name of the index.
-      # @param revision [String] Revision of the index.
       # @return [void]
       # @raise [Arfi::Errors::InvalidSchemaFormat] if ActiveRecord.schema_format is not :ruby
-      def destroy(index_name, revision = '01')
+      def destroy(index_name)
         validate_schema_format!
 
-        revision = "0#{revision}" if revision.match?(/^\d$/)
+        revision = Integer(options[:revision] || '01') # steep:ignore NoMethod
+        revision = "0#{revision}"
         FileUtils.rm("#{functions_dir}/#{index_name}_v#{revision}.sql")
         puts "Deleted: #{functions_dir}/#{index_name}_v#{revision}.sql"
       end
 
       private
 
-      # +Arfi::Commands::FIdx#functions_dir+                        -> Pathname
-      #
-      # Helper method to get path to `db/functions` directory.
-      #
-      # @!visibility private
-      # @private
-      # @return [Pathname] Path to `db/functions` directory
-      def functions_dir
-        Rails.root.join('db/functions')
-      end
-
       # +Arfi::Commands::FIdx#validate_schema_format!+                        -> void
       #
       # Helper method to validate the schema format.
@@ -91,7 +98,7 @@ module Arfi
       # @raise [Arfi::Errors::InvalidSchemaFormat] if ActiveRecord.schema_format is not :ruby.
       # @return [nil] if the schema format is valid.
       def validate_schema_format!
-        raise Arfi::Errors::InvalidSchemaFormat unless ActiveRecord.schema_format == :ruby
+        raise Arfi::Errors::InvalidSchemaFormat unless ActiveRecord.schema_format == :ruby # steep:ignore NoMethod
       end
 
       # +Arfi::Commands::FIdx#build_sql_function+                        -> String
@@ -102,17 +109,43 @@ module Arfi
       # @private
       # @param index_name [String] Name of the index.
       # @return [String] SQL function body.
-      def build_sql_function(index_name)
-        return build_from_file(index_name) if options[:template]
-
-        <<~SQL
-          CREATE OR REPLACE FUNCTION #{index_name}() RETURNS TEXT[]
-              LANGUAGE SQL
-              IMMUTABLE AS
-          $$
+      def build_sql_function(index_name) # rubocop:disable Metrics/MethodLength
+        return build_from_file(index_name) if options[:template] # steep:ignore NoMethod
+
+        unless options[:adapter] # steep:ignore NoMethod
+          return <<~SQL
+            CREATE OR REPLACE FUNCTION #{index_name}() RETURNS TEXT[]
+                LANGUAGE SQL
+                IMMUTABLE AS
+            $$
+                -- Function body here
+            $$
+          SQL
+        end
+
+        case options[:adapter] # steep:ignore NoMethod
+        when 'postgresql'
+          <<~SQL
+            CREATE OR REPLACE FUNCTION #{index_name}() RETURNS TEXT[]
+                LANGUAGE SQL
+                IMMUTABLE AS
+            $$
+                -- Function body here
+            $$
+          SQL
+        when 'mysql'
+          <<~SQL
+            CREATE FUNCTION #{index_name} ()
+            RETURNS return_type
+            BEGIN
               -- Function body here
-          $$
-        SQL
+            END;
+          SQL
+        else
+          # steep:ignore:start
+          raise "Unknown adapter: #{options[:adapter]}. Supported adapters: #{ADAPTERS.join(', ')}"
+          # steep:ignore:end
+        end
       end
 
       # +Arfi::Commands::FIdx#build_from_file+                          -> String
@@ -126,10 +159,12 @@ module Arfi
       # @see Arfi::Commands::FIdx#create
       # @see Arfi::Commands::FIdx#build_sql_function
       def build_from_file(index_name)
+        # steep:ignore:start
         RubyVM::InstructionSequence.compile("index_name = '#{index_name}'; #{File.read(options[:template])}").eval
+        # steep:ignore:end
       end
 
-      # +Arfi::Commands::FIdx#create_index_file+                        -> void
+      # +Arfi::Commands::FIdx#create_function_file+                        -> void
       #
       # Helper method to create the index file.
       #
@@ -138,13 +173,13 @@ module Arfi
       # @param index_name [String] Name of the index.
       # @param content [String] SQL function body.
       # @return [void]
-      def create_index_file(index_name, content)
+      def create_function_file(index_name, content)
         existing_files = Dir.glob("#{functions_dir}/#{index_name}*.sql")
 
         return write_file(index_name, content, 1) if existing_files.empty?
 
         latest_version = extract_latest_version(existing_files)
-        write_file(index_name, content, latest_version.next)
+        write_file(index_name, content, latest_version.succ)
       end
 
       # +Arfi::Commands::FIdx#extract_latest_version+                        -> Integer
@@ -171,14 +206,33 @@ module Arfi
       # @private
       # @param index_name [String] Name of the index.
       # @param content [String] SQL function body.
-      # @param version [Integer] Version of the index.
+      # @param version [String|Integer] Version of the index.
       # @return [void]
       def write_file(index_name, content, version)
         version_str = format('%02d', version)
         path = "#{functions_dir}/#{index_name}_v#{version_str}.sql"
-        File.write(path, content)
+        File.write(path, content.to_s)
         puts "Created: #{path}"
       end
+
+      # +Arfi::Commands::FIdx#functions_dir+                        -> Pathname
+      #
+      # Helper method to get path to `db/functions` directory.
+      #
+      # @!visibility private
+      # @private
+      # @return [Pathname] Path to `db/functions` directory
+      def functions_dir
+        # steep:ignore:start
+        if options[:adapter]
+          raise Arfi::Errors::AdapterNotSupported unless ADAPTERS.include?(options[:adapter].to_sym)
+
+          Rails.root.join("db/functions/#{options[:adapter]}")
+          # steep:ignore:end
+        else
+          Rails.root.join('db/functions')
+        end
+      end
     end
   end
 end

data/lib/arfi/commands/project.rb

@@ -8,7 +8,16 @@ module Arfi
   module Commands
     # +Arfi::Commands::Project+ class is used to create `db/functions` directory.
     class Project < Thor
+      ADAPTERS = %i[postgresql mysql].freeze
+
+      # steep:ignore:start
       desc 'create', 'Initialize project by creating db/functions directory'
+      option :adapter, type: :string,
+                       desc: 'Specify database adapter, used for projects with multiple database architecture. ' \
+                             "Available adapters: #{ADAPTERS.join(', ')}",
+                       banner: 'adapter'
+      # steep:ignore:end
+
       # +Arfi::Commands::Project#create+                 -> void
       #
       # This command is used to create `db/functions` directory.
@@ -18,7 +27,7 @@ module Arfi
       # @return [void]
       # @raise [Arfi::Errors::InvalidSchemaFormat] if ActiveRecord.schema_format is not :ruby.
       def create
-        raise Arfi::Errors::InvalidSchemaFormat unless ActiveRecord.schema_format == :ruby
+        raise Arfi::Errors::InvalidSchemaFormat unless ActiveRecord.schema_format == :ruby # steep:ignore NoMethod
         return puts "Directory #{functions_dir} already exists" if Dir.exist?(functions_dir)
 
         FileUtils.mkdir_p(functions_dir)
@@ -27,7 +36,7 @@ module Arfi
 
       private
 
-      # +Arfi::Commands::Project#functions_dir+ -> Pathname
+      # +Arfi::Commands::Project#functions_dir+          -> Pathname
       #
       # Helper method to get path to `db/functions` directory.
       #
@@ -35,7 +44,15 @@ module Arfi
       # @private
       # @return [Pathname] Path to `db/functions` directory
       def functions_dir
-        Rails.root.join('db/functions')
+        # steep:ignore:start
+        if options[:adapter]
+          raise Arfi::Errors::AdapterNotSupported unless ADAPTERS.include?(options[:adapter].to_sym)
+
+          Rails.root.join("db/functions/#{options[:adapter]}")
+          # steep:ignore:end
+        else
+          Rails.root.join('db/functions')
+        end
       end
     end
   end

data/lib/arfi/extensions/active_record/base.rb

@@ -13,8 +13,24 @@ module ActiveRecord
     #   ActiveRecord::Base.function_exists?('my_function123') #=> false
     # @param [String] function_name The name of the function to check.
     # @return [Boolean] Returns true if the function exists, false otherwise.
-    def self.function_exists?(function_name)
-      connection.execute("SELECT * FROM pg_proc WHERE proname = '#{function_name}'").any?
+    def self.function_exists?(function_name) # rubocop:disable Metrics/MethodLength
+      case connection
+      when ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+        connection.execute("SELECT * FROM pg_proc WHERE proname = '#{function_name}'").any?
+      when ActiveRecord::ConnectionAdapters::Mysql2Adapter
+        sql = <<~SQL
+          SELECT 1
+          FROM information_schema.ROUTINES
+          WHERE ROUTINE_TYPE = 'FUNCTION'
+            AND ROUTINE_SCHEMA = '#{connection.current_database}'
+            AND ROUTINE_NAME = '#{function_name}'
+          LIMIT 1;
+        SQL
+
+        !!connection.execute(sql).first
+      else
+        raise ActiveRecord::AdapterNotFound, "adapter #{connection.class.name} is not supported"
+      end
     end
   end
 end

data/lib/arfi/extensions/active_record/connection_adapters/postgresql/database_statements.rb

@@ -6,6 +6,7 @@ module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module DatabaseStatements
+        # This patch is used for db:prepare task.
         def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
           log(sql, name, async: async) do |notification_payload|
             with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|

data/lib/arfi/railtie.rb

@@ -8,7 +8,7 @@ module Arfi
     railtie_name :arfi
 
     rake_tasks do
-      path = File.expand_path(__dir__)
+      path = File.expand_path(__dir__ || '.')
       Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }
     end
   end