torque-postgresql 4.0.0.rc1 → 4.0.0

data/lib/torque/postgresql/versioned_commands/migration_context.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    class IllegalCommandTypeError < ActiveRecord::MigrationError
+      def initialize(file)
+        super(<<~MSG.squish)
+          Illegal name for command file '#{file}'. Commands are more strict and require
+          the version, one of create, update, or remove, type of object, name
+          and operation version to be present in the filename.
+          (e.g. 20250101010101_create_function_my_function_v1.sql)
+        MSG
+      end
+    end
+
+    module VersionedCommands
+      module MigrationContext
+        InvalidMigrationTimestampError = ActiveRecord::InvalidMigrationTimestampError
+        PGAdapter = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+
+        def migrations
+          return super unless running_for_pg?
+
+          commands = command_files.map do |file|
+            version, op, type, name, op_version, scope = parse_command_filename(file)
+            raise IllegalCommandTypeError.new(file) unless version
+            if validate_timestamp? && !valid_migration_timestamp?(version)
+              raise InvalidMigrationTimestampError.new(version, [op, type, name, op_version].join('_'))
+            end
+
+            version = version.to_i
+            CommandMigration.new(file, version, op, type, name, op_version.to_i, scope)
+          end
+
+          super.concat(commands).sort_by(&:version)
+        end
+
+        def migrations_status
+          return super unless running_for_pg?
+          db_list = schema_migration.normalized_versions
+
+          commands = command_files.map do |file|
+            version, op, type, name, op_version, scope = parse_command_filename(file)
+            raise IllegalCommandTypeError.new(file) unless version
+            if validate_timestamp? && !valid_migration_timestamp?(version)
+              raise InvalidMigrationTimestampError.new(version, [op, type, name, op_version].join('_'))
+            end
+
+            version = schema_migration.normalize_migration_number(version)
+            status = db_list.delete(version) ? "up" : "down"
+            [status, version, "#{op.capitalize} #{type.capitalize} #{name}#{scope} (v#{op_version})"]
+          end
+
+          (commands + super).uniq(&:second).sort_by(&:second)
+        end
+
+        def migration_commands
+          migrations.select { |m| m.is_a?(VersionedCommands::CommandMigration) }
+        end
+
+        private
+
+          # Checks if the current migration context is running for PostgreSQL
+          def running_for_pg?
+            connection_pool.db_config.adapter_class <= PGAdapter
+          end
+
+          # Get the list of all versioned command files
+          def command_files
+            paths = Array(migrations_paths)
+            Dir[*paths.flat_map { |path| "#{path}/**/[0-9]*_*.sql" }]
+          end
+
+          # Commands are more strict with the filename format
+          def parse_command_filename(filename)
+            File.basename(filename).scan(VersionedCommands.filename_regexp).first
+          end
+      end
+
+      ActiveRecord::MigrationContext.prepend(MigrationContext)
+    end
+  end
+end

data/lib/torque/postgresql/versioned_commands/migrator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module VersionedCommands
+      module Migrator
+        def execute_migration_in_transaction(migration)
+          @versioned_command = versioned_command?(migration) && migration
+          super
+        ensure
+          @versioned_command = false
+        end
+
+        def record_version_state_after_migrating(version)
+          return super if (command = @versioned_command) == false
+
+          @versioned_table ||= VersionedCommands::SchemaTable.new(connection.pool)
+          @versioned_counter ||= @versioned_table.count
+
+          if down?
+            @versioned_counter -= 1
+            @versioned_table.delete_version(command)
+            @versioned_table.drop_table if @versioned_counter.zero?
+          else
+            @versioned_table.create_table if @versioned_counter.zero?
+            @versioned_table.create_version(command)
+            @versioned_counter += 1
+          end
+        end
+
+        def versioned_command?(migration)
+          migration.is_a?(VersionedCommands::CommandMigration)
+        end
+      end
+
+      ActiveRecord::Migrator.prepend(Migrator)
+    end
+  end
+end

