elasticsearch_record 1.8.2 → 3.0.0

data/lib/elasticsearch_record/model_api.rb

@@ -39,7 +39,7 @@ module ElasticsearchRecord
     end
 
     # delegated dangerous methods with confirm parameter (created with exclamation mark)
-    # a exception will be raised, if +confirm:true+ is missing.
+    # an exception will be raised, if +confirm:true+ is missing.
     #
     # @example
     #   drop!(confirm: true)
@@ -183,12 +183,15 @@ module ElasticsearchRecord
     # @param [Boolean] close
     # @return [String] backup_name
 
-    # @!method restore!(from:, timeout: nil, open: true, drop_backup: false)
+    # @!method restore!(from:, timeout: nil, unblock: true, drop_backup: false)
     # Shortcut for restore_table
+    # PLEASE NOTE: the restore runs through a +clone+, so the restored table inherits the
+    # 'write'-block of its source - +unblock+ releases it again.
     # @param [String] from
     # @param [String (frozen)] timeout
-    # @param [Boolean] open
-    # @return [Boolean] acknowledged status
+    # @param [Boolean] unblock - releases the inherited 'write'-block (default: true)
+    # @param [Boolean] drop_backup
+    # @return [nil]
 
     # @!method reindex!(target_name, **options)
     # Shortcut for reindex_table
@@ -267,7 +270,7 @@ module ElasticsearchRecord
     def bulk(data, operation = :index, refresh: true, **options)
       data = [data] unless data.is_a?(Array)
 
-      _connection.api(:core, :bulk, {
+      _connection.api(:bulk, {
         index:   _index_name,
         body:    case operation
                  when :update

data/lib/elasticsearch_record/model_schema.rb

@@ -45,7 +45,7 @@ module ElasticsearchRecord
       # so this is a array of real document (+_source+) attributes of the index.
       # @return [Array<String>]
       def source_column_names
-        @source_column_names ||= columns.reject(&:virtual?).map(&:name) - ActiveRecord::ConnectionAdapters::ElasticsearchAdapter.base_structure_keys
+        @source_column_names ||= columns.reject(&:virtual?).map(&:name) - ActiveRecord::ConnectionAdapters::ElasticsearchAdapter.metadata_keys
       end
 
       # returns an array with columns names, that are searchable (also includes nested fields & properties )

data/lib/elasticsearch_record/patches/active_record/connection_pool_patch.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/abstract/connection_pool'
+
+module ElasticsearchRecord
+  module Patches
+    module ActiveRecord
+      # Since rails 7.2 the migration plumbing is resolved through the connection POOL
+      # (+ConnectionPool#migration_context+ builds from +#migrations_paths+, +#schema_migration+ &
+      # +#internal_metadata+) instead of the connection - so the adapters own implementations are
+      # no longer consulted. Without this patch a Elasticsearch pool would migrate with the generic
+      # +ActiveRecord::SchemaMigration+ (which resolves the index name through +ActiveRecord::Base+
+      # and only ever sees the first ten migrations - Elasticsearch default search size), enable the
+      # internal metadata index (the adapter cannot serve it) and fall back to the default
+      # 'db/migrate' path.
+      #
+      # The patch simply routes those factories back to the adapter class, which keeps the
+      # Elasticsearch-specific implementations in one place.
+      module ConnectionPoolPatch
+        def self.included(base)
+          base.send(:prepend, PrependMethods)
+        end
+
+        module PrependMethods
+          def migrations_paths
+            return super unless elasticsearch_pool?
+
+            db_config.migrations_paths || ['db/migrate_elasticsearch']
+          end
+
+          def schema_migration
+            return super unless elasticsearch_pool?
+
+            ElasticsearchRecord::SchemaMigration.new(self)
+          end
+
+          def internal_metadata
+            return super unless elasticsearch_pool?
+
+            ElasticsearchRecord::InternalMetadata.new(self)
+          end
+
+          private
+
+          # returns true, if the pools config resolves to the Elasticsearch adapter
+          # @return [Boolean]
+          def elasticsearch_pool?
+            db_config.adapter_class <= ::ActiveRecord::ConnectionAdapters::ElasticsearchAdapter
+          end
+        end
+      end
+    end
+  end
+end
+
+# include once only!
+::ActiveRecord::ConnectionAdapters::ConnectionPool.include(ElasticsearchRecord::Patches::ActiveRecord::ConnectionPoolPatch) unless ::ActiveRecord::ConnectionAdapters::ConnectionPool.included_modules.include?(ElasticsearchRecord::Patches::ActiveRecord::ConnectionPoolPatch)

data/lib/elasticsearch_record/persistence.rb

@@ -5,22 +5,23 @@ module ElasticsearchRecord
     module ClassMethods
       # insert a new record into the Elasticsearch index
       # NOTICE: We don't want to mess up with the Arel-builder - so we send new data directly to the API
+      # @param [ActiveRecord::ConnectionAdapters::ElasticsearchAdapter] connection
       # @param [ActiveModel::Attribute] values
       # @return [Object] id
-      def _insert_record(values, returning)
+      def _insert_record(connection, values, returning)
         # values is not a "key=>values"-Hash, but a +ActiveModel::Attribute+ - so the casted values gets resolved here
         values = values.transform_values(&:value)
 
         # resolve & update a auto_increment value, if configured
-        _insert_with_auto_increment(values) do |arguments|
+        _insert_with_auto_increment(connection, values) do |arguments|
           # build new query
           query = ElasticsearchRecord::Query.new(
-            index:     table_name,
-            type:      ElasticsearchRecord::Query::TYPE_CREATE,
+            index: table_name,
+            type: ElasticsearchRecord::Query::TYPE_CREATE,
             # IMPORTANT: always exclude possible provided +_id+ field
-            body:      values.except('_id'),
+            body: values.except('_id'),
             arguments: arguments,
-            refresh:   true)
+            refresh: true)
 
           # execute query and return inserted id
           connection.insert(query, "#{self} Create", returning: returning)
@@ -35,11 +36,11 @@ module ElasticsearchRecord
 
         # build new query
         query = ElasticsearchRecord::Query.new(
-          index:     table_name,
-          type:      ElasticsearchRecord::Query::TYPE_UPDATE,
-          body:      { doc: values },
+          index: table_name,
+          type: ElasticsearchRecord::Query::TYPE_UPDATE,
+          body: { doc: values },
           arguments: { id: constraints[self.primary_key] },
-          refresh:   true)
+          refresh: true)
 
         # execute query and return total updates
         connection.update(query, "#{self} Update")
@@ -50,10 +51,10 @@ module ElasticsearchRecord
       def _delete_record(constraints)
         # build new query
         query = ElasticsearchRecord::Query.new(
-          index:     table_name,
-          type:      ElasticsearchRecord::Query::TYPE_DELETE,
+          index: table_name,
+          type: ElasticsearchRecord::Query::TYPE_DELETE,
           arguments: { id: constraints[self.primary_key] },
-          refresh:   true)
+          refresh: true)
 
         # execute query and return total deletes
         connection.delete(query, "#{self} Delete")
@@ -62,11 +63,11 @@ module ElasticsearchRecord
       private
 
       # Resolves the +auto_increment+ status from the tables +_meta+ attributes.
-      def _insert_with_auto_increment(values)
+      def _insert_with_auto_increment(connection, values)
         # check, if the primary_key's value is provided.
         # so, no need to resolve a +auto_increment+ value, but provide the id directly
         if (id = values[self.primary_key]).present?
-          yield({id: id})
+          yield({ id: id })
         elsif auto_increment?
           # future increments: uuid (+uuidv6 ?), hex, radix(2-36), integer
           # allocated through: primary_key_type
@@ -75,17 +76,34 @@ module ElasticsearchRecord
             # try to resolve the current-auto-increment value from the tables meta
             connection.table_metas(self.table_name).dig('auto_increment').to_i + 1,
             # for secure reasons: also resolve the current maximum value for the primary key
-            self.unscoped.all.maximum(self.primary_key).to_i + 1
+            self.unscoped.maximum(self.primary_key).to_i + 1
           ]
 
-          id = yield({ id: ids.max })
+          # yield and resolve the new inserted *result*
+          result = yield({ id: ids.max })
 
-          if id.present?
-            connection.change_meta(self.table_name, :auto_increment, id)
+          # IMPORTANT: the block returns whatever +connection.insert+ resolved, which is NOT a plain id:
+          # ActiveRecord always provides the primary_key as +returning+ column, so an ARRAY of the
+          # returning column values is resolved (see @ ActiveRecord::Persistence#_create_record).
+          # The +_meta+ must be updated with the PLAIN id - storing the raw result breaks the
+          # +.to_i+ of the NEXT insert (which then only resolves a 0 - or fails altogether).
+          id = case result
+               when Array
+                 result.first
+               when Hash
+                 result[:id] || result['id']
+               else
+                 result
+               end
+
+          if id.present? && id.to_i > 0
+            # IMPORTANT: elasticsearch resolves a document +_id+ as String - the +_meta+ must keep the
+            # INTEGER it was created with, so the schema does not change its type behind the first insert.
+            connection.change_meta(self.table_name, :auto_increment, id.to_i)
           end
 
-          # return inserted id
-          id
+          # return the UNCHANGED insert result - it is zipped against the +returning+ columns
+          result
         else
           yield({})
         end

data/lib/elasticsearch_record/query.rb

@@ -1,36 +1,39 @@
 module ElasticsearchRecord
   class Query
     # STATUS CONSTANTS
-    STATUS_VALID  = :valid
+    STATUS_VALID = :valid
     STATUS_FAILED = :failed
 
     # -- UNDEFINED TYPE ------------------------------------------------------------------------------------------------
     TYPE_UNDEFINED = :undefined
 
     # -- QUERY TYPES ---------------------------------------------------------------------------------------------------
-    TYPE_COUNT   = :count
-    TYPE_SEARCH  = :search
+    TYPE_COUNT = :count
+    TYPE_SEARCH = :search
     TYPE_MSEARCH = :msearch
-    TYPE_SQL     = :sql
-    TYPE_ESQL    = :esql
+    TYPE_SQL = :sql
+
+    # PLEASE NOTE: ES|QL requires Elasticsearch >= 8.11
+    # (the +esql+ API namespace does not exist before that)
+    TYPE_ESQL = :esql
 
     # -- DOCUMENT TYPES ------------------------------------------------------------------------------------------------
-    TYPE_CREATE          = :create
-    TYPE_UPDATE          = :update
+    TYPE_CREATE = :create
+    TYPE_UPDATE = :update
     TYPE_UPDATE_BY_QUERY = :update_by_query
-    TYPE_DELETE          = :delete
+    TYPE_DELETE = :delete
     TYPE_DELETE_BY_QUERY = :delete_by_query
 
     # -- INDEX TYPES ---------------------------------------------------------------------------------------------------
     TYPE_INDEX_CREATE = :index_create
-    TYPE_INDEX_CLONE  = :index_clone
+    TYPE_INDEX_CLONE = :index_clone
     # INDEX update is not implemented by Elasticsearch
     # - this is handled through individual updates of +mappings+, +settings+ & +aliases+.
     # INDEX delete is handled directly as API-call
     TYPE_INDEX_UPDATE_MAPPING = :index_update_mapping
     TYPE_INDEX_UPDATE_SETTING = :index_update_setting
-    TYPE_INDEX_UPDATE_ALIAS   = :index_update_alias
-    TYPE_INDEX_DELETE_ALIAS   = :index_delete_alias
+    TYPE_INDEX_UPDATE_ALIAS = :index_update_alias
+    TYPE_INDEX_DELETE_ALIAS = :index_delete_alias
 
     # includes valid types only
     TYPES = [
@@ -54,22 +57,39 @@ module ElasticsearchRecord
     # acts like the SQL-query "where('1=0')"
     FAILED_BODIES = {
       TYPE_SEARCH => { size: 0, query: { bool: { filter: [{ term: { _id: '_' } }] } } },
-      TYPE_COUNT  => { query: { bool: { filter: [{ term: { _id: '_' } }] } } }
+      TYPE_COUNT => { query: { bool: { filter: [{ term: { _id: '_' } }] } } }
     }.freeze
 
     # defines special api gates to be used per type.
     # if no special type is defined, it simply uses +[:core,self.type]+
-    GATES = {
-      TYPE_SQL                  => [:sql, :query],
-      TYPE_ESQL                 => [:esql, :query],
-      TYPE_INDEX_CREATE         => [:indices, :create],
-      TYPE_INDEX_CLONE          => [:indices, :clone],
-      TYPE_INDEX_UPDATE_MAPPING => [:indices, :put_mapping],
-      TYPE_INDEX_UPDATE_SETTING => [:indices, :put_settings],
-      TYPE_INDEX_UPDATE_ALIAS   => [:indices, :put_alias],
-      TYPE_INDEX_DELETE_ALIAS   => [:indices, :delete_alias],
+    # @return [Hash<Symbol=>String>]
+    GATES_MAP = {
+      TYPE_SQL => 'sql.query',
+      TYPE_ESQL => 'esql.query',
+      TYPE_INDEX_CREATE => 'indices.create',
+      TYPE_INDEX_CLONE => 'indices.clone',
+      TYPE_INDEX_UPDATE_MAPPING => 'indices.put_mapping',
+      TYPE_INDEX_UPDATE_SETTING => 'indices.put_settings',
+      TYPE_INDEX_UPDATE_ALIAS => 'indices.put_alias',
+      TYPE_INDEX_DELETE_ALIAS => 'indices.delete_alias'
     }.freeze
 
+    # -- PROJECTION MARKERS --------------------------------------------------------------------------------------------
+
+    # defines a projection marker that forces a query to return *no* +_source+ fields at all.
+    # metadata fields ('_id', '_score', ...) are not part of the +_source+ - they are always
+    # returned on the document level and therefore stay accessible.
+    #
+    # this is the only way to clear the columns that +visit_Arel_Nodes_SelectCore+ claims for
+    # every relation - a +configure+ can only reach the query-body, never the columns.
+    #
+    # HINT: only evaluated as the *first* projection - combining it with other fields
+    # (e.g. +select(COLUMNS_NONE, :name)+) silently discards them.
+    #
+    # see @ ElasticsearchRecord::Relation::ResultMethods#meta_only!
+    # see @ Arel::Visitors::ElasticsearchQuery#visit_Selects
+    COLUMNS_NONE = '!'
+
     # defines the index the query should be executed on
     # @!attribute String
     attr_reader :index
@@ -101,14 +121,14 @@ module ElasticsearchRecord
     attr_reader :columns
 
     def initialize(index: nil, type: TYPE_UNDEFINED, status: STATUS_VALID, body: nil, refresh: nil, timeout: nil, arguments: {}, columns: [])
-      @index     = index
-      @type      = type
-      @status    = status
-      @refresh   = refresh
-      @timeout   = timeout
-      @body      = body
+      @index = index
+      @type = type
+      @status = status
+      @refresh = refresh
+      @timeout = timeout
+      @body = body
       @arguments = arguments
-      @columns   = columns
+      @columns = columns
     end
 
     # sets the failed status for this query.
@@ -136,9 +156,9 @@ module ElasticsearchRecord
     # returns the API gate to be called to execute the query.
     # each query type needs a different endpoint.
     # @see Elasticsearch::API
-    # @return [Array<Symbol, Symbol>] - API gate [<namespace>,<action>]
+    # @return [Symbol, String] - API gate "<namespace>.<action>" | <:action>
     def gate
-      GATES[self.type].presence || [:core, self.type]
+      GATES_MAP[self.type].presence || self.type
     end
 
     # returns true if this is a write query
@@ -161,13 +181,13 @@ module ElasticsearchRecord
     # Also used possible PRE-defined arguments to be merged with those mentioned attributes.
     # @return [Hash]
     def query_arguments
-      args           = @arguments.deep_dup
+      args = @arguments.deep_dup
 
       # set index, if present
-      args[:index]   = self.index if self.index.present?
+      args[:index] = self.index if self.index.present?
 
       # set body, if present
-      args[:body]    = self.body if self.body.present?
+      args[:body] = self.body if self.body.present?
 
       # set refresh, if defined (also includes false value)
       args[:refresh] = self.refresh unless self.refresh.nil?

data/lib/elasticsearch_record/querying.rb

@@ -42,13 +42,14 @@ module ElasticsearchRecord
       # @param [String, Hash, ElasticsearchRecord::Query] sql
       # @param [Array] binds
       # @param [nil] preparable
+      # @param [Boolean] allow_retry
       # @param [Proc] block
-      def find_by_sql(sql, binds = [], preparable: nil, &block)
+      def find_by_sql(sql, binds = [], preparable: nil, allow_retry: false, &block)
         query = case sql
                 when String # really find by SQL
                   ElasticsearchRecord::Query.new(
                     type: ElasticsearchRecord::Query::TYPE_SQL,
-                    body: { query: query_or_sql },
+                    body: { query: sql },
                     # IMPORTANT: Always provide all columns
                     columns: source_column_names)
                 when Hash
@@ -61,7 +62,11 @@ module ElasticsearchRecord
                   sql
                 end
 
-        _load_from_sql(_query_by_sql(query, binds), &block)
+        result = with_connection do |c|
+          _query_by_sql(c, query, binds, preparable: preparable, allow_retry: allow_retry)
+        end
+
+        _load_from_sql(result, &block)
       end
 
       # finds records by query arguments
@@ -74,7 +79,11 @@ module ElasticsearchRecord
           # IMPORTANT: Always provide all columns to prevent unknown attributes that should be nil ...
           columns: source_column_names)
 
-        _load_from_sql(_query_by_sql(query), &block)
+        result = with_connection do |c|
+          _query_by_sql(c, query)
+        end
+
+        _load_from_sql(result, &block)
       end
 
       # ES|QL query API
@@ -90,14 +99,17 @@ module ElasticsearchRecord
           # IMPORTANT: Always provide all columns
           columns: source_column_names)
 
-        _load_from_sql(_query_by_sql(query), &block)
+        result = with_connection do |c|
+          _query_by_sql(c, query)
+        end
+
+        _load_from_sql(result, &block)
       end
 
       # executes a +esql+ by provided *ES|SL* query
       # Does NOT instantiate records.
       # @param [String] esql
-      # @param [Boolean] async (default: false)
-      def esql(esql, async: false)
+      def esql(esql)
         # build new query
         query = ElasticsearchRecord::Query.new(
           type: ElasticsearchRecord::Query::TYPE_ESQL,
@@ -105,15 +117,14 @@ module ElasticsearchRecord
           # IMPORTANT: Always provide all columns
           columns: source_column_names)
 
-        connection.internal_exec_query(query, "#{name} ES|QL", async: async)
+        connection.exec_query(query, "#{name} ES|QL")
       end
 
 
       # executes a +msearch+ by provided *RAW* queries.
       # Does NOT instantiate records.
       # @param [Array<String>] queries
-      # @param [Boolean] async (default: false)
-      def msearch(queries, async: false)
+      def msearch(queries)
         # build new msearch query
         query = ElasticsearchRecord::Query.new(
           index: table_name,
@@ -122,20 +133,31 @@ module ElasticsearchRecord
           # IMPORTANT: Always provide all columns
           columns: source_column_names)
 
-        connection.internal_exec_query(query, "#{name} Msearch", async: async)
+        connection.exec_query(query, "#{name} Msearch")
       end
 
-      # executes a search by provided +RAW+ query - supports +Elasticsearch::DSL+ gem if loaded
+      # executes a search by provided +RAW+ query - supports +Elasticsearch::DSL+ gem if loaded.
+      #
+      # Without a block the trailing options-hash is used as query arguments.
+      # With a block the +Elasticsearch::DSL+ gem builds the query - if the gem is not
+      # available (or the block fails), the block is SILENTLY ignored and the
+      # options-hash is used instead.
       def search(*args, &block)
-        begin
-          # require the Elasticsearch::DSL gem, if loaded
-          require 'elasticsearch/dsl'
-          query = ::Elasticsearch::DSL::Search::Search.new(*args, &block).to_hash
-        rescue LoadError
-          query = args.extract_options!
-        rescue
-          query = args.extract_options!
-        end
+        query = if block_given?
+                  begin
+                    # require the Elasticsearch::DSL gem, if loaded
+                    require 'elasticsearch/dsl'
+                    # PLEASE NOTE: +Search#to_hash+ returns the request BODY - it must be nested
+                    # into the query arguments, otherwise it is sent as (invalid) URL parameters.
+                    { body: ::Elasticsearch::DSL::Search::Search.new(*args, &block).to_hash }
+                  rescue LoadError
+                    args.extract_options!
+                  rescue
+                    args.extract_options!
+                  end
+                else
+                  args.extract_options!
+                end
 
         find_by_query(query)
       end

data/lib/elasticsearch_record/relation/calculation_methods.rb

@@ -8,6 +8,12 @@ module ElasticsearchRecord
       #
       #   Person.all.count(:age)
       #   => returns the total count of all people whose age is present in database
