elasticsearch-persistence-queryable 0.1.8

data/lib/elasticsearch/persistence/null_relation.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Elasticsearch
+  module Persistence
+    module NullRelation # :nodoc:
+      def pluck(*column_names)
+        []
+      end
+
+      def delete_all
+        0
+      end
+
+      def update_all(_updates)
+        0
+      end
+
+      def delete(_id_or_array)
+        0
+      end
+
+      def empty?
+        true
+      end
+
+      def none?
+        true
+      end
+
+      def any?
+        false
+      end
+
+      def one?
+        false
+      end
+
+      def many?
+        false
+      end
+
+      def exists?(_conditions = :none)
+        false
+      end
+
+      def or(other)
+        other.spawn
+      end
+
+
+        def exec_queries
+          @records = OpenStruct.new(klass: Elasticsearch::Persistence::Repository::Class, total: 0, results: []).freeze
+        end
+    end
+  end
+end

data/lib/elasticsearch/persistence/query_cache.rb

@@ -0,0 +1,68 @@
+require "active_support/core_ext/module"
+
+module Elasticsearch
+  module Persistence
+    module QueryCache
+      module CacheMethods
+        mattr_accessor :force_cache
+        mattr_accessor :cache_store
+        mattr_accessor :cache_store_expire_in
+
+        @@cache_store_expire_in = 300
+
+        @@force_cache = false
+
+        def cache
+          Elasticsearch::Persistence.force_cache = true
+          lm = yield
+          Elasticsearch::Persistence.force_cache = false
+          lm
+        end
+
+        def setup_store!
+          case Elasticsearch::Persistence.cache_store
+          when :redis_store
+            ActiveSupport::Cache::RedisStore
+          when :memory_store
+            ActiveSupport::Cache::MemoryStore
+          else
+            ActiveSupport::Cache::MemoryStore
+          end.new(namespace: "elasticsearch", expires_in: Elasticsearch::Persistence.cache_store_expire_in)
+        end
+      end
+
+      def store
+        @query_cache ||= Elasticsearch::Persistence.setup_store!
+      end
+
+      def cache_query(query, klass)
+        cache_key = sha(query)
+        Elasticsearch::Persistence.force_cache
+        result = if store.exist?(cache_key) && Elasticsearch::Persistence.force_cache
+            ActiveSupport::Notifications.instrument "cache.query.elasticsearch",
+              name: klass.name,
+              query: query
+
+            store.fetch cache_key
+          else
+            res = []
+            ActiveSupport::Notifications.instrument "query.elasticsearch",
+              name: klass.name,
+              query: query do
+              res = yield
+            end
+
+            store.write(cache_key, res) if Elasticsearch::Persistence.force_cache
+            res
+          end
+        result.dup
+      end
+
+      private
+
+      def sha(str)
+        Digest::SHA256.new.hexdigest(str)
+      end
+    end
+  end
+end

data/lib/elasticsearch/persistence/querying.rb

@@ -0,0 +1,21 @@
+module Elasticsearch
+  module Persistence
+      module Querying
+        delegate :first, :first!, :last, :last!, :exists?, :has_field?, :any?, :many?, to: :all
+        delegate :order, :limit, :size, :sort, :where, :rewhere, :eager_load, :includes,  :create_with, :none, :unscope, to: :all
+        delegate :or_filter, :filter, :fields, :source, :highlight, :aggregation, to: :all
+        delegate :skip_callbacks, :routing, to: :all
+        delegate :search_options, :routing, to: :all
+        delegate :must, :must_not, :should, :where_not, :query_string, to: :all
+
+        def fetch_results(es)
+          unless es.count?
+            gateway.search(es.to_elastic, es.search_options)
+          else
+            gateway.count(es.to_elastic, es.search_options)
+          end
+        end
+
+      end
+  end
+end

data/lib/elasticsearch/persistence/relation/delegation.rb