data/lib/torque/postgresql/versioned_commands/schema_table.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module VersionedCommands
+      class SchemaTable
+        attr_reader :arel_table
+
+        def initialize(pool)
+          @pool = pool
+          @arel_table = ::Arel::Table.new(table_name)
+        end
+
+        def create_version(command)
+          im = ::Arel::InsertManager.new(arel_table)
+          im.insert(
+            arel_table[primary_key] => command.version,
+            arel_table['type'] => command.type,
+            arel_table['object_name'] => command.object_name,
+          )
+
+          @pool.with_connection do |connection|
+            connection.insert(im, "#{name} Create", primary_key, command.version)
+          end
+        end
+
+        def delete_version(command)
+          dm = ::Arel::DeleteManager.new(arel_table)
+          dm.wheres = [arel_table[primary_key].eq(command.version.to_s)]
+
+          @pool.with_connection do |connection|
+            connection.delete(dm, "#{name} Destroy")
+          end
+        end
+
+        def primary_key
+          'version'
+        end
+
+        def name
+          'Torque::PostgreSQL::VersionedCommand'
+        end
+
+        def table_name
+          [
+            ActiveRecord::Base.table_name_prefix,
+            PostgreSQL.config.versioned_commands.table_name,
+            ActiveRecord::Base.table_name_suffix,
+          ].join
+        end
+
+        def create_table
+          @pool.with_connection do |connection|
+            return if connection.table_exists?(table_name)
+
+            parent = @pool.schema_migration.table_name
+            connection.create_table(table_name, inherits: parent) do |t|
+              t.string :type, null: false, index: true
+              t.string :object_name, null: false, index: true
+            end
+          end
+        end
+
+        def drop_table
+          @pool.with_connection do |connection|
+            connection.drop_table table_name, if_exists: true
+          end
+        end
+
+        def count
+          return 0 unless table_exists?
+
+          sm = ::Arel::SelectManager.new(arel_table)
+          sm.project(*FN.count(::Arel.star))
+
+          @pool.with_connection do |connection|
+            connection.select_value(sm, "#{self.class} Count")
+          end
+        end
+
+        def table_exists?
+          @pool.with_connection { |connection| connection.data_source_exists?(table_name) }
+        end
+
+        def versions_of(type)
+          return [] unless table_exists?
+
+          sm = ::Arel::SelectManager.new(arel_table)
+          sm.project(arel_table['object_name'], FN.count(::Arel.star).as('version'))
+          sm.where(arel_table['type'].eq(type.to_s))
+          sm.group(arel_table['object_name'])
+          sm.order(arel_table['object_name'].asc)
+
+          @pool.with_connection do |connection|
+            connection.select_rows(sm, "#{name} Load")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/versioned_commands.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative 'versioned_commands/command_migration'
+require_relative 'versioned_commands/migration_context'
+require_relative 'versioned_commands/migrator'
+require_relative 'versioned_commands/schema_table'
+
+module Torque
+  module PostgreSQL
+    # Takes advantage of Rails migrations to create other sorts of
+    # objects/commands that can also be versioned. Everything migrated will
+    # still live within Migrations borders (i.e., the schema_migrations), but
+    # the way they are handled and registered in the schema dumper is completely
+    # different
+    module VersionedCommands
+      RAILS_APP = defined?(Rails.application.paths)
+      NAME_MATCH = '"?((?:[_a-z0-9]+"?\."?)?[_a-z0-9]+)"?'
+
+      class << self
+        # Check if the type is current enabled
+        def valid_type?(type)
+          PostgreSQL.config.versioned_commands.types.include?(type.to_sym)
+        end
+
+        # Run the internal validations for the given type and content
+        def validate!(type, content, name)
+          method_name = :"validate_#{type}!"
+          return send(method_name, content, name) if valid_type?(type)
+          raise ArgumentError, "Unknown versioned command type: #{type}"
+        end
+
+        # Get the content of the command based on the type, name, and version
+        def fetch_command(dirs, type, name, version)
+          paths = Array.wrap(dirs).map { |d| "#{d}/**/*_#{type}_#{name}_v#{version}.sql" }
+          files = Dir[*paths]
+          return File.read(files.first) if files.one?
+
+          raise ArgumentError, <<~MSG.squish if files.none?
+            No previous version found for #{type} #{name}
+            of version v#{version}.
+          MSG
+
+          raise ArgumentError, <<~MSG.squish if files.many?
+            Multiple files found for #{type} #{name}
+            of version v#{version}.
+          MSG
+        end
+
+        # The regexp is dynamic due to the list of available types
+        def filename_regexp
+          @filename_regexp ||= begin
+            types = PostgreSQL.config.versioned_commands.types
+            Regexp.new([
+              "\\A([0-9]+)_",
+              "(create|update|remove)_",
+              "(#{types.join('|')})_",
+              "([_a-z0-9]*)",
+              "_v([0-9]+)",
+              "\\.?([_a-z0-9]*)?",
+              "\\.sql\\z",
+            ].join)
+          end
+        end
+
+        private
+
+          # Validate that the content of the command is correct
+          def validate_function!(content, name)
+            result = content.scan(Regexp.new([
+              '^\s*CREATE\s+(OR\s+REPLACE)?\s*',
+              "FUNCTION\\s+#{NAME_MATCH}",
+            ].join, 'mi'))
+
+            names = result.map(&:last).compact.uniq(&:downcase)
+            raise ArgumentError, <<~MSG.squish if names.size > 1
+              Multiple functions definition found.
+            MSG
+
+            raise ArgumentError, <<~MSG.squish unless result.all?(&:first)
+              'OR REPLACE' is required for proper migration support.
+            MSG
+
+            fn_name = names.first.downcase.sub('.', '_')
+            raise ArgumentError, <<~MSG.squish if fn_name != name.downcase
+              Function name must match file name.
+            MSG
+          end
+
+          # Validate that the content of the command is correct
+          def validate_type!(content, name)
+            creates = content.scan(Regexp.new(['^\s*CREATE\s+TYPE\s+', NAME_MATCH].join, 'mi'))
+            drops = content.scan(Regexp.new([
+              '^\s*DROP\s+TYPE\s+(IF\s+EXISTS)?\s*',
+              NAME_MATCH,
+            ].join, 'mi'))
+
+            raise ArgumentError, <<~MSG.squish if creates.size > 1
+              More than one type definition found.
+            MSG
+
+            raise ArgumentError, <<~MSG.squish if drops.size > 1
+              More than one type drop found.
+            MSG
+
+            raise ArgumentError, <<~MSG.squish if drops.empty?
+              'DROP TYPE' is required for proper migration support.
+            MSG
+
+            create_name = creates.first.last.downcase
+            raise ArgumentError, <<~MSG.squish if drops.first.last.downcase != create_name
+              Drop does not match create.
+            MSG
+
+            create_name = create_name.sub('.', '_')
+            raise ArgumentError, <<~MSG.squish if create_name != name.downcase
+              Type name must match file name.
+            MSG
+          end
+
+          # Validate that the content of the command is correct
+          def validate_view!(content, name)
+            result = content.scan(Regexp.new([
+              '^\s*CREATE\s+(OR\s+REPLACE)?\s*',
+              '((?:TEMP|TEMPORARY|MATERIALIZED)\s+)?',
+              '(?:RECURSIVE\s+)?',
+              "VIEW\\s+#{NAME_MATCH}",
+            ].join, 'mi'))
+
+            raise ArgumentError, <<~MSG.squish if result.empty?
+              Missing or invalid view definition.
+            MSG
+
+            raise ArgumentError, <<~MSG.squish if result.size > 1
+              More than one view definition found.
+            MSG
+
+            with_replace, opt, view_name = result.first
+            if opt&.strip == 'MATERIALIZED'
+              raise ArgumentError, <<~MSG.squish if with_replace.present?
+                Materialized view does not support 'OR REPLACE'.
+              MSG
+
+              with_drop = "DROP MATERIALIZED VIEW IF EXISTS #{view_name};"
+              raise ArgumentError, <<~MSG.squish unless content.include?(with_drop)
+                'DROP MATERIALIZED VIEW IF EXISTS' is required for proper migration support.
+              MSG
+            else
+              raise ArgumentError, <<~MSG.squish if with_replace.blank?
+                'OR REPLACE' is required for proper migration support.
+              MSG
+            end
+
+            view_name = view_name.downcase.sub('.', '_')
+            raise ArgumentError, <<~MSG.squish if view_name != name.downcase
+              View name must match file name.
+            MSG
+          end
+      end
+    end
+  end
+end

