activerecord-full_text_search 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0e395c41810e9e42ae30e3f2aca5527fe80666fd52dcfdd9913b3501b6e97f0
-  data.tar.gz: dab379e41ed0fe39a5f90e3dc42b99337d5dbf441e6e8b1b10eae93ab6f202c9
+  metadata.gz: 5bccc63fac75881da6efbc80e1281588f0091d6e227d11fd8335623366f720dd
+  data.tar.gz: 36440ad1275656da894a59ad1afb8f908e4fafb2070232f302161a2994a756b8
 SHA512:
-  metadata.gz: 51fc2b15b2016a7030c4fbd63c0cf0065453c1cff0d4a50007d8870e556cf8e4098008f7077a76b85c41124d865cda4e4fda3d9f0acdc38d8dbb4b7c951f32ba
-  data.tar.gz: e97e619209f362b9412ad7df74b0511f3f99b557dd1085cd8b7508ae4ee369b74e2e8f5a7ea2c4c8191ab3253ecd4432ee8c25b0c2f5d14d295c344b206198bf
+  metadata.gz: 6d75a6e9c06fd2e609ebf27b4a041fff217b1f3207cbabab342da4011a06c7293bc84888483b063c9618b86fd6eb86af6ad2e91f760807a15a10450246657758
+  data.tar.gz: 7ab9fbaef688c03932c72661e60f74e9b4593bf5388f0b5a8727386a4408e16fcaf750f1603b609a67dce2f8b54314bad81f13b634de020e2cd6fe504ba5afec

data/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-06-02
+
+- Add Rails 8.0 & 8.1 as known versions
+- Sort functions and triggers
+
+## [0.2.0] - 2024-12-03
+
+- Add basic support for TRIGGERS
+
 ## [0.1.0] - 2024-11-28
 
 ### Added

data/README.md

@@ -10,6 +10,8 @@ The gem permits to use these commands:
 
 - `create_function`
 - `drop_function`
+- `create_trigger`
+- `drop_trigger`
 - `create_text_search_template`
 - `rename_text_search_template`
 - `drop_text_search_template`
@@ -31,6 +33,10 @@ The gem permits to use these commands:
 
 - Add tests
 - Enhance (and extract?) functions support
+- Enhance (and extract?) triggers support
+- Support triggers with parameterized functions
+- Support `UPDATE OF columns` in triggers
+- Support `TRUNCATE` in triggers
 - Check recorder
 - Manage schema (`public` is hardcoded)
 

data/lib/active_record/full_text_search/7.2/postgresql_adapter.rb

@@ -15,15 +15,44 @@ module ActiveRecord
       def functions
         # List of functions in the current schema with their argument types, return type, language,  immutability, and body.
         # List only functions that don't depend on extensions.
+        # Functions are ordered by dependency depth (via pg_depend) so that dependencies come first.
         res = exec_query(<<-SQL.strip_heredoc, "SCHEMA")
+          WITH RECURSIVE
+            func_deps AS (
+              SELECT p.oid AS func_oid, dep_p.oid AS dep_func_oid
+              FROM pg_catalog.pg_proc p
+              JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
+              JOIN pg_catalog.pg_depend fd ON fd.objid = p.oid AND fd.deptype = 'n'
+              JOIN pg_catalog.pg_proc dep_p ON dep_p.oid = fd.refobjid
+              JOIN pg_catalog.pg_namespace dep_n ON dep_n.oid = dep_p.pronamespace
+              WHERE n.nspname = ANY (current_schemas(false))
+                AND dep_n.nspname = ANY (current_schemas(false))
+                AND p.oid != dep_p.oid
+            ),
+            levels(oid, level) AS (
+              SELECT p.oid, 0
+              FROM pg_catalog.pg_proc p
+              JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
+              WHERE n.nspname = ANY (current_schemas(false))
+                AND p.oid NOT IN (SELECT func_oid FROM func_deps)
+              UNION ALL
+              SELECT fd.func_oid, l.level + 1
+              FROM func_deps fd
+              JOIN levels l ON l.oid = fd.dep_func_oid
+            ),
+            max_levels AS (
+              SELECT oid, MAX(level) AS level FROM levels GROUP BY oid
+            )
           SELECT proname, pg_catalog.pg_get_function_arguments(p.oid) AS argtypes, pg_catalog.pg_get_function_result(p.oid) AS rettype, lanname, provolatile, prosrc
           FROM pg_catalog.pg_proc p