@@ -0,0 +1,130 @@
+module Elasticsearch
+  module Persistence
+    module Delegation # :nodoc:
+      module DelegateCache
+        def relation_delegate_class(klass) # :nodoc:
+          @relation_delegate_cache[klass]
+        end
+
+        def initialize_relation_delegate_cache # :nodoc:
+          @relation_delegate_cache = cache = {}
+          [
+            Elasticsearch::Persistence::Relation,
+          ].each do |klass|
+            delegate = Class.new(klass) {
+              include ClassSpecificRelation
+            }
+            const_set klass.name.gsub("::", "_"), delegate
+            cache[klass] = delegate
+          end
+        end
+
+        def self.extended(child_class)
+          child_class.initialize_relation_delegate_cache
+          super
+        end
+      end
+
+      extend ActiveSupport::Concern
+
+      # This module creates compiled delegation methods dynamically at runtime, which makes
+      # subsequent calls to that method faster by avoiding method_missing. The delegations
+      # may vary depending on the klass of a relation, so we create a subclass of Relation
+      # for each different klass, and the delegations are compiled into that subclass only.
+
+      BLACKLISTED_ARRAY_METHODS = [
+        :compact!, :flatten!, :reject!, :reverse!, :rotate!, :map!,
+        :shuffle!, :slice!, :sort!, :sort_by!, :delete_if,
+        :keep_if, :pop, :shift, :delete_at, :compact, :select!,
+      ].to_set # :nodoc:
+
+      delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to_ary, :join, to: :to_a
+      delegate :inner_hits, :aggregations, :highlights, :total, to: :to_a
+
+      delegate :mapping, :index_name, :document_type, :to => :klass
+
+      module ClassSpecificRelation # :nodoc:
+        extend ActiveSupport::Concern
+
+        included do
+          @delegation_mutex = Mutex.new
+        end
+
+        module ClassMethods # :nodoc:
+          def name
+            superclass.name
+          end
+
+          def delegate_to_scoped_klass(method)
+            @delegation_mutex.synchronize do
+              return if method_defined?(method)
+
+              if method.to_s =~ /\A[a-zA-Z_]\w*[!?]?\z/
+                module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                    def #{method}(*args, &block)
+                      scoping { @klass.#{method}(*args, &block) }
+                    end
+                  RUBY
+              else
+                define_method method do |*args, &block|
+                  scoping { @klass.public_send(method, *args, &block) }
+                end
+              end
+            end
+          end
+
+          def delegate(method, opts = {})
+            @delegation_mutex.synchronize do
+              return if method_defined?(method)
+              super
+            end
+          end
+        end
+
+        protected
+
+        def method_missing(method, *args, &block)
+          if @klass.respond_to?(method)
+            self.class.delegate_to_scoped_klass(method)
+            scoping { @klass.public_send(method, *args, &block) }
+          else
+            super
+          end
+        end
+      end
+
+      module ClassMethods # :nodoc:
+        def create(klass, *args)
+          relation_class_for(klass).new(klass, *args)
+        end
+
+        private
+
+        def relation_class_for(klass)
+          klass.relation_delegate_class(self)
+        end
+      end
+
+      def respond_to?(method, include_private = false)
+        super || @klass.respond_to?(method, include_private) ||
+          array_delegable?(method)
+      end
+
+      protected
+
+      def array_delegable?(method)
+        Array.method_defined?(method) && BLACKLISTED_ARRAY_METHODS.exclude?(method)
+      end
+
+      def method_missing(method, *args, &block)
+        if @klass.respond_to?(method)
+          scoping { @klass.public_send(method, *args, &block) }
+        elsif array_delegable?(method)
+          to_a.public_send(method, *args, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/persistence/relation/finder_methods.rb

@@ -0,0 +1,39 @@
+module Elasticsearch
+  module Persistence
+
+      module FinderMethods
+
+        def first
+          return results.first if @loaded
+          spawn.first!.results.first
+        end
+
+        def first!
+          spawn.sort(Hash[default_sort_key, :asc]).spawn.size(1)
+          self
+        end
+
+        def last
+          return results.last if @loaded
+          spawn.last!.results.first
+        end
+
+        def last!
+          spawn.sort(Hash[default_sort_key, :desc]).spawn.size(1)
+          self
+        end
+
+        def count
+          return results.count if @loaded
+          spawn.count!
+        end
+
+        def count!
+          @values[:count] = true
+          @values.delete(:size)
+          spawn.to_a["count"]
+        end
+
+      end
+    end
+end

data/lib/elasticsearch/persistence/relation/merger.rb

@@ -0,0 +1,179 @@
+require 'active_support/core_ext/hash/keys'
+require "set"
+
+module Elasticsearch
+  module Persistence
+    class Relation
+      class HashMerger # :nodoc:
+        attr_reader :relation, :hash
+
+        def initialize(relation, hash)
+          hash.assert_valid_keys(*Relation::VALUE_METHODS)
+
+          @relation = relation
+          @hash     = hash
+        end
+
+        def merge
+          Merger.new(relation, other).merge
+        end
+
+        # Applying values to a relation has some side effects. E.g.
+        # interpolation might take place for where values. So we should
+        # build a relation to merge in rather than directly merging
+        # the values.
+        def other
+          other = Relation.create(relation.klass)
+          hash.each { |k, v|
+            if k == :joins
+              if Hash === v
+                other.joins!(v)
+              else
+                other.joins!(*v)
+              end
+            elsif k == :select
+              other._select!(v)
+            else
+              other.send("#{k}!", v)
+            end
+          }
+          other
+        end
+      end
+
+      class Merger # :nodoc:
+        attr_reader :relation, :values, :other
+
+        def initialize(relation, other)
+          @relation = relation
+          @values   = other.values
+          @other    = other
+        end
+
+        NORMAL_VALUES = [:where, :first, :last, :filter]
+
+        def normal_values
+          NORMAL_VALUES
+        end
+
+        def merge
+          normal_values.each do |name|
+            value = values[name]
+            # The unless clause is here mostly for performance reasons (since the `send` call might be moderately
+            # expensive), most of the time the value is going to be `nil` or `.blank?`, the only catch is that
+            # `false.blank?` returns `true`, so there needs to be an extra check so that explicit `false` values
+            # don't fall through the cracks.
+
+            unless value.nil? || (value.blank? && false != value)
+              if name == :select
+                relation._select!(*value)
+              elsif name == :filter
+                values.each do |v|
+                  relation.send("#{name}!", v.first, v.last)
+                end
+              else
+                relation.send("#{name}!", *value)
+              end
+            end
+          end
+
+          merge_multi_values
+          merge_single_values
+          #merge_joins
+
+          relation
+        end
+
+        private
+
+        def merge_joins
+          return if values[:joins].blank?
+
+          if other.klass == relation.klass
+            relation.joins!(*values[:joins])
+          else
+            joins_dependency, rest = values[:joins].partition do |join|
+              case join
+              when Hash, Symbol, Array
+                true
+              else
+                false
+              end
+            end
+
+            join_dependency = ActiveRecord::Associations::JoinDependency.new(other.klass,
+                                                                             joins_dependency,
+                                                                             [])
+            relation.joins! rest
+
+            @relation = relation.joins join_dependency
+          end
+        end
+
+        def merge_multi_values
+          lhs_wheres = relation.where_values
+          rhs_wheres = values[:where] || []
+
+          lhs_filters = relation.filter_values
+          rhs_filters = values[:filter] || []
+
+          removed, kept = partition_overwrites(lhs_wheres, rhs_wheres)
+
+          where_values = kept + rhs_wheres
+
+          filters_removed, filters_kept = partition_overwrites(lhs_wheres, rhs_wheres)
+          filter_values =  rhs_filters
+
+
+          relation.where_values = where_values.empty? ? nil : where_values
+          relation.filter_values = filter_values.empty? ? nil : filter_values
+
+          if values[:reordering]
+            # override any order specified in the original relation
+            relation.reorder! values[:order]
+          elsif values[:order]
+            # merge in order_values from relation
+            relation.order! values[:order]
+          end
+
+          relation.extend(*values[:extending]) unless values[:extending].blank?
+        end
+
+        def merge_single_values
+          #relation.from_value          = values[:from] unless relation.from_value
+          #relation.lock_value          = values[:lock] unless relation.lock_value
+
+          unless values[:create_with].blank?
+            relation.create_with_value = (relation.create_with_value || {}).merge(values[:create_with])
+          end
+        end
+
+        def filter_binds(lhs_binds, removed_wheres)
+          return lhs_binds if removed_wheres.empty?
+
+          set = Set.new removed_wheres.map { |x| x.left.name.to_s }
+          lhs_binds.dup.delete_if { |col,_| set.include? col.name }
+        end
+
+        # Remove equalities from the existing relation with a LHS which is
+        # present in the relation being merged in.
+        # returns [things_to_remove, things_to_keep]
+        def partition_overwrites(lhs_wheres, rhs_wheres)
+          if lhs_wheres.empty? || rhs_wheres.empty?
+            return [[], lhs_wheres]
+          end
+
+          nodes = rhs_wheres.find_all do |w|
+            w.respond_to?(:operator) && w.operator == :==
+          end
+          seen = Set.new(nodes) { |node| node.left }
+
+          lhs_wheres.partition do |w|
+            w.respond_to?(:operator) && w.operator == :== && seen.include?(w.left)
+          end
+        end
+      end
+    end
+  end
+end
+