data/spec/initialize.rb

@@ -16,6 +16,10 @@ require_relative '../lib/torque/postgresql/attributes/period'
 require_relative '../lib/torque/postgresql/attributes/full_text_search'
 
 require_relative '../lib/torque/postgresql/relation/auxiliary_statement'
+require_relative '../lib/torque/postgresql/relation/join_series'
+require_relative '../lib/torque/postgresql/relation/buckets'
+
+require_relative '../lib/torque/postgresql/versioned_commands'
 
 module Torque
   module PostgreSQL
@@ -27,6 +31,11 @@ module Torque
     Attributes::FullTextSearch.include_on(ActiveRecord::Base)
 
     Relation.include(Relation::AuxiliaryStatement)
+    Relation.include(Relation::JoinSeries)
+    Relation.include(Relation::Buckets)
+
+    config.versioned_commands.enabled = true
+    ActiveRecord::Schema::Definition.include(Adapter::Definition)
 
     ::Object.const_set('TorqueCTE', AuxiliaryStatement)
     ::Object.const_set('TorqueRecursiveCTE', AuxiliaryStatement::Recursive)

data/spec/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-version = 5
+version = 6
 
 return if ActiveRecord::Migrator.current_version == version
 ActiveRecord::Schema.define(version: version) do
@@ -127,6 +127,7 @@ ActiveRecord::Schema.define(version: version) do
   create_table "users", force: :cascade do |t|
     t.string   "name", null: false
     t.enum     "role", enum_type: :roles, default: :visitor
