elasticsearch_record 1.0.0

data/lib/elasticsearch_record/result.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module ElasticsearchRecord
+  class Result
+    include Enumerable
+
+    # creates an empty response
+    # @return [ElasticsearchRecord::Result (frozen)]
+    def self.empty
+      new(nil).freeze
+    end
+
+    attr_reader :response, :columns, :column_types
+
+    # initializes a new result object
+    # @param [Elasticsearch::API::Response, Object, nil] response
+    # @param [Array] columns
+    # @param [Hash] column_types
+    def initialize(response, columns = [], column_types = {})
+      # contains either the response or creates a empty hash (if nil)
+      @response = response.presence || {}
+
+      # used to build computed_results
+      @columns = columns
+
+      # used to cast values
+      @column_types = column_types
+    end
+
+    # returns the response duration time
+    # @return [Integer]
+    def took
+      response['took']
+    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
+    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 values from the hits - aka. +rows+.
+    # PLEASE NOTE: The array will only contain the RAW data from each +_source+ (meta info like '_score' is not included)
+    # The +rows+ alias use used by the ActiveRecord ConnectionAdapters and must not be removed!
+    # @return [Array]
+    def results
+      return [] unless response['hits']
+
+      response['hits']['hits'].map { |result| result['_source'] }
+    end
+
+    alias_method :rows, :results
+
+    # returns the response RAW aggregations hash.
+    # @return [ActiveSupport::HashWithIndifferentAccess, Hash]
+    def aggregations
+      response.key?('aggregations') ? response['aggregations'].with_indifferent_access : {}
+    end
+
+    # Returns true if this result set includes the column named +name+.
+    # 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)_.
+    # @return [Integer]
+    def length
+      if response.key?('hits')
+        response['hits']['hits'].length
+      elsif response.key?('responses')
+        # used by +msearch+
+        response['responses'].length
+      else
+        0
+      end
+    end
+
+    # Calls the given block once for each element in row collection, passing
+    # row as parameter.
+    #
+    # Returns an +Enumerator+ if no block is given.
+    def each(&block)
+      if block_given?
+        computed_results.each(&block)
+      else
+        computed_results.to_enum { @computed_results.size }
+      end
+    end
+
+    # Returns true if there are no records, otherwise false.
+    def empty?
+      length == 0
+    end
+
+    # Returns an array of hashes representing each row record.
+    def to_ary
+      computed_results
+    end
+
+    alias :to_a :to_ary
+
+    def [](idx)
+      computed_results[idx]
+    end
+
+    # Returns the last record from the rows collection.
+    def last(n = nil)
+      n ? computed_results.last(n) : computed_results.last
+    end
+
+    # used by ActiveRecord
+    def result # :nodoc:
+      self
+    end
+
+    # used by ActiveRecord
+    def cancel # :nodoc:
+      self
+    end
+
+    # used by ActiveRecord
+    def cast_values(type_overrides = {})
+      # :nodoc:
+      if columns.one?
+        # Separated to avoid allocating an array per row
+        key = columns.first
+
+        type = if type_overrides.is_a?(Array)
+                 type_overrides.first
+               else
+                 column_type(columns.first, type_overrides)
+               end
+
+        computed_results.map do |result|
+          type.deserialize(result[key])
+        end
+      else
+        types = if type_overrides.is_a?(Array)
+                  type_overrides
+                else
+                  columns.map { |name| column_type(name, type_overrides) }
+                end
+
+        size = types.size
+
+        computed_results.map do |result|
+          Array.new(size) { |i|
+            key = columns[i]
+            types[i].deserialize(result[key])
+          }
+        end
+      end
+    end
+
+    private
+
+    # used by ActiveRecord
+    def column_type(name, type_overrides = {})
+      type_overrides.fetch(name, Type.default_value)
+    end
+
+    # chops total value from response
+    # @return [Integer]
+    def _chop_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')
+
+      0
+    end
+
+    # used for +msearch+ results
+    # @return [Array]
+    def _results_for_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
+      # 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
+
+      # 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(&:-@) : []
+
+        # this is the hashed result array
+        response['hits']['hits'].map { |doc|
+          result = doc.slice(*base_fields)
+          columns.each do |column|
+            result[column] = doc['_source'][column]
+          end
+
+          result
+        }
+      else
+        # if we don't have any columns we just resolve the _source data as it is
+        # this might end up in unknown (but mapped) attributes (if they are stored as nil in ES)
+
+        # this is the hashed result array
+        response['hits']['hits'].map { |doc|
+          doc.slice(*base_fields).merge(doc['_source'])
+        }
+      end
+    end
+
+    # builds computed results (used to build ActiveRecord models)
+    # @return [Array]
+    def computed_results
+      @computed_results ||= if response.key?('hits')
+                              _results_for_hits
+                            elsif response.key?('responses')
+                              # used by +msearch+
+                              _results_for_responses
+                            else
+                              []
+                            end
+    end
+  end
+end