+      #
+      #   Person.all.limit(10).count
+      #   => returns at most 10 - the SQL 'LIMIT n OFFSET m' semantic is applied on the resolved total
+      #
+      # @param [Symbol, String, nil] column_name
+      # @return [Integer, Hash]
       def count(column_name = nil)
         # fallback to default
         return super() if block_given?
@@ -36,12 +42,12 @@ module ElasticsearchRecord
           # HINT: +:__query__+ directly interacts with the query-object and sets the 'terminate_after' argument
           # see @ ElasticsearchRecord::Query#arguments & Arel::Collectors::ElasticsearchQuery#assign
           arel = spawn.unscope!(:offset, :limit, :order, :configure, :aggs).configure!(:__query__, argument: { terminate_after: limit_value }).arel
-          klass.connection.select_count(arel, "#{klass.name} Count")
+          _resolve_limited_count(klass.connection.select_count(arel, "#{klass.name} Count"))
         else
           # since total will be limited to 10000 results, we need to resolve the real values by a custom query.
           # This query is called through +#select_count+.
           arel = spawn.unscope!(:offset, :limit, :order, :configure, :aggs)
-          klass.connection.select_count(arel, "#{klass.name} Count")
+          _resolve_limited_count(klass.connection.select_count(arel, "#{klass.name} Count"))
         end
       end
 
@@ -129,9 +135,17 @@ module ElasticsearchRecord
       #
       # @note returns *nil* on a *NullRelation*
       #
+      # PLEASE NOTE: the aggregation quantifies the relationship BETWEEN fields, so it requires at
+      # least two of them. A single column would additionally take the 'field'-branch of
+      # +#calculate_aggregation+ - but the metric only accepts a 'fields' node.
+      #
       # @param [Array<Symbol|String>] column_names
+      # @raise [ArgumentError] if less than two columns were provided
       # @return [Hash,nil]
       def matrix_stats(*column_names)
+        # ensure minimum number of names are provided
+        raise(ArgumentError, "Unable to build a 'matrix_stats' aggregation with less than two columns (#{column_names.size} provided) @ #{klass.name}!") if column_names.size < 2
+
         calculate_aggregation(:matrix_stats, *column_names)
       end
 
@@ -316,6 +330,28 @@ module ElasticsearchRecord
       end
 
       alias_method :calculate, :calculate_aggregation
+
+      private
+
+      # applies the SQL +LIMIT n OFFSET m+ semantic onto an already resolved total.
+      #
+      # IMPORTANT: Elasticsearch always answers a count with the FULL total. The +terminate_after+
+      # argument (see @ +#count+) cannot provide this semantic on its own:
+      # - it limits the *collected* documents, but a count query collects none - so it never fires
+      # - and it acts PER SHARD, which would resolve +limit * shards+ on a multi-shard index
+      #
+      # Clamping the resolved total is exact either way: a per-shard early termination can only
+      # return a value between +min(limit, total)+ and +total+, so the minimum stays the same.
+      #
+      # @param [Integer] total - the resolved (full) total
+      # @return [Integer]
+      def _resolve_limited_count(total)
+        # the offset is subtracted first - it can never result in a negative count
+        total -= offset_value if offset_value
+        return 0 if total < 0
+
+        limit_value ? [total, limit_value].min : total
+      end
     end
   end
 end

data/lib/elasticsearch_record/relation/core_methods.rb

@@ -10,7 +10,7 @@ module ElasticsearchRecord
       # transforms the current relation into arel, compiles it to query and executes the query.
       # returns the result object.
       #
-      # PLEASE NOTE: This makes the query +immutable+ and raises a +ActiveRecord::ImmutableRelation+
+      # PLEASE NOTE: This makes the query +immutable+ and raises a +ActiveRecord::UnmodifiableRelation+
       # if you try to change it's values.
       #
       # PLEASE NOTE: resolving records _(instantiate)_ is never possible after calling this method!

data/lib/elasticsearch_record/relation/query_clause_tree.rb

@@ -109,7 +109,8 @@ module ElasticsearchRecord # :nodoc:
           left = left[key]
           right = right[key]
 
-          or_clause = Arel::Nodes::Or.new(left, right)
+          # since rails 7.2 +Arel::Nodes::Or+ is a nary node and takes its children as a single Array
+          or_clause = Arel::Nodes::Or.new([left, right])
 
           common.predicates[key] = ElasticsearchRecord::Relation::QueryClause.new(key, [Arel::Nodes::Grouping.new(or_clause)])
           common