activerecord-full_text_search 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0e395c41810e9e42ae30e3f2aca5527fe80666fd52dcfdd9913b3501b6e97f0
-  data.tar.gz: dab379e41ed0fe39a5f90e3dc42b99337d5dbf441e6e8b1b10eae93ab6f202c9
+  metadata.gz: 3c5deadfa80337621d1082bbd878ba261d2892c5021371d7f3b1d8a1ddf2f006
+  data.tar.gz: fdd8e1ed4bf501c13cfea20e1b02860c6e1c37e525a6052dfd766bb16bffc4fa
 SHA512:
-  metadata.gz: 51fc2b15b2016a7030c4fbd63c0cf0065453c1cff0d4a50007d8870e556cf8e4098008f7077a76b85c41124d865cda4e4fda3d9f0acdc38d8dbb4b7c951f32ba
-  data.tar.gz: e97e619209f362b9412ad7df74b0511f3f99b557dd1085cd8b7508ae4ee369b74e2e8f5a7ea2c4c8191ab3253ecd4432ee8c25b0c2f5d14d295c344b206198bf
+  metadata.gz: 60141c5d729d71ba3b4e44501ef8299438bef3c290fd034c6f5714f3d1b3a398ecc0be7c9ace074d24528019d86bddec2275c3103f4db7594a312866c8e5f7b9
+  data.tar.gz: 46e6d7c0d0e67a77ee514e7da5a229109cd62b6d32fdd00a7472fb86f7fc9e67b88181fe79e194cf2e756613f5343f2916de23866aa25b29b8b525ffaac65921

data/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+## [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

@@ -31,6 +31,47 @@ 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_expr(tgqual, tgrelid) AS tg_condition,
+            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;
+        SQL
+
+        res.rows.each_with_object({}) do |(name, table, function, timing, ops, for_each, condition, deferrable, initially_deferred), memo|
+          attributes = {table: table, function: function, for_each: for_each.to_sym}
+          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

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.2.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-full_text_search
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Codeur SAS
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-29 00:00:00.000000000 Z
+date: 2024-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg