elasticsearch_record 1.8.2 → 3.0.0

data/lib/elasticsearch_record/relation/query_methods.rb

@@ -50,6 +50,7 @@ module ElasticsearchRecord
       end
 
       # same like +#configure!+, but on the same relation (no spawn)
+      # @return [self]
       def configure!(*args)
         check_if_method_has_arguments!(__callee__, args)
 
@@ -259,7 +260,7 @@ module ElasticsearchRecord
             unless _valid_unscoping_values.include?(scope)
               raise ArgumentError, "Called unscope() with invalid unscoping argument ':#{scope}'. Valid arguments are :#{_valid_unscoping_values.to_a.join(", :")}."
             end
-            assert_mutability!
+            assert_modifiable!
             @values.delete(scope)
           when Hash
             scope.each do |key, target_value|
@@ -274,6 +275,27 @@ module ElasticsearchRecord
         self
       end
 
+      # overwrite to prevent metadata fields within the projection.
+      # Metadata fields (like '_id' or '_score') are NOT part of the +_source+ node, so they cannot be
+      # resolved through the +_source+-filter this method builds - providing them would silently create
+      # a filter that never matches.
+      # HINT: This is different to the +pluck+-method which allows to resolve meta keys directly.
+      # see @ Arel::Visitors::ElasticsearchQuery#visit_Selects
+      # @param [Array] fields
+      def select(*fields)
+        # IMPORTANT: +select+ can also be called with a block (and without any fields) - in this case
+        # ActiveRecord directly forwards to +super()+, so we must not interfere here.
+        if fields.any? && (invalid = _invalid_projection_fields(fields)).present?
+          raise(ActiveRecord::UnknownAttributeReference,
+                "Unable to select metadata attributes: #{invalid.map(&:inspect).join(", ")}. " \
+                "Metadata fields are not part of the '_source' node but are always returned and accessible within the record. " \
+                "(e.g. #{klass.name}.first.#{invalid.first})."
+          )
+        end
+
+        super
+      end
+
       private
 
       def build_where_clause(opts, _rest = [])
@@ -342,6 +364,14 @@ module ElasticsearchRecord
 
         arel
       end
+
+      # returns any provided field that is a metadata field and therefore not resolvable
+      # through a projection.
+      # @param [Array] fields
+      # @return [Array<String>]
+      def _invalid_projection_fields(fields)
+        ActiveRecord::ConnectionAdapters::ElasticsearchAdapter.metadata_keys & fields.flatten.select{|fld| fld.is_a?(String) || fld.is_a?(Symbol)}.map(&:to_s)
+      end
     end
   end
 end

data/lib/elasticsearch_record/relation/result_methods.rb

@@ -66,7 +66,7 @@ module ElasticsearchRecord
       # @return [nil, String] - either returns the pit_id (no block given) or nil
       def point_in_time(keep_alive: '1m')
         # resolve a initial PIT id
-        initial_pit_id = klass.connection.api(:core, :open_point_in_time, { index: klass.table_name, keep_alive: keep_alive }, "#{klass} Open Pit").dig('id')
+        initial_pit_id = klass.connection.api(:open_point_in_time, { index: klass.table_name, keep_alive: keep_alive }, "#{klass} Open Pit").dig('id')
 
         return initial_pit_id unless block_given?
 
@@ -74,7 +74,7 @@ module ElasticsearchRecord
         yield initial_pit_id
 
         # close PIT
-        klass.connection.api(:core, :close_point_in_time, { body: { id: initial_pit_id } }, "#{klass} Close Pit")
+        klass.connection.api(:close_point_in_time, { body: { id: initial_pit_id } }, "#{klass} Close Pit")
 
         # return nil if everything was ok
         nil
@@ -90,13 +90,12 @@ module ElasticsearchRecord
       #
       # @param [String] keep_alive - how long to keep alive (for each single request) - default: '1m'
       # @param [Integer] batch_size - how many results per query (default: 1000 - this means at least 10 queries before reaching the +max_result_window+)
-      # @param [Boolean] ids_only - resolve ids only from results
       # @return [Integer, Array] either returns the results-array (no block provided) or the total amount of results
-      def pit_results(keep_alive: '1m', batch_size: 1000, ids_only: false)
-        raise(ArgumentError, "Batch size cannot be above the 'max_result_window' (#{klass.max_result_window}) !") if batch_size > klass.max_result_window
+      def pit_results(keep_alive: '1m', batch_size: 1000)
+        raise(ArgumentError, "Batch size cannot be above the 'max_result_window' (#{batch_size} > #{klass.max_result_window}) !") if batch_size > klass.max_result_window
 
         # check if limit or offset values where provided
-        results_limit  = limit_value ? limit_value : Float::INFINITY
+        results_limit = limit_value ? limit_value : Float::INFINITY
         results_offset = offset_value ? offset_value : 0
 
         # search_after requires a order - we resolve a order either from provided value or by default ...
@@ -107,9 +106,6 @@ module ElasticsearchRecord
         # see @ https://www.elastic.co/guide/en/elasticsearch/reference/current/paginate-search-results.html
         relation.order!(_shard_doc: :asc) if relation.order_values.empty? && klass.connection.access_shard_doc?
 
-        # resolve ids only
-        relation.reselect!('_id') if ids_only
-
         # clear limit & offset
         relation.offset!(nil).limit!(nil)
 
@@ -117,47 +113,47 @@ module ElasticsearchRecord
         relation.configure!(:__query__, { index: nil })
 
         # we store the results in this array
-        results       = []
+        results = []
         results_total = 0
 
         # resolve a new pit and auto-close after we finished
         point_in_time(keep_alive: keep_alive) do |pit_id|
+          # set the initial pit hash, used to configure the ES query
           current_pit_hash = { pit: { id: pit_id, keep_alive: keep_alive } }
 
           # resolve new data until we got all we need
           loop do
             # change pit settings & limit (spawn is required, since a +resolve+ will make the relation immutable)
-            current_response = relation.spawn.configure!(current_pit_hash).limit!(batch_size).resolve('Pit Results').response
+            # @type [ElasticsearchRecord::Result]
+            current_result = relation.spawn.configure!(current_pit_hash).limit!(batch_size).resolve('Pit Results')
 
-            # resolve only data from hits->hits[{_source}]
-            current_results        = if ids_only
-                                       current_response['hits']['hits'].map { |result| result['_id'] }
-                                     else
-                                       current_response['hits']['hits'].map { |result| result['_source'].merge('_id' => result['_id']) }
-                                     end
+            # resolve all results, depending on the existing query (select, ...)
+            current_results = current_result.to_ary
 
+            # temporary store the absolute length - used for pagination or stop
             current_results_length = current_results.length
 
             # check if we reached the required offset
             if results_offset < current_results_length
               # check for parts
-              # (maybe a offset 6300 was provided but the batch size is 1000 - so we need to skip a part ...)
+              # (maybe an offset of 6300 was provided but the batch size is 1000 - so we need to skip a part ...)
               results_from = results_offset > 0 ? results_offset : 0
-              results_to   = (results_total + current_results_length - results_from) > results_limit ? results_limit - results_total + results_from - 1 : -1
+              results_to = (results_total + current_results_length - results_from) > results_limit ? results_limit - results_total + results_from - 1 : -1
 
-              ranged_results = current_results[results_from..results_to]
+              # reduce the *current_results* by calculated +from..to+ range
+              current_results = current_results[results_from..results_to] if results_from != 0 || results_to != -1
 
               if block_given?
-                yield ranged_results
+                yield current_results
               else
-                results += ranged_results
+                results += current_results
               end
 
               # add to total
-              results_total += ranged_results.length
+              results_total += current_results.length
             end
 
-            # -------- BREAK conditions --------
+            # -- BREAK conditions --------------------------------------------------------------------------------------
 
             # we reached our maximum value
             break if results_total >= results_limit
@@ -166,22 +162,24 @@ module ElasticsearchRecord
             break if current_results_length < batch_size
 
             # additional security - prevents infinite loops
-            raise(::ActiveRecord::StatementInvalid, "'pit_results' aborted due an infinite loop error (invalid or missing order)") if current_pit_hash[:search_after] == current_response['hits']['hits'][-1]['sort'] && current_pit_hash[:pit][:id] == current_response['pit_id']
+            if current_pit_hash[:search_after] == current_result.response['hits']['hits'][-1]['sort'] && current_pit_hash[:pit][:id] == current_result.response['pit_id']
+              raise(::ActiveRecord::StatementInvalid, "'pit_results' aborted due an infinite loop error (invalid or missing order)")
+            end
 
-            # -------- NEXT LOOP changes --------
+            # -- NEXT LOOP changes -------------------------------------------------------------------------------------
 
             # reduce the offset
             results_offset -= current_results_length
 
             # assign new pit
-            current_pit_hash = { search_after: current_response['hits']['hits'][-1]['sort'], pit: { id: current_response['pit_id'], keep_alive: keep_alive } }
+            current_pit_hash = { search_after: current_result.response['hits']['hits'][-1]['sort'], pit: { id: current_result.response['pit_id'], keep_alive: keep_alive } }
 
-            # we need to justify the +batch_size+ if the query will reach over the limit
-            batch_size       = results_limit - results_total if results_offset < batch_size && (results_total + batch_size) > results_limit
+            # we need to justify the +batch_size+ if the query reaches over the limit
+            batch_size = results_limit - results_total if results_offset < batch_size && (results_total + batch_size) > results_limit
           end
         end
 
-        # return results array or total value
+        # returns either to total number of +pit+ results or an array of all collected results
         if block_given?
           results_total
         else
@@ -193,17 +191,19 @@ module ElasticsearchRecord
 
       # executes a delete query in a +point_in_time+ scope.
       # this will provide the possibility to delete more than the +max_result_window+ (default: 10000) docs in a batched process.
-      # @param [String] keep_alive
-      # @param [Integer] batch_size
-      # @param [Boolean] refresh index after delete finished (default: true)
+      # @param [String] keep_alive - defines the keep alive time per +pit+ (not in total) - should be relative to *batch_size*
+      # @param [Integer] batch_size - the size of entries to delete per +pit+
+      # @param [Boolean] refresh - auto-refresh index after delete finished (default: true)
       # @return [Integer] total amount of deleted docs
-      def pit_delete(keep_alive: '1m', batch_size: 1000, refresh: true)
-        delete_count = select('_id').pit_results(keep_alive: keep_alive, batch_size: batch_size, ids_only: true) do |ids|
+      def pit_delete(keep_alive: '1m', batch_size: 1_000, refresh: true)
+        # spawns a new query with disabled results (so only ids will be resolved)
+        delete_count = spawn.meta_only!.pit_results(keep_alive: keep_alive, batch_size: batch_size) do |results|
           # skip empty results
-          next unless ids.any?
+          next unless results.any?
 
-          # delete all IDs, but do not refresh index, yet
-          klass.connection.api(:core, :bulk, { index: klass.table_name, body: ids.map { |id| { delete: { _id: id } } }, refresh: false }, "#{klass} Pit Delete")
+          # delete all IDs through +API+
+          # does not refresh index at this point (this is done below, if not disabled)
+          klass.connection.api(:bulk, { index: klass.table_name, body: results.map { |result| { delete: { _id: result['_id'] } } }, refresh: false }, "#{klass} Pit Delete")
         end
 
         # refresh index
@@ -249,24 +249,28 @@ module ElasticsearchRecord
       end
 
       # sets query as "hits"-only query (drops the aggs from the query)
+      # @return [self]
       def hits_only!
         configure!({ aggs: nil })
-
-        self
       end
 
       # sets query as "aggs"-only query (drops the size & sort options - so no hits will return)
+      # @return [self]
       def aggs_only!
         configure!({ size: 0, from: nil, sort: nil, _source: false })
-
-        self
       end
 
       # sets query as "total"-only query (drops the size, sort & aggs options - so no hits & aggs will be returned)
+      # @return [self]
       def total_only!
         configure!({ size: 0, from: nil, aggs: nil, sort: nil, _source: false })
+      end
 
-        self
+      # sets query as "meta"-only query (drops aggs and source).
+      # This is used to prevent resolving documents from the index and only returns "meta" information (like _id, _score, _type, ...)
+      # @return [self]
+      def meta_only!
+        select(::ElasticsearchRecord::Query::COLUMNS_NONE).configure!({ aggs: nil, _source: false })
       end
     end
   end

data/lib/elasticsearch_record/relation/value_methods.rb

@@ -8,7 +8,7 @@ module ElasticsearchRecord
 
       def kind_value=(value)
         # checks if records are already loaded - in this case we cannot mutate the query anymore
-        assert_mutability!
+        assert_modifiable!
 
         @values[:kind] = value.to_sym
       end
@@ -18,7 +18,7 @@ module ElasticsearchRecord
       end
 
       def configure_value=(value)
-        assert_mutability!
+        assert_modifiable!
 
         @values[:configure] = value
       end
@@ -28,7 +28,7 @@ module ElasticsearchRecord
       end
 
       def query_clause=(value)
-        assert_mutability!
+        assert_modifiable!
 
         @values[:query] = value
       end
@@ -38,7 +38,7 @@ module ElasticsearchRecord
       end
 
       def aggs_clause=(value)
-        assert_mutability!
+        assert_modifiable!
 
         @values[:aggs] = value
       end

data/lib/elasticsearch_record/result.rb

@@ -7,8 +7,8 @@ module ElasticsearchRecord
     include Enumerable
 
     # creates an empty response
-    # @return [ElasticsearchRecord::Result (frozen)]
-    def self.empty(async: false) # :nodoc:
+    # @return [ElasticsearchRecord::Result (frozen), ActiveRecord::FutureResult::Complete (frozen)]
+    def self.empty(async: false)
       if async
         EMPTY_ASYNC
       else
@@ -23,7 +23,7 @@ module ElasticsearchRecord
     # @param [Array] columns
     # @param [Hash] column_types
     def initialize(response, columns = [], column_types = {})
-      # contains either the response or creates a empty hash (if nil)
+      # contains either the response or creates an empty hash (if nil)
       @response = response.presence || {}
 
       # used to build computed_results
@@ -39,37 +39,69 @@ module ElasticsearchRecord
       response['took']
     end
 
+    # returns the response result string
+    # @return [String]
+    def result
+      response['result'] || ''
+    end
+
     # returns the response total value.
     # either chops the +total+ value directly from response, from hits or aggregations.
     # @return [Integer]
     def total
-      # chop total only
-      @total ||= _chop_total
+      # chop total from response and not from the generated data
+      @total ||= _total
     end
 
-    # returns the response RAW hits hash.
-    # PLEASE NOTE: Does not return the nested hits (+response['hits']['hits']+) array!
-    # @return [ActiveSupport::HashWithIndifferentAccess, Hash]
-    def hits
-      response.key?('hits') ? response['hits'].with_indifferent_access : {}
-    end
-
-    # Returns the RAW +_source+ data from each hit - aka. +rows+.
+    # Returns the RAW +_source+ data from each hit.
     # PLEASE NOTE: The array will only contain the RAW data from each +_source+ (meta info like '_id' or '_score' are not included)
     # @return [Array]
     def results
-      return [] unless response['hits']
+      # IMPORTANT: check against missing hits without any '_source' node.
+      # This happens if the Elasticsearch query has the  +_source:false+ flag!
+      if response['hits']
+        response['hits']['hits'].map { |doc| doc['_source'] || {} }
+      elsif _tabular?
+        # a tabular (+SQL+ / +ES|QL+) response has no '_source' node - the row values are the data
+        _results_from_tabular
+      else
+        []
+      end
+    end
 
-      response['hits']['hits'].map { |result| result['_source'] }
+    # returns an array of all rows.
+    # => All result values, depending on the provided columns.
+    # The +rows+ is used by the ActiveRecord ConnectionAdapters and must not be removed!
+    # @return [Array]
+    def rows
+      # a tabular (+SQL+ / +ES|QL+) response is ALREADY positional - and it is positional to the
+      # response's own columns, not to the (requested) +columns+ of the query.
+      return _tabular_values if _tabular?
+
+      # IMPORTANT: without provided +columns+ we cannot build positional rows - mapping over an
+      # empty +columns+ array would return an empty array per hit and silently lose all data.
+      # In this case we fall back to the raw +_source+ values.
+      return results.map(&:values) if columns.blank?
+
+      results.map { |doc|
+        columns.map { |column|
+          doc[column]
+        }
+      }
     end
 
-    # The +rows+ alias is used by the ActiveRecord ConnectionAdapters and must not be removed!
-    alias_method :rows, :results
+    # returns the response RAW hits hash.
+    # PLEASE NOTE: Does not return the nested hits (+response['hits']['hits']+) array!
+    #
+    # @return [ActiveSupport::HashWithIndifferentAccess, Hash]
+    def hits
+      response['hits']&.with_indifferent_access || {}
+    end
 
     # returns the response RAW aggregations hash.
     # @return [ActiveSupport::HashWithIndifferentAccess, Hash]
     def aggregations
-      response.key?('aggregations') ? response['aggregations'].with_indifferent_access : {}
+      response['aggregations']&.with_indifferent_access || {}
     end
 
     # returns the (nested) bucket values (and aggregated values) from the response aggregations.
@@ -84,13 +116,14 @@ module ElasticsearchRecord
     end
 
     # Returns true if this result set includes the column named +name+.
-    # used by ActiveRecord
+    # used by +ActiveRecord+
     def includes_column?(name)
       @columns&.include?(name)
     end
 
     # Returns the number of elements in the response array.
-    # Either uses the +hits+ length or the +responses+ length _(msearch)_.
+    # Either uses the +hits+ length, the +responses+ length _(msearch)_ or the length of the
+    # tabular value rows _(SQL / ES|QL)_.
     # @return [Integer]
     def length
       if response.key?('hits')
@@ -98,6 +131,9 @@ module ElasticsearchRecord
       elsif response.key?('responses')
         # used by +msearch+
         response['responses'].length
+      elsif _tabular?
+        # used by +sql+ & +esql+
+        _tabular_values.length
       else
         0
       end
@@ -131,51 +167,56 @@ module ElasticsearchRecord
       computed_results[idx]
     end
 
-    # Returns the last record from the rows collection.
+    # Returns the last record(s) from the *computed_results* collection.
     def last(n = nil)
       n ? computed_results.last(n) : computed_results.last
     end
 
-    # returns the response result string
-    # @return [String]
-    def result
-      response['result'] || ''
-    end
-
     # used by ActiveRecord
     def cancel # :nodoc:
       self
     end
 
-    # used by ActiveRecord
+    # used by ActiveRecord for "pluck"
     def cast_values(type_overrides = {})
-      # :nodoc:
+      # fast escape, if no hits are available
+      return [] unless response['hits']
+
+      # HINT: This is separated to avoid allocating a (nested) array per row
       if columns.one?
-        # Separated to avoid allocating an array per row
+        # resolve the column key
         key = columns.first
 
-        type = if type_overrides.is_a?(Array)
-                 type_overrides.first
-               else
-                 column_type(columns.first, type_overrides)
-               end
+        # resolve type from overrides or +#column_type+ method
+        type = type_overrides.is_a?(Array) ? type_overrides.first : column_type(key, type_overrides)
 
-        computed_results.map do |result|
-          type.deserialize(result[key])
+        # EDGE-case for metadata fields
+        if ActiveRecord::ConnectionAdapters::ElasticsearchAdapter.metadata_keys.include?(key)
+          # directly read from doc
+          response['hits']['hits'].map { |doc| type.deserialize(doc[key]) }
+        else
+          results.map do |result|
+            type.deserialize(result[key])
+          end
         end
       else
-        types = if type_overrides.is_a?(Array)
-                  type_overrides
-                else
-                  columns.map { |name| column_type(name, type_overrides) }
-                end
+        # resolve types from overrides or +#column_type+ method
+        types = type_overrides.is_a?(Array) ? type_overrides : columns.map { |name| column_type(name, type_overrides) }
 
         size = types.size
 
-        computed_results.map do |result|
+        # EDGE-case for metadata fields - they have to be resolved from the doc, so we merge them into the +_source+
+        rows = if (ActiveRecord::ConnectionAdapters::ElasticsearchAdapter.metadata_keys & columns).any?
+                 response['hits']['hits'].map { |doc|
+                   (doc['_source'] || {}).merge(doc.slice(*ActiveRecord::ConnectionAdapters::ElasticsearchAdapter.metadata_keys))
+                 }
+               else
+                 response['hits']['hits'].map { |doc| doc['_source'] || {} }
+               end
+
+        rows.map do |result|
           Array.new(size) { |i|
-            key = columns[i]
-            types[i].deserialize(result[key])
+            types[i].deserialize(result[columns[i]])
           }
         end
       end
@@ -185,45 +226,84 @@ module ElasticsearchRecord
 
     # used by ActiveRecord
     def column_type(name, type_overrides = {})
-      type_overrides.fetch(name, Type.default_value)
+      type_overrides.fetch(name, ::ActiveRecord::Type.default_value)
     end
 
-    # chops total value from response
+    # resolves total value from response
     # @return [Integer]
-    def _chop_total
+    def _total
       return self.response['total'] if self.response.key?('total')
       return self.response['hits']['total']['value'] if self.response.key?('hits')
       return self.response['aggregations'].count if self.response.key?('aggregations')
-      return self.response['_shards']['total'] if self.response.key?('_shards')
+      # a tabular response has no total - the transferred rows are all there is
+      return _tabular_values.length if _tabular?
 
       0
     end
 