data/lib/elasticsearch_record/statement_cache.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ElasticsearchRecord
+  class StatementCache < ActiveRecord::StatementCache
+
+    class PartialQuery < ActiveRecord::StatementCache::PartialQuery # :nodoc:
+      def initialize(values)
+        @values = values
+        # no need to create indexes
+      end
+
+      def sql_for(binds, connection)
+        # dup original array
+        claims = @values.dup
+
+        # substitute binds
+        claims.each do |claim|
+          # action, args = claim
+          claim[1] = deep_substitute_binds(claim[1], binds, connection)
+        end
+
+        # build a new query collector
+        collector = ::Arel::Collectors::ElasticsearchQuery.new
+
+        claims.each do |claim|
+          collector << claim
+        end
+
+        collector
+      end
+
+      private
+
+      def deep_substitute_binds(thing, binds, connection)
+        if thing.is_a?(ActiveRecord::StatementCache::Substitute)
+          value = binds.shift
+          if ActiveModel::Attribute === value
+            value = value.value_for_database
+          end
+          connection.quote(value)
+        elsif thing.is_a?(Hash)
+          thing.transform_values { |val|
+            deep_substitute_binds(val, binds, connection)
+          }
+        elsif thing.is_a?(Array)
+          thing.map { |val|
+            deep_substitute_binds(val, binds, connection)
+          }
+        else
+          thing
+        end
+      end
+    end
+
+    class PartialQueryCollector < ActiveRecord::StatementCache::PartialQueryCollector # :nodoc:
+      def add_bind(obj)
+        super
+
+        # only add binds, no parts - so we need to remove the previously set part
+        @parts.pop
+
+        self
+      end
+
+      def add_binds(binds, proc_for_binds = nil)
+        super
+
+        # only add binds, no parts - so we need to remove the previously set part
+        if binds.size == 1
+          @parts.pop
+        else
+          @parts.pop((binds.size * 2) - 1)
+        end
+
+        self
+      end
+    end
+
+    def self.partial_query(values)
+      PartialQuery.new(values)
+    end
+
+    def self.partial_query_collector
+      PartialQueryCollector.new
+    end
+  end
+end

data/lib/elasticsearch_record/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'gem_version'
+
+module ElasticsearchRecord
+  # Returns the version of the currently loaded Gem as a <tt>Gem::Version</tt>
+  def self.version
+    gem_version
+  end
+end

data/lib/elasticsearch_record.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# VERSION
+require_relative 'elasticsearch_record/version'
+
+require 'active_record'
+
+# new arel
+require 'arel/collectors/elasticsearch_query'
+require 'arel/nodes/select_agg'
+require 'arel/nodes/select_configure'
+require 'arel/nodes/select_kind'
+require 'arel/nodes/select_query'
+require 'arel/visitors/elasticsearch'
+
+# new adapter
+require 'active_record/connection_adapters/elasticsearch_adapter'
+
+module ElasticsearchRecord
+  extend ActiveSupport::Autoload
+
+  eager_autoload do
+    autoload :Base
+    autoload :Core
+    autoload :ModelSchema
+    autoload :Persistence
+    autoload :Querying
+    autoload :Query
+    autoload :Result
+    autoload :StatementCache
+  end
+
+  module Extensions
+    extend ActiveSupport::Autoload
+
+    autoload :Relation
+  end
+
+  module Relation
+    extend ActiveSupport::Autoload
+
+    autoload :CalculationMethods
+    autoload :CoreMethods
+    autoload :QueryClause
+    autoload :QueryClauseTree
+    autoload :QueryMethods
+    autoload :ResultMethods
+    autoload :ValueMethods
+  end
+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'
+  require 'elasticsearch_record/patches/arel/update_manager_patch'
+  require 'elasticsearch_record/patches/arel/update_statement_patch'
+end

data/sig/elasticsearch_record.rbs

@@ -0,0 +1,4 @@
+module ElasticsearchRecord
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: elasticsearch_record
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tobias Gonsior
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: elasticsearch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.4'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: 'ElasticsearchRecord is a ActiveRecord-fork and tries to provide the
+  same functionality for Elasticsearch.
+
+  '
+email:
+- info@ruby-smart.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- docs/CHANGELOG.md
+- docs/CODE_OF_CONDUCT.md
+- docs/LICENSE.txt
+- lib/active_record/connection_adapters/elasticsearch/column.rb
+- lib/active_record/connection_adapters/elasticsearch/database_statements.rb
+- lib/active_record/connection_adapters/elasticsearch/quoting.rb
+- lib/active_record/connection_adapters/elasticsearch/schema_statements.rb
+- lib/active_record/connection_adapters/elasticsearch/type.rb
+- lib/active_record/connection_adapters/elasticsearch/type/format_string.rb
+- lib/active_record/connection_adapters/elasticsearch/type/multicast_value.rb
+- lib/active_record/connection_adapters/elasticsearch/type/object.rb
+- lib/active_record/connection_adapters/elasticsearch/type/range.rb
+- lib/active_record/connection_adapters/elasticsearch_adapter.rb
+- lib/arel/collectors/elasticsearch_query.rb
+- lib/arel/nodes/select_agg.rb
+- lib/arel/nodes/select_configure.rb
+- lib/arel/nodes/select_kind.rb
+- lib/arel/nodes/select_query.rb
+- lib/arel/visitors/elasticsearch.rb
+- lib/elasticsearch_record.rb
+- lib/elasticsearch_record/base.rb
+- lib/elasticsearch_record/core.rb
+- lib/elasticsearch_record/extensions/relation.rb
+- lib/elasticsearch_record/gem_version.rb
+- lib/elasticsearch_record/instrumentation.rb
+- lib/elasticsearch_record/instrumentation/controller_runtime.rb
+- lib/elasticsearch_record/instrumentation/log_subscriber.rb
+- lib/elasticsearch_record/instrumentation/railtie.rb
+- lib/elasticsearch_record/model_schema.rb
+- lib/elasticsearch_record/patches/active_record/relation_merger_patch.rb
+- lib/elasticsearch_record/patches/arel/select_core_patch.rb
+- lib/elasticsearch_record/patches/arel/select_manager_patch.rb
+- lib/elasticsearch_record/patches/arel/select_statement_patch.rb
+- lib/elasticsearch_record/patches/arel/update_manager_patch.rb
+- lib/elasticsearch_record/patches/arel/update_statement_patch.rb
+- lib/elasticsearch_record/persistence.rb
+- lib/elasticsearch_record/query.rb
+- lib/elasticsearch_record/querying.rb
+- lib/elasticsearch_record/relation/calculation_methods.rb
+- lib/elasticsearch_record/relation/core_methods.rb
+- lib/elasticsearch_record/relation/query_clause.rb
+- lib/elasticsearch_record/relation/query_clause_tree.rb
+- lib/elasticsearch_record/relation/query_methods.rb
+- lib/elasticsearch_record/relation/result_methods.rb
+- lib/elasticsearch_record/relation/value_methods.rb
+- lib/elasticsearch_record/result.rb
+- lib/elasticsearch_record/statement_cache.rb
+- lib/elasticsearch_record/version.rb
+- sig/elasticsearch_record.rbs
+homepage: https://github.com/ruby-smart/elasticsearch_record
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ruby-smart/elasticsearch_record
+  source_code_uri: https://github.com/ruby-smart/elasticsearch_record
+  changelog_uri: https://github.com/ruby-smart/elasticsearch_record/blob/main/docs/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: ActiveRecord functionality for Elasticsearch indexes & documents.
+test_files: []