elasticsearch_record 1.7.2 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e957272489ab4ebcfc628f36441959f01e20264d215f3f8d020d461447b87bc
-  data.tar.gz: a12a713313af1fd1dd83077b96255efe9cfeced3bcc5204739fd383499e6ad8a
+  metadata.gz: ef01a33de054cbae1fe582ba5f7d8a5910c73dd81e3395f8b6c07ec9d3a5fbe2
+  data.tar.gz: d574bafc90b201869727539fd0a0c148118d6f666f9f29400690613bd7cbbaa8
 SHA512:
-  metadata.gz: 4ef80538ae0feca07575902168df24c56696b4c4cf608ca8466b4c495261296a4338709e302bf402b2596fe1bb0617faa3c1198a7fa6f6b96cc031bd4ea7831e
-  data.tar.gz: 5ad60438e39b4f579d84959f897452d48ac1d4b261c7b65af7539ddb7b69601b1d963dd393ab647d5dbcef55c695ce0cf5e2ffbb6db217348ead523f8e373f4b
+  metadata.gz: 89ac7c99f35a36650c2ac8f00600f0c702ed8ec4c4aaa5d28ad86c329a66be3625d063ada9dd8c6630b8b30eea1a5283a0231a60c0d8021242adeae4efe86316
+  data.tar.gz: b44f713a1650100a925c94349fcb9fdce4b72bf5acb901c5ff04b871e0586115bf5e08e42f38cd9ecb0e550663977da48e430a739b67230ced4eb29aa4f5bb8b

data/README.md

@@ -14,8 +14,8 @@ _ElasticsearchRecord is a ActiveRecord adapter and provides similar functionalit
 
 **PLEASE NOTE:**
 
-- This is the `rails-7-0-stable`-branch, which only supports rails **7.0** _(see section 'Rails_Versions' for supported versions)_
-- supports ActiveRecord ~> 7.0 + Elasticsearch >= 7.17
+- This is the `rails-7-1-stable`-branch, which only supports rails **7.1** _(see section 'Rails_Versions' for supported versions)_
+- supports ActiveRecord ~> 7.1 + Elasticsearch >= 7.17
 
 -----
 
@@ -44,10 +44,10 @@ https://github.com/ruby-smart/elasticsearch_record/tree/rails-7-0-stable
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'elasticsearch_record', '~> 1.7.0'
+gem 'elasticsearch_record', '~> 1.8'
 
 # alternative
-gem 'elasticsearch_record', git: 'https://github.com/ruby-smart/elasticsearch_record', branch: 'rails-7-0-stable'
+gem 'elasticsearch_record', git: 'https://github.com/ruby-smart/elasticsearch_record', branch: 'rails-7-1-stable'
 
 ```
 
@@ -87,7 +87,7 @@ To raise an exception while using transactions on a ElasticsearchRecord model, t
 However enabling this flag will surely fail transactional tests _(prevent this with 'use_transactional_tests=false')_
 
 ```ruby
-# config/initializers/elasticsearch_record.yml
+# config/initializers/elasticsearch_record.rb
 
 # enable transactional exceptions
 ElasticsearchRecord.error_on_transaction = true

data/docs/CHANGELOG.md

@@ -1,5 +1,24 @@
 # ElasticsearchRecord - CHANGELOG
 
+## [1.8.1] - 2024-05-07
+* [add] new elasticsearch mapping types _(percolator, geo, vector, texts, ...)_
+* [ref] `ElasticsearchRecord::Relation#limit` to detect `Float::INFINITY` to also set the **max_result_window**
+* [fix] `ElasticsearchRecord::SchemaMigration` only returning the first ten migrations (broke migrated migrations)
+* [fix] `ElasticsearchRecord::Relation::CalculationMethods#calculate` method incompatibility - renamed to `#calculate_aggregation` (+ alias to `#calculate`)
+* [fix] `ElasticsearchRecord::ModelApi#bulk` method not correctly generating data for 'delete'
+
+## [1.8.0] - 2024-01-10
+* [ref] major method & dependency refactoring for `rails 7.1` - _(Does **NOT** work with rails 7.0)_
+* [add] new repository branch `rails-7-1-stable` to support different rails version
+* [ref] gemspec to lock on rails 7.1
+
+## [1.7.3] - 2024-05-07 _(no gem release)_
+* [add] new elasticsearch mapping types _(percolator, geo, vector, texts, ...)_
+* [ref] `ElasticsearchRecord::Relation#limit` to detect `Float::INFINITY` to also set the **max_result_window**
+* [fix] `ElasticsearchRecord::SchemaMigration` only returning the first ten migrations (broke migrated migrations)
+* [fix] `ElasticsearchRecord::Relation::CalculationMethods#calculate` method incompatibility - renamed to `#calculate_aggregation` (+ alias to `#calculate`)
+* [fix] `ElasticsearchRecord::ModelApi#bulk` method not correctly generating data for 'delete'
+
 ## [1.7.2] - 2024-01-10
 * [ref] gemspec to lock on rails 7.0
 

data/elasticsearch_record.gemspec

@@ -32,7 +32,7 @@ DESC
 
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'activerecord', '~> 7.0.0'
+  spec.add_dependency 'activerecord', '~> 7.1.0'
   spec.add_dependency 'elasticsearch', '>= 7.17'
 
   #spec.add_development_dependency 'coveralls_reborn', '~> 0.25'

data/lib/active_record/connection_adapters/elasticsearch/database_statements.rb

@@ -50,43 +50,12 @@ module ActiveRecord
             query.write?
           end
 
-          # Executes the query object in the context of this connection and returns the raw result
-          # from the connection adapter.
-          # @param [ElasticsearchRecord::Query] query
-          # @param [String (frozen)] name
-          # @param [Boolean] async
-          # @return [ElasticsearchRecord::Result]
-          def execute(query, name = nil, async: false)
-            # validate the query
-            raise ActiveRecord::StatementInvalid, 'Unable to execute! Provided query is not a "ElasticsearchRecord::Query".' unless query.is_a?(ElasticsearchRecord::Query)
-            raise ActiveRecord::StatementInvalid, 'Unable to execute! Provided query is invalid.' unless query.valid?
-
-            # checks for write query - raises an exception if connection is locked to readonly ...
-            check_if_write_query(query)
-
-            api(*query.gate, query.query_arguments, name, async: async)
-          end
-
-          # gets called for all queries - a +ElasticsearchRecord::Query+ must be provided.
-          # @param [ElasticsearchRecord::Query] query
-          # @param [String (frozen)] name
-          # @param [Array] binds - not supported on the top-level and therefore ignored!
-          # @param [Boolean] prepare - used by the default AbstractAdapter - but not supported and therefore never ignored!
-          # @param [Boolean] async
-          # @return [ElasticsearchRecord::Result]
-          def exec_query(query, name = "QUERY", binds = [], prepare: false, async: false)
-            build_result(
-              execute(query, name, async: async),
-              columns: query.columns
-            )
-          end
-
           # Executes insert +query+ statement in the context of this connection using
           # +binds+ as the bind substitutes. +name+ is logged along with
           # the executed +query+ arguments.
           # @return [ElasticsearchRecord::Result]
-          def exec_insert(query, name = nil, binds = [], _pk = nil, _sequence_name = nil)
-            result = exec_query(query, name, binds)
+          def exec_insert(query, name = nil, binds = [], _pk = nil, _sequence_name = nil, returning: nil)
+            result = internal_exec_query(query, name, binds)
 
             # fetch additional Elasticsearch response result
             # raise ::ElasticsearchRecord::ResponseResultError.new('created', result.result) unless result.result == 'created'
@@ -101,7 +70,7 @@ module ActiveRecord
           # expects a integer as return.
           # @return [Integer]
           def exec_update(query, name = nil, binds = [])
-            result = exec_query(query, name, binds)
+            result = internal_exec_query(query, name, binds)
 
             # fetch additional Elasticsearch response result
             # raise ::ElasticsearchRecord::ResponseResultError.new('updated', result.result) unless result.result == 'updated'
@@ -115,7 +84,7 @@ module ActiveRecord
           # expects a integer as return.
           # @return [Integer]
           def exec_delete(query, name = nil, binds = [])
-            result = exec_query(query, name, binds)
+            result = internal_exec_query(query, name, binds)
 
             # fetch additional Elasticsearch response result
             # raise ::ElasticsearchRecord::ResponseResultError.new('deleted', result.result) unless result.result == 'deleted'
@@ -135,7 +104,7 @@ module ActiveRecord
               type:  ElasticsearchRecord::Query::TYPE_MSEARCH,
               body:  queries.map { |q| { search: q.body } })
 