+    t.integer  "age"
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
   end
@@ -176,9 +177,6 @@ ActiveRecord::Schema.define(version: version) do
   # create_table "activity_images", force: :cascade, inherits: [:activities, :images]
 
   add_foreign_key "posts", "authors"
-rescue Exception => e
-  byebug
-  raise
 end
 
 ActiveRecord::Base.connection.schema_cache.clear!

data/spec/spec_helper.rb

@@ -4,7 +4,12 @@ require 'factory_bot'
 require 'dotenv'
 require 'faker'
 require 'rspec'
-require 'byebug'
+
+begin
+  require 'debug/prelude'
+rescue LoadError
+  # No debugger available, skip
+end
 
 Dotenv.load
 

data/spec/tests/full_text_seach_test.rb

@@ -215,14 +215,30 @@ RSpec.describe 'FullTextSearch' do
       expect(result.to_sql).to eql(parts)
     end
 
-    it 'can use regular query mode' do
-      result = Course.full_text_search('test', phrase: false)
+    it 'can use default query mode' do
+      result = Course.full_text_search('test', mode: :default)
       parts = 'SELECT "courses".* FROM "courses"'
       parts << ' WHERE "courses"."search_vector" @@'
       parts << " TO_TSQUERY('english', 'test')"
       expect(result.to_sql).to eql(parts)
     end
 
+    it 'can use plain query mode' do
+      result = Course.full_text_search('test', mode: :plain)
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << " PLAINTO_TSQUERY('english', 'test')"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can use web query mode' do
+      result = Course.full_text_search('test', mode: :web)
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << " WEBSEARCH_TO_TSQUERY('english', 'test')"
+      expect(result.to_sql).to eql(parts)
+    end
+
     it 'can use a attribute as the language' do
       result = Course.full_text_search('test', language: :lang)
       parts = 'SELECT "courses".* FROM "courses"'
@@ -248,5 +264,17 @@ RSpec.describe 'FullTextSearch' do
       expect(binds.first.value).to eq('english')
       expect(binds.second.value).to eq('test')
     end
+
+    it 'raises an error when the language is not found' do
+      expect do
+        Course.full_text_search('test', language: '')
+      end.to raise_error(ArgumentError, /Unable to determine language/)
+    end
+
+    it 'raises an error when the mode is invalid' do
+      expect do
+        Course.full_text_search('test', mode: :invalid)
+      end.to raise_error(ArgumentError, /Invalid mode :invalid for full text search/)
+    end
   end
 end