-          JOIN pg_catalog.pg_namespace n ON n.oid = pronamespace
-          JOIN pg_catalog.pg_language l ON l.oid = prolang
+          JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
+          JOIN pg_catalog.pg_language l ON l.oid = p.prolang
           LEFT JOIN pg_catalog.pg_depend d ON d.objid = p.oid AND d.deptype = 'e'
           LEFT JOIN pg_catalog.pg_extension e ON e.oid = d.refobjid
+          JOIN max_levels ml ON ml.oid = p.oid
           WHERE n.nspname = ANY (current_schemas(false))
-            AND e.extname IS NULL;
+            AND e.extname IS NULL
+          ORDER BY ml.level, proname;
         SQL
 
         res.rows.each_with_object({}) do |(name, args, ret, lang, vol, src), memo|
@@ -31,6 +60,49 @@ module ActiveRecord
         end
       end
 
+      # See https://github.com/postgres/postgres/blob/master/src/include/commands/trigger.h
+      # and https://stackoverflow.com/questions/23634550/meanings-of-bits-in-trigger-type-field-tgtype-of-postgres-pg-trigger
+      def triggers
+        # List of triggers in the current schema with name, table name, function, timing, op, for each, condition, deferrable, initially_deferred.
+        res = exec_query(<<-SQL.strip_heredoc, "SCHEMA")
+          SELECT tgname, c.relname, proname,
+            COALESCE(
+              CASE WHEN (tgtype::int::bit(7) & b'0000010')::int = 0 THEN NULL ELSE 'before' END,
+              CASE WHEN (tgtype::int::bit(7) & b'0000010')::int = 0 THEN 'after' ELSE NULL END,
+              CASE WHEN (tgtype::int::bit(7) & b'1000000')::int = 0 THEN NULL ELSE 'instead_of' END,
+              ''
+            ) as tg_timing,
+            (CASE WHEN (tgtype::int::bit(7) & b'0000100')::int = 0 THEN '' ELSE ' insert' END)
+            || (CASE WHEN (tgtype::int::bit(7) & b'0001000')::int = 0 THEN '' ELSE ' delete' END)
+            || (CASE WHEN (tgtype::int::bit(7) & b'0010000')::int = 0 THEN '' ELSE ' update' END)
+            -- || (CASE WHEN (tgtype::int::bit(7) & b'0100000')::int = 0 THEN '' ELSE ' truncate' END)
+            AS tg_ops,
+            CASE WHEN (tgtype::int::bit(7) & b'0000001')::int = 0 THEN 'statement' ELSE 'row' END as tg_foreach,
+            pg_get_triggerdef(t.oid, true) AS tg_definition,
+            tgdeferrable,
+            tginitdeferred
+          FROM pg_catalog.pg_trigger t
+          JOIN pg_catalog.pg_class c ON c.oid = tgrelid
+          JOIN pg_catalog.pg_proc f ON f.oid = t.tgfoid
+          JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+          LEFT JOIN pg_catalog.pg_depend d ON d.objid = t.oid AND d.deptype = 'e'
+          LEFT JOIN pg_catalog.pg_extension e ON e.oid = d.refobjid
+          WHERE n.nspname = ANY (current_schemas(false))
+            AND tgisinternal = FALSE
+            AND e.extname IS NULL
+          ORDER BY c.relname, tgname;
+        SQL
+
+        res.rows.each_with_object({}) do |(name, table, function, timing, ops, for_each, definition, deferrable, initially_deferred), memo|
+          attributes = {table: table, function: function, for_each: for_each.to_sym}
+          condition = extract_trigger_condition(definition)
+          attributes[:when] = condition if condition.present?
+          attributes[timing.to_sym] = ops.strip.split(/\s+/).map(&:to_sym)
+          attributes[:deferrable] = initially_deferred ? :initially_deferred : true if deferrable
+          memo[name] = attributes
+        end
+      end
+
       def text_search_parsers
         res = exec_query(<<-SQL.strip_heredoc, "SCHEMA")
           SELECT prsname, prsstart::VARCHAR, prstoken::VARCHAR, prsend::VARCHAR, prsheadline::VARCHAR, prslextype::VARCHAR
@@ -109,6 +181,12 @@ module ActiveRecord
 
       private
 
+      def extract_trigger_condition(definition)
+        return unless definition
+
+        definition[/\bWHEN\s*\((.*)\)\s+EXECUTE\s+FUNCTION\b/m, 1]
+      end
+
       def options_to_hash(text)
         text.split(/\s*,\s*/).map { |s| s.strip.split(/\s+=\s+/) }.to_h.transform_values { |v| v[1..-2] }.transform_keys(&:to_sym)
       end

data/lib/active_record/full_text_search/7.2/schema_dumper.rb

@@ -17,6 +17,11 @@ module ActiveRecord
         text_search_configurations(stream)
       end
 
+      def tables(stream)
+        super
+        triggers(stream)
+      end
+
       def functions(stream)
         return unless (functions = @connection.functions).any?
 
@@ -33,6 +38,22 @@ module ActiveRecord
         stream.puts
       end
 
+      def triggers(stream)
+        return unless (triggers = @connection.triggers).any?
+
+        stream.puts
+        stream.puts "  # These are triggers that must be created in order to support this database"
+
+        triggers.each do |name, definition|
+          definition[:name] = name if include_trigger_name_in_dump?(definition)
+          table = definition.delete(:table)
+          function = definition.delete(:function)
+          stream.puts %(  create_trigger #{table.inspect}, #{function.inspect}, #{hash_to_string(definition)})
+        end
+
+        # stream.puts
+      end
+
       def text_search_parsers(stream)
         return unless (parsers = @connection.text_search_parsers).any?
 
@@ -88,6 +109,10 @@ module ActiveRecord
 
       private
 
+      def include_trigger_name_in_dump?(trigger_definition)
+        trigger_definition[:name] !=~ /\Atg_rails_/
+      end
+
       def hash_to_string(hash)
         hash.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
       end

data/lib/active_record/full_text_search/command_recorder.rb

@@ -30,6 +30,14 @@ module ActiveRecord
         record(:drop_function, args, &block)
       end
 
+      def create_trigger(*args, &block)
+        record(:create_trigger, args, &block)
+      end
+
+      def drop_trigger(*args, &block)
+        record(:drop_trigger, args, &block)
+      end
+
       def create_text_search_configuration(*args, &block)
         record(:create_text_search_configuration, args, &block)
       end
@@ -108,6 +116,14 @@ module ActiveRecord
         [:create_function, args]
       end
 
+      def invert_create_trigger(args)
+        [:drop_trigger, args]
+      end
+
+      def invert_drop_trigger(args)
+        [:create_trigger, args]
+      end
+
       def invert_create_text_search_configuration(args)
         [:drop_text_search_configuration, args]
       end

data/lib/active_record/full_text_search/schema_statements.rb

@@ -6,7 +6,10 @@ module ActiveRecord
     end
 
     module SchemaStatements
-      def create_function(name_with_args, as:, volatility: :volatile, language: "sql", returns: "void", replace: true)
+      def create_function(name_with_args, as:, volatility: :volatile, language: nil, returns: :void, replace: true)
+        name_with_args = "#{name_with_args}()" unless name_with_args.to_s.include?("(")
+        language = "plpgsql" if returns == :trigger
+        language ||= "sql"
         execute(<<-SQL)
           CREATE #{"OR REPLACE" if replace} FUNCTION #{name_with_args}
           RETURNS #{returns}
@@ -18,10 +21,60 @@ module ActiveRecord
         SQL
       end
 
-      def drop_function(name_with_args, if_exists: false, cascade: false)
+      def drop_function(name_with_args, options = {})
+        if_exists = options[:if_exists]
+        cascade = options[:cascade]
         execute "DROP FUNCTION #{"IF EXISTS" if if_exists} #{name_with_args} #{"CASCADE" if cascade}"
       end
 
+      def create_trigger(table, function, options = {})
+        raise ArgumentError, "function name is invalid" unless /\A\w+\z/.match?(function.to_s)
+        raise ArgumentError, "Must specify one and only one of the options :before, :after, or :instead_of" unless %i[before after instead_of].select { |t| options.key?(t) }.count == 1
+        raise ArgumentError, "for_each must be :row or :statement" if options[:for_each] && !%i[row statement].include?(options[:for_each])
+
+        timing = %i[before after instead_of].find { |t| options.key?(t) }
+        operations = options[timing] || raise(ArgumentError, "Must specify operations for #{timing} trigger")
+        operations.detect { |op| %i[insert update delete].exclude?(op) } && raise(ArgumentError, "Invalid operation for trigger: #{operations.inspect}")
+        for_each = "FOR EACH #{options[:for_each].to_s.upcase}" if options[:for_each]
+        if options[:deferrable] == :initially_deferred
+          deferrability = "DEFERRABLE INITIALLY DEFERRED"
+        elsif options[:deferrable] == :initially_immediate
+          deferrability = "DEFERRABLE INITIALLY IMMEDIATE"
+        elsif options[:deferrable] == true
+          deferrability = "DEFERRABLE"
+        elsif options[:deferrable] == false
+          deferrability = "NOT DEFERRABLE"
+        elsif options[:deferrable]
+          raise ArgumentError, "Invalid value for :deferrable"
+        end
+        condition = options[:when] ? "WHEN (#{options[:when]})" : ""
+        operations = [operations].flatten.map do |event|
+          if %i[insert update delete].include?(event)
+            event.to_s.upcase
+          # elsif event.is_a?(Hash)
+          #   raise ArgumentError, "Key must be :update" unless event.keys.size == 1 && event.keys.first == :update
+          #   "UPDATE OF #{[event[:update]].flatten.map { |c| quote_column_name(c) }.join(", ")}"
+          else
+            raise ArgumentError, "Unsupported event: #{event.inspect}"
+          end
+        end
+        name = options[:name] || default_trigger_name(table, function, timing, operations)
+
+        execute "CREATE TRIGGER #{name} #{timing.to_s.upcase} #{operations.join(" OR ")} ON #{table} #{for_each} #{deferrability} #{condition} EXECUTE FUNCTION #{function}()"
+      end
+
+      def drop_trigger(table, function, options = {})
+        if_exists = options[:if_exists]
+        cascade = options[:cascade]
+        if options.keys.intersect?(%i[before after instead_of])
+          raise ArgumentError, "Must specify only one of the options :before, :after, or :instead_of" unless %i[before after instead_of].select { |t| options.key?(t) }.count == 1
+          timing = %i[before after instead_of].find { |t| options.key?(t) }
+          operations = options[timing] || raise(ArgumentError, "Must specify operations for #{timing} trigger")
+        end
+        name = options[:name] || default_trigger_name(table, function, timing, operations)
+        execute "DROP TRIGGER #{"IF EXISTS" if if_exists} #{name} ON #{table} #{"CASCADE" if cascade}"
+      end
+
       def create_text_search_template(name, lexize:, init: nil)
         options = {init: init, lexize: lexize}.compact
         execute("CREATE TEXT SEARCH TEMPLATE public.#{name} (#{options.map { |k, v| "#{k.upcase} = #{v}" }.join(", ")})")
@@ -96,6 +149,19 @@ module ActiveRecord
       def drop_text_search_configuration(name, if_exists: false, cascade: :restrict)
         execute "DROP TEXT SEARCH CONFIGURATION #{"IF EXISTS" if if_exists} public.#{name} #{"CASCADE" if cascade == :cascade}"
       end
+
+      def max_trigger_name_size
+        62
+      end
+
+      private
+
+      # Copied from ActiveRecord::ConnectionAdapters::Abstract::SchemaStatements#foreign_key_name
+      def default_trigger_name(table, function, timing, operations)
+        identifier = "#{table}_#{function}_#{timing}_#{operations.sort.join('_')}_tg".underscore
+        hashed_identifier = OpenSSL::Digest::SHA256.hexdigest(identifier).first(10)
+        "tg_rails_#{hashed_identifier}"
+      end
     end
   end
 end

data/lib/active_record/full_text_search/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module FullTextSearch
-    VERSION = "0.1.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/active_record/full_text_search.rb

@@ -3,7 +3,15 @@ require "active_support/lazy_load_hooks"
 
 module ActiveRecord
   module FullTextSearch
-    KNOWN_VERSIONS = %w[7.2].map { |v| Gem::Version.new(v) }.freeze
+    KNOWN_VERSIONS = %w[7.2 8.0 8.1].map { |v| Gem::Version.new(v) }.freeze
+
+    # Maps a supported version to the directory containing its implementation.
+    # Versions that share an implementation point to the same directory.
+    VERSION_DIRECTORIES = {
+      Gem::Version.new("7.2") => "7.2",
+      Gem::Version.new("8.0") => "7.2",
+      Gem::Version.new("8.1") => "7.2",
+    }.freeze
 
     class << self
       attr_reader :enabled_version
@@ -39,7 +47,8 @@ module ActiveRecord
         require "active_record/full_text_search/command_recorder"
         require "active_record/full_text_search/schema_statements"
 
-        Dir[File.join(__dir__, "full_text_search", enabled_version.to_s, "*.rb")].each { |file| require file }
+        directory = VERSION_DIRECTORIES.fetch(enabled_version, enabled_version.to_s)
+        Dir[File.join(__dir__, "full_text_search", directory, "*.rb")].each { |file| require file }
         monkeypatches.keys.each { |patch| monkeypatches.delete(patch).call }
       end
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-full_text_search
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Codeur SAS
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-29 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -85,7 +84,6 @@ metadata:
   changelog_uri: https://github.com/codeur/activerecord-full_text_search/blob/master/CHANGELOG.md
   pgp_keys_uri: https://keybase.io/codeur/pgp_keys.asc
   signatures_uri: https://keybase.pub/codeur/gems/
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -100,8 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Integrate PostgreSQL's FTS configs with Rails
 test_files: []