-            exec_query(query, name, async: async)
+            internal_exec_query(query, name, async: async)
           end
 
           # executes a count query for provided arel
@@ -151,7 +120,7 @@ module ActiveRecord
               status:    query.status,
               arguments: query.arguments)
 
-            exec_query(query, name, async: async).response['count']
+            internal_exec_query(query, name, async: async).response['count']
           end
 
           # returns the last inserted id from the result.
@@ -159,6 +128,40 @@ module ActiveRecord
           def last_inserted_id(result)
             result.response['_id']
           end
+
+          private
+
+          # Executes the query object in the context of this connection and returns the raw result
+          # from the connection adapter.
+          # @param [ElasticsearchRecord::Query] query
+          # @param [String (frozen),nil] name
+          # @param [Boolean] async (default: false)
+          # @param [Boolean] allow_retry (default: false)
+          # @return [ElasticsearchRecord::Result]
+          def internal_execute(query, name = nil, async: false, allow_retry: false, materialize_transactions: nil)
+            # validate the query
+            raise ActiveRecord::StatementInvalid, 'Unable to execute! Provided query is not a "ElasticsearchRecord::Query".' unless query.is_a?(ElasticsearchRecord::Query)
+            raise ActiveRecord::StatementInvalid, 'Unable to execute! Provided query is invalid.' unless query.valid?
+
+            # checks for write query - raises an exception if connection is locked to readonly ...
+            check_if_write_query(query)
+
+            api(*query.gate, query.query_arguments, name, async: async)
+          end
+
+          # gets called for all queries - a +ElasticsearchRecord::Query+ must be provided.
+          # @param [ElasticsearchRecord::Query] query
+          # @param [String (frozen),nil] name
+          # @param [Array] binds - not supported on the top-level and therefore ignored!
+          # @param [Boolean] prepare - used by the default AbstractAdapter - but not supported and therefore never ignored!
+          # @param [Boolean] async
+          # @return [ElasticsearchRecord::Result]
+          def internal_exec_query(query, name = "QUERY", binds = [], prepare: false, async: false)
+            build_result(
+              internal_execute(query, name, async: async),
+              columns: query.columns
+            )
+          end
         end
       end
     end

data/lib/active_record/connection_adapters/elasticsearch/schema_definitions/column_methods.rb

@@ -8,11 +8,20 @@ module ActiveRecord
 
         included do
           # see @ ::ActiveRecord::ConnectionAdapters::ElasticsearchAdapter::NATIVE_DATABASE_TYPES.keys
-          define_column_methods :string, :blob, :datetime, :bigint, :json, :binary, :boolean, :keyword,
-                                :constant_keyword, :wildcard, :long, :integer, :short, :byte, :double, :float,
-                                :half_float, :scaled_float, :unsigned_long, :date, :object, :flattened, :nested,
+          define_column_methods :string, :blob, :datetime, :bigint, :json,
+                                :binary, :boolean,
+                                :keyword, :constant_keyword, :wildcard,
+                                :long, :integer, :short, :byte, :double, :float, :half_float, :scaled_float, :unsigned_long,
+                                :date, :date_nanos,
+                                :alias,
+                                :object, :flattened, :nested, :join,
                                 :integer_range, :float_range, :long_range, :double_range, :date_range, :ip_range,
-                                :ip, :version, :text
+                                :ip, :version, :murmur3,
+                                :aggregate_metric_double, :histogram,
+                                :text, :match_only_text, :completion, :search_as_you_type, :token_count,
+                                :dense_vector, :sparse_vector, :rank_feature, :rank_features,
+                                :geo_point, :geo_shape, :point, :shape,
+                                :percolator
 
           # Appends a primary key definition to the table definition.
           # Can be called multiple times, but this is probably not a good idea.

data/lib/active_record/connection_adapters/elasticsearch/schema_statements.rb

@@ -223,7 +223,7 @@ module ActiveRecord
           # @param [String] _table_name
           # @param [Hash] field
           # @return [ActiveRecord::ConnectionAdapters::Column]