+    # true if the response is TABULAR - which is what the +sql+ & +esql+ APIs return instead of a
+    # (nested) 'hits' node: a flat 'columns' definition and positional value rows.
+    # @return [Boolean]
+    def _tabular?
+      response.key?('columns') && (response.key?('rows') || response.key?('values'))
+    end
+
+    # returns the column names of a tabular response.
+    # Both APIs describe their columns as a {'name' =>, 'type' =>} pair.
+    # @return [Array<String>]
+    def _tabular_columns
+      response['columns'].map { |column| column['name'] }
+    end
+
+    # returns the positional value rows of a tabular response.
+    # PLEASE NOTE: the +sql+ API names this node 'rows', the +esql+ API names it 'values'.
+    # @return [Array<Array>]
+    def _tabular_values
+      response['rows'] || response['values']
+    end
+
+    # used for +sql+ & +esql+ results
+    # IMPORTANT: the rows are positional to the RESPONSE columns - not to the (requested) +columns+
+    # of the query. A projecting query (e.g. 'SELECT name FROM ...') returns fewer columns, so
+    # zipping against the query's columns would shift every value.
+    # @return [Array]
+    def _results_from_tabular
+      # We freeze the strings to prevent them getting duped when
+      # used as keys in ActiveRecord::Base's @attributes hash.
+      keys = _tabular_columns.map(&:-@)
+
+      _tabular_values.map { |row| keys.zip(row).to_h }
+    end
+
     # used for +msearch+ results
     # @return [Array]
-    def _results_for_responses
+    def _results_from_responses
       response['responses'].map { |response| self.class.new(response, self.columns, self.column_types) }
     end
 
     # used for +search+ results
     # @return [Array]
-    def _results_for_hits
+    def _results_from_hits
       # PLEASE NOTE: the 'hits' response has multiple nodes: BASE nodes & the +_source+ node.
-      # The real data is within the source node, but we also want the BASE nodes for possible score & type check
-      base_fields = ActiveRecord::ConnectionAdapters::ElasticsearchAdapter.base_structure_keys
+      # The real data is within the source node, but we also want the METADATA nodes for possible score & type check
+      metadata_fields = ActiveRecord::ConnectionAdapters::ElasticsearchAdapter.metadata_keys
 
       # check for provided columns
       if @columns.present?
         # We freeze the strings to prevent them getting duped when
         # used as keys in ActiveRecord::Base's @attributes hash.
-        # ALSO IMPORTANT: remove base_fields from possible provided columns
-        columns = @columns ? (@columns - base_fields).map(&:-@) : []
+        # IMPORTANT: remove *metadata_fields* from possible provided columns ( &:-@ -> freeze strings )
+        columns = (@columns - metadata_fields).map(&:-@)
 
         # this is the hashed result array
         response['hits']['hits'].map { |doc|
-          result = doc.slice(*base_fields)
+          # allocate new result hash with all known metadata keys ('_id', ...)
+          result = doc.slice(*metadata_fields)
+
+          # iterate through each requested column
           columns.each do |column|
-            result[column] = doc['_source'][column]
+            # in case no source was provided, it prevents an exception
+            result[column] = doc.dig('_source', column)
           end
 
           result
@@ -234,7 +314,8 @@ module ElasticsearchRecord
 
         # this is the hashed result array
         response['hits']['hits'].map { |doc|
-          doc.slice(*base_fields).merge(doc['_source'])
+          # in case no source was provided, it prevents an exception
+          doc.slice(*metadata_fields).merge!(doc['_source'] || {})
         }
       end
     end
@@ -270,10 +351,13 @@ module ElasticsearchRecord
     # @return [Array]
     def computed_results
       @computed_results ||= if response.key?('hits')
-                              _results_for_hits
+                              _results_from_hits
                             elsif response.key?('responses')
                               # used by +msearch+
-                              _results_for_responses
+                              _results_from_responses
+                            elsif _tabular?
+                              # used by +sql+ & +esql+
+                              _results_from_tabular
                             else
                               []
                             end

data/lib/elasticsearch_record/schema_migration.rb

@@ -14,9 +14,12 @@ module ElasticsearchRecord
       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")
+      @pool.with_connection do |connection|
+        sm.take(connection.max_result_window(table_name))
+
+        connection.select_values(sm, "#{self.class} Load")
+      end
     end
   end
 end