-          def new_column_from_field(_table_name, field)
+          def new_column_from_field(_table_name, field, _definitions)
             ActiveRecord::ConnectionAdapters::Elasticsearch::Column.new(
               field["name"],
               field["null_value"],

data/lib/active_record/connection_adapters/elasticsearch_adapter.rb

@@ -23,31 +23,18 @@ require 'elasticsearch'
 
 module ActiveRecord # :nodoc:
   module ConnectionHandling # :nodoc:
-    def elasticsearch_connection(config)
-      config          = config.symbolize_keys
-
-      # move 'username' to 'user'
-      config[:user]  = config.delete(:username) if config[:username]
-
-      # append 'port' to 'host'
-      config[:host]  += ":#{config.delete(:port)}" if config[:port] && config[:host]
-
-      # move 'host' to 'hosts'
-      config[:hosts]  = config.delete(:host) if config[:host]
-
-      # enable logging (Rails.logger)
-      config[:logger] = logger if config.delete(:log)
+    def elasticsearch_adapter_class
+      ConnectionAdapters::ElasticsearchAdapter
+    end
 
-      ConnectionAdapters::ElasticsearchAdapter.new(
-        ConnectionAdapters::ElasticsearchAdapter.new_client(config),
-        logger,
-        config
-      )
+    def elasticsearch_connection(config)
+      elasticsearch_adapter_class.new(config)
     end
   end
 
   module ConnectionAdapters # :nodoc:
     class ElasticsearchAdapter < AbstractAdapter
+      # defines the *Elasticsearch* adapter name.
       ADAPTER_NAME = "Elasticsearch"
 
       # defines the Elasticsearch 'base' structure, which is always included but cannot be resolved through mappings ...
@@ -68,16 +55,20 @@ module ActiveRecord # :nodoc:
 
       class << self
         def base_structure_keys
-          @base_structure_keys ||= BASE_STRUCTURE.map { |struct| struct['name'] }.freeze
+          # using a class_variable to not reinitialize for descendants
+          @@base_structure_keys ||= BASE_STRUCTURE.map { |struct| struct['name'] }.freeze
         end
 
         def new_client(config)
           # IMPORTANT: remove +adapter+ from config - otherwise we mess up with Faraday::AdapterRegistry
-          client = ::Elasticsearch::Client.new(config.except(:adapter))
-          client.ping unless config[:ping] == false
-          client
+          client_config          = config.except(:adapter)
+          # add rails logger manually, if +:log+ is true
+          client_config[:logger] = logger if client_config.delete(:log)
+
+          # build an return new client
+          ::Elasticsearch::Client.new(client_config)
         rescue ::Elastic::Transport::Transport::Errors::Unauthorized
-          raise ActiveRecord::DatabaseConnectionError.username_error(config[:user])
+          raise ::ActiveRecord::DatabaseConnectionError.username_error(config[:user])
         rescue ::Elastic::Transport::Transport::ServerError => error
           raise ::ActiveRecord::ConnectionNotEstablished, error.message
         end
@@ -144,25 +135,35 @@ module ActiveRecord # :nodoc:
       # define native types - which will be used for schema-dumping
       NATIVE_DATABASE_TYPES = {
         primary_key: { name: 'long' }, # maybe this hae to changed to 'keyword'
-        string:      { name: 'keyword' },
-        blob:        { name: 'binary' },
-        datetime:    { name: 'date' },
-        bigint:      { name: 'long' },
-        json:        { name: 'object' }
+        string:   { name: 'keyword' },
+        blob:     { name: 'binary' },
+        datetime: { name: 'date' },
+        bigint:   { name: 'long' },
+        json:     { name: 'object' }
       }.merge(
         TYPE_MAP.keys.map { |key| [key.to_sym, { name: key }] }.to_h
       )
 
-      def initialize(*args)
-        super(*args)
+      def initialize(...)
+        super
+
+        # transform provided config
+        config         = @config.dup
+
+        # move 'username' to 'user'
+        config[:user]  = config.delete(:username) if config[:username]
+
+        # append 'port' to 'host'
+        config[:host]  += ":#{config.delete(:port)}" if config[:port] && config[:host]
+
+        # move 'host' to 'hosts'
+        config[:hosts] = config.delete(:host) if config[:host]
 
-        # prepared statements are not supported by Elasticsearch.
-        # documentation for mysql prepares statements @ https://dev.mysql.com/doc/refman/8.0/en/sql-prepared-statements.html
-        @prepared_statements = false
+        @connection_parameters = config
       end
 
       def schema_migration # :nodoc:
-        @schema_migration ||= ElasticsearchRecord::SchemaMigration
+        ElasticsearchRecord::SchemaMigration.new(self)
       end
 
       # provide a table_name_prefix from the configuration to create & restrict schema creation
@@ -180,6 +181,12 @@ module ActiveRecord # :nodoc:
         @config[:migrations_paths] || ['db/migrate_elasticsearch']
       end
 
+      # prepared statements are not supported by Elasticsearch.
+      # documentation for mysql prepares statements @ https://dev.mysql.com/doc/refman/8.0/en/sql-prepared-statements.html
+      def default_prepared_statements
+        false
+      end
+
       # Does this adapter support transactions in general?
       # HINT: This is +NOT* an official setting and only introduced to ElasticsearchRecord
       def supports_transactions?
@@ -236,7 +243,7 @@ module ActiveRecord # :nodoc:
         raise ::StandardError, 'ASYNC api calls are not supported' if async
 
         # resolve the API target
-        target = namespace == :core ? @connection : @connection.__send__(namespace)
+        target = namespace == :core ? raw_connection : raw_connection.__send__(namespace)
 
         __send__(:log, "#{namespace}.#{action}", arguments, name, async: async, log: log) do
           response = ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
@@ -258,6 +265,30 @@ module ActiveRecord # :nodoc:
 
       private
 
+      def connect
+        @raw_connection = self.class.new_client(@connection_parameters)
+      rescue ::ActiveRecord::ConnectionNotEstablished => ex
+        raise ex.set_pool(@pool)
+      end
+
+      def reconnect
+        @raw_connection = nil
+        connect
+      end
+
+      def active?
+        !!@raw_connection&.ping
+      end
+
+      # Disconnects from the database if already connected.
+      # Otherwise, this method does nothing.
+      def disconnect!
+        super
+        @raw_connection = nil
+      end
+
+      alias :reset! :reconnect!
+
       def type_map
         TYPE_MAP
       end

data/lib/elasticsearch_record/gem_version.rb

@@ -8,8 +8,8 @@ module ElasticsearchRecord
 
   module VERSION
     MAJOR = 1
-    MINOR = 7
-    TINY  = 2
+    MINOR = 8
+    TINY  = 1
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/elasticsearch_record/instrumentation/log_subscriber.rb

@@ -45,8 +45,8 @@ module ElasticsearchRecord
         query = payload[:arguments].except(:_qt).inspect.gsub(/:(\w+)=>/, '\1: ').truncate((payload[:truncate] || 1000), omission: color(' (pruned)', RED))
 
         # final coloring
-        name  = color(name, name_color(payload[:name]), true)
-        query = color(query, gate_color(payload[:gate], payload[:name]), true) if colorize_logging
+        name  = color(name, name_color(payload[:name]), bold: true)
+        query = color(query, gate_color(payload[:gate], payload[:name]), bold: true) if colorize_logging
 
         debug "  #{name} #{query.presence || '-/-'}"
       end

data/lib/elasticsearch_record/model_api.rb

@@ -269,8 +269,11 @@ module ElasticsearchRecord
 
       _connection.api(:core, :bulk, {
         index:   _index_name,
-        body:    if operation == :update
-                   data.map { |item| { operation => { _id: (item[:_id].presence || item['_id']), data: { doc: item.except(:_id, '_id') } } } }
+        body:    case operation
+                 when :update
+                   data.map { |item| { update: { _id: (item[:_id].presence || item['_id']), data: { doc: item.except(:_id, '_id') } } } }
+                 when :delete
+                   data.map { |item| { delete: { _id: (item[:_id].presence || item['_id']) } } }
                  else
                    data.map { |item| { operation => { _id: (item[:_id].presence || item['_id']), data: item.except(:_id, '_id') } } }
                  end,

data/lib/elasticsearch_record/model_schema.rb

@@ -58,7 +58,7 @@ module ElasticsearchRecord
 
       # clears schema-related instance variables.
       # @see ActiveRecord::ModelSchema::ClassMethods#reload_schema_from_cache
-      def reload_schema_from_cache
+      def reload_schema_from_cache(recursive = true)
         # we also need to clear our custom-defined variables
         @source_column_names     = nil
         @searchable_column_names = nil

data/lib/elasticsearch_record/persistence.rb

@@ -7,7 +7,7 @@ module ElasticsearchRecord
       # NOTICE: We don't want to mess up with the Arel-builder - so we send new data directly to the API
       # @param [ActiveModel::Attribute] values
       # @return [Object] id
-      def _insert_record(values)
+      def _insert_record(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)
 
@@ -23,7 +23,7 @@ module ElasticsearchRecord
             refresh:   true)
 
           # execute query and return inserted id
-          connection.insert(query, "#{self} Create")
+          connection.insert(query, "#{self} Create", returning: returning)
         end
       end
 

data/lib/elasticsearch_record/querying.rb

@@ -105,7 +105,7 @@ module ElasticsearchRecord
           # IMPORTANT: Always provide all columns
           columns: source_column_names)
 
-        connection.exec_query(query, "#{name} ES|QL", async: async)
+        connection.internal_exec_query(query, "#{name} ES|QL", async: async)
       end
 
 
@@ -122,7 +122,7 @@ module ElasticsearchRecord
           # IMPORTANT: Always provide all columns
           columns: source_column_names)
 
-        connection.exec_query(query, "#{name} Msearch", async: async)
+        connection.internal_exec_query(query, "#{name} Msearch", async: async)
       end
 
       # executes a search by provided +RAW+ query - supports +Elasticsearch::DSL+ gem if loaded

data/lib/elasticsearch_record/relation/calculation_methods.rb

@@ -64,9 +64,12 @@ module ElasticsearchRecord
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-boxplot-aggregation.html
       #
+      # @note returns *nil* on a *NullRelation*
+      #
       # @param [Symbol, String] column_name
+      # @return [Hash,nil]
       def boxplot(column_name)
-        calculate(:boxplot, column_name)
+        calculate_aggregation(:boxplot, column_name)
       end
 
       # A multi-value metrics aggregation that computes stats over numeric values extracted from the aggregated documents.      #
@@ -83,9 +86,12 @@ module ElasticsearchRecord
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-stats-aggregation.html
       #
+      # @note returns *nil* on a *NullRelation*
+      #
       # @param [Symbol, String] column_name
+      # @return [Hash,nil]
       def stats(column_name)
-        calculate(:stats, column_name)
+        calculate_aggregation(:stats, column_name)
       end
 
       # A multi-value metrics aggregation that computes statistics over string values extracted from the aggregated documents.
@@ -102,9 +108,12 @@ module ElasticsearchRecord
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-string-stats-aggregation.html
       #
+      # @note returns *nil* on a *NullRelation*
+      #
       # @param [Symbol, String] column_name
+      # @return [Hash,nil]
       def string_stats(column_name)
-        calculate(:string_stats, column_name)
+        calculate_aggregation(:string_stats, column_name)
       end
 
       # The matrix_stats aggregation is a numeric aggregation that computes the following statistics over a set of document fields:
@@ -118,9 +127,12 @@ module ElasticsearchRecord
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-matrix-stats-aggregation.html
       #
+      # @note returns *nil* on a *NullRelation*
+      #
       # @param [Array<Symbol|String>] column_names
+      # @return [Hash,nil]
       def matrix_stats(*column_names)
-        calculate(:matrix_stats, *column_names)
+        calculate_aggregation(:matrix_stats, *column_names)
       end
 
       # A multi-value metrics aggregation that calculates one or more
@@ -140,9 +152,12 @@ module ElasticsearchRecord
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-percentile-aggregation.html
       #
+      # @note returns *nil* on a *NullRelation*
+      #
       # @param [Symbol, String] column_name
+      # @return [Hash,nil]
       def percentiles(column_name)
-        calculate(:percentiles, column_name, node: :values)
+        calculate_aggregation(:percentiles, column_name, node: :values)
       end
 
       # A multi-value metrics aggregation that calculates one or more
@@ -165,10 +180,13 @@ module ElasticsearchRecord
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-percentile-rank-aggregation.html
       #
+      # @note returns *nil* on a *NullRelation*
+      #
       # @param [Symbol, String] column_name
       # @param [Array] values
+      # @return [Hash,nil]
       def percentile_ranks(column_name, values)
-        calculate(:percentile_ranks, column_name, opts: { values: values }, node: :values)
+        calculate_aggregation(:percentile_ranks, column_name, opts: { values: values }, node: :values)
       end
 
       # Calculates the cardinality on a given column. Returns +0+ if there's no row.
@@ -178,9 +196,12 @@ module ElasticsearchRecord
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-cardinality-aggregation.html
       #
+      # @note returns *nil* on a *NullRelation*
+      #
       # @param [Symbol, String] column_name
+      # @return [Integer,nil]
       def cardinality(column_name)
-        calculate(:cardinality, column_name, node: :value)
+        calculate_aggregation(:cardinality, column_name, node: :value)
       end
 
       # Calculates the average value on a given column. Returns +nil+ if there's no row. See #calculate for examples with options.
@@ -189,9 +210,12 @@ module ElasticsearchRecord
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-avg-aggregation.html
       #
+      # @note returns *nil* on a *NullRelation*
+      #
       # @param [Symbol, String] column_name
+      # @return [Float,nil]
       def average(column_name)
-        calculate(:avg, column_name, node: :value)
+        calculate_aggregation(:avg, column_name, node: :value)
       end
 
       # Calculates the minimum value on a given column. The value is returned
@@ -202,9 +226,12 @@ module ElasticsearchRecord
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-min-aggregation.html
       #
+      # @note returns *nil* on a *NullRelation*
+      #
       # @param [Symbol, String] column_name
+      # @return [Float,nil]
       def minimum(column_name)
-        calculate(:min, column_name, node: :value)
+        calculate_aggregation(:min, column_name, node: :value)
       end
 
       # Calculates the maximum value on a given column. The value is returned
@@ -215,9 +242,12 @@ module ElasticsearchRecord
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-max-aggregation.html
       #
+      # @note returns *nil* on a *NullRelation*
+      #
       # @param [Symbol, String] column_name
+      # @return [Float,nil]
       def maximum(column_name)
-        calculate(:max, column_name, node: :value)
+        calculate_aggregation(:max, column_name, node: :value)
       end
 
       # This single-value aggregation approximates the median absolute deviation of its search results.
@@ -232,9 +262,12 @@ module ElasticsearchRecord
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-median-absolute-deviation-aggregation.html
       #
+      # @note returns *nil* on a *NullRelation*
+      #
       # @param [Symbol, String] column_name
+      # @return [Float,nil]
       def median_absolute_deviation(column_name)
-        calculate(:median_absolute_deviation, column_name)
+        calculate_aggregation(:median_absolute_deviation, column_name)
       end
 
       # Calculates the sum of values on a given column. The value is returned
@@ -245,18 +278,27 @@ module ElasticsearchRecord
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-sum-aggregation.html
       #
+      # @note returns *nil* on a *NullRelation*
+      #
       # @param [Symbol, String] column_name (optional)
+      # @return [Float,nil]
       def sum(column_name)
-        calculate(:sum, column_name, node: :value)
+        calculate_aggregation(:sum, column_name, node: :value)
       end
 
       # creates a aggregation with the provided metric (e.g. :sum) and columns.
       # returns the metric node (default: :value) from the aggregations result.
+      #
+      # @note returns *nil* on a *NullRelation*
+      #
       # @param [Symbol, String] metric
       # @param [Array<Symbol|String>] columns
       # @param [Hash] opts - additional arguments that get merged with the metric definition
       # @param [Symbol] node (default: nil)
-      def calculate(metric, *columns, opts: {}, node: nil)
+      def calculate_aggregation(metric, *columns, opts: {}, node: nil)
+        # prevent execution on a *NullRelation*
+        return if null_relation?
+
         metric_key = "calculate_#{metric}"
 
         # spawn a new aggregation and return the aggs
@@ -272,6 +314,8 @@ module ElasticsearchRecord
           response[metric_key]
         end
       end
+
+      alias_method :calculate, :calculate_aggregation
     end
   end
 end

data/lib/elasticsearch_record/relation/query_methods.rb

@@ -188,8 +188,9 @@ module ElasticsearchRecord
       end
 
       def none! # :nodoc:
+        @none = true
         # tell the query it 'failed'
-        configure!(:__query__, status: :failed).extending!(ActiveRecord::NullRelation)
+        configure!(:__query__, status: :failed)
       end
 
       # creates a condition on the relation.

data/lib/elasticsearch_record/relation/result_methods.rb

@@ -132,11 +132,10 @@ module ElasticsearchRecord
             # resolve only data from hits->hits[{_source}]
             current_results        = if ids_only
                                        current_response['hits']['hits'].map { |result| result['_id'] }
-                                       # future with helper
-                                       # current_response['hits']['hits'].map.from_hash('_id')
                                      else
                                        current_response['hits']['hits'].map { |result| result['_source'].merge('_id' => result['_id']) }
                                      end
+
             current_results_length = current_results.length
 
             # check if we reached the required offset

data/lib/elasticsearch_record/relation/value_methods.rb

@@ -45,7 +45,7 @@ module ElasticsearchRecord
 
       # overwrite the limit_value setter, to provide a special behaviour of auto-setting the +max_result_window+.
       def limit_value=(limit)
-        if limit == '__max__' || (limit.nil? && delegate_query_nil_limit?)
+        if limit == '__max__' || limit == Float::INFINITY || (limit.nil? && delegate_query_nil_limit?)
           super(max_result_window)
         else
           super(limit)

data/lib/elasticsearch_record/result.rb

@@ -1,13 +1,19 @@
 # frozen_string_literal: true
 
+require "active_record/future_result"
+
 module ElasticsearchRecord
   class Result
     include Enumerable
 
     # creates an empty response
     # @return [ElasticsearchRecord::Result (frozen)]
-    def self.empty
-      new(nil).freeze
+    def self.empty(async: false) # :nodoc:
+      if async
+        EMPTY_ASYNC
+      else
+        EMPTY
+      end
     end
 
     attr_reader :response, :columns, :column_types
@@ -272,5 +278,11 @@ module ElasticsearchRecord
                               []
                             end
     end
+
+    EMPTY = new([].freeze, [].freeze, {}.freeze).freeze
+    private_constant :EMPTY
+
+    EMPTY_ASYNC = ::ActiveRecord::FutureResult::Complete.new(EMPTY).freeze
+    private_constant :EMPTY_ASYNC
   end
 end

data/lib/elasticsearch_record/schema_migration.rb

@@ -3,47 +3,20 @@
 require "active_record/schema_migration"
 
 module ElasticsearchRecord
-  class SchemaMigration < ElasticsearchRecord::Base # :nodoc:
-    class << self
-      def primary_key
-        "version"
-      end
+  class SchemaMigration < ::ActiveRecord::SchemaMigration
 
-      def table_name
-        "#{table_name_prefix}#{schema_migrations_table_name}#{table_name_suffix}"
-      end
-
-      def create_table
-        unless connection.table_exists?(table_name)
-          connection.create_table(table_name, id: false) do |t|
-            t.string :version, **connection.internal_string_options_for_primary_key
-          end
-        end
-      end
-
-      def drop_table
-        connection.drop_table table_name, if_exists: true
-      end
-
-      def normalize_migration_number(number)
-        "%.3d" % number.to_i
-      end
-
-      def normalized_versions
-        all_versions.map { |v| normalize_migration_number v }
-      end
-
-      def all_versions
-        order(:version).pluck(:version)
-      end
-
-      def table_exists?
-        connection.data_source_exists?(table_name)
-      end
+    def table_name
+      "#{ElasticsearchRecord::Base.table_name_prefix}#{ElasticsearchRecord::Base.schema_migrations_table_name}#{ElasticsearchRecord::Base.table_name_suffix}"
     end
 
-    def version
-      super.to_i
+    # overwrite method to fix the default limit (= 10) to support returning more than 10 migrations
+    def versions
+      sm = Arel::SelectManager.new(arel_table)
+      sm.project(arel_table[primary_key])
+      sm.order(arel_table[primary_key].asc)
+      sm.take(connection.max_result_window(table_name))
+
+      connection.select_values(sm, "#{self.class} Load")
     end
   end
 end

data/lib/elasticsearch_record.rb

@@ -70,7 +70,6 @@ end
 ActiveSupport.on_load(:active_record) do
   # load patches
   require 'elasticsearch_record/patches/active_record/relation_merger_patch'
-
   require 'elasticsearch_record/patches/arel/select_core_patch'
   require 'elasticsearch_record/patches/arel/select_manager_patch'
   require 'elasticsearch_record/patches/arel/select_statement_patch'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elasticsearch_record
 version: !ruby/object:Gem::Version
-  version: 1.7.2
+  version: 1.8.1
 platform: ruby
 authors:
 - Tobias Gonsior
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-10 00:00:00.000000000 Z
+date: 2024-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.1.0
 - !ruby/object:Gem::Dependency
   name: elasticsearch
   requirement: !ruby/object:Gem::Requirement