elastic_record 2.0.2 → 3.0.0

data/lib/elastic_record/errors.rb

@@ -3,6 +3,11 @@ module ElasticRecord
   end
 
   class ConnectionError < Error
+    attr_reader :status_code
+    def initialize(status_code, message)
+      @status_code = status_code
+      super(message)
+    end
   end
 
   class BulkError < Error

data/lib/elastic_record/index.rb

@@ -40,8 +40,10 @@ module ElasticRecord
     include Deferred
 
     attr_accessor :model
+
     attr_accessor :disabled
     attr_accessor :has_percolator
+    attr_accessor :partial_updates
 
     def initialize(model)
       @model = model
@@ -53,10 +55,18 @@ module ElasticRecord
       @mapping = mapping.deep_dup
     end
 
+    def alias_name=(name)
+      @alias_name = name
+    end
+
     def alias_name
       @alias_name ||= model.base_class.name.demodulize.underscore.pluralize
     end
 
+    def type=(name)
+      @type = name
+    end
+
     def type
       @type ||= model.base_class.name.demodulize.underscore
     end
@@ -84,7 +94,7 @@ module ElasticRecord
     private
 
       def new_index_name
-        "#{alias_name}_#{(Time.now.to_f * 100).to_i}"
+        "#{alias_name}_#{Time.now.utc.strftime('%Y%m%d_%H%M%S')}"
       end
 
   end

data/lib/elastic_record/index/deferred.rb

@@ -16,6 +16,7 @@ module ElasticRecord
         def initialize(index)
           self.index = index
           self.bulk_stack = []
+          @deferring_enabled = false
           reset!
         end
 

data/lib/elastic_record/index/documents.rb

@@ -2,38 +2,105 @@ require 'active_support/core_ext/object/to_query'
 
 module ElasticRecord
   class Index
-    module Documents
-      def index_record(record, index_name = nil)
-        return if disabled
+    class ScanSearch
+      attr_reader :scroll_id
+      attr_accessor :total_hits
+
+      def initialize(elastic_index, scroll_id, options = {})
+        @elastic_index  = elastic_index
+        @scroll_id      = scroll_id
+        @options        = options
+      end
 
-        index_document(record.send(record.class.primary_key), record.as_search, index_name)
+      def each_slice(&block)
+        while (hit_ids = request_more_ids).any?
+          hit_ids.each_slice(requested_batch_size, &block)
+        end
       end
 
-      def index_document(id, document, index_name = nil)
-        return if disabled
+      def request_more_ids
+        json = @elastic_index.scroll(@scroll_id, keep_alive)
+        json['hits']['hits'].map { |hit| hit['_id'] }
+      end
 
-        index_name ||= alias_name
+      def keep_alive
+        @options[:keep_alive] || (raise "Must provide a :keep_alive option")
+      end
 
+      def requested_batch_size
+        @options[:batch_size]
+      end
+    end
+
+    module Documents
+      def index_record(record, index_name: alias_name)
+        unless disabled
+          index_document(record.send(record.class.primary_key), record.as_search, index_name: index_name)
+        end
+      end
+
+      def update_record(record, index_name: alias_name)
+        unless disabled
+          update_document(record.send(record.class.primary_key), record.as_partial_update_document, index_name: index_name)
+        end
+      end
+
+      def index_document(id, document, parent: nil, index_name: alias_name)
         if batch = current_bulk_batch
-          batch << { index: { _index: index_name, _type: type, _id: id } }
+          instructions = { _index: index_name, _type: type, _id: id }
+          instructions[:parent] = parent if parent
+
+          batch << { index: instructions }
           batch << document
         else
-          connection.json_put "/#{index_name}/#{type}/#{id}", document
+          path = "/#{index_name}/#{type}/#{id}"
+          path << "?parent=#{parent}" if parent
+
+          connection.json_put path, document
         end
       end
 
-      def delete_document(id, index_name = nil)
+      def update_document(id, document, parent: nil, index_name: alias_name)
+        params = {doc: document, doc_as_upsert: true}
+
+        if batch = current_bulk_batch
+          instructions = { _index: index_name, _type: type, _id: id, _retry_on_conflict: 3 }
+          instructions[:parent] = parent if parent
+
+          batch << { update: instructions }
+          batch << params
+        else
+          path = "/#{index_name}/#{type}/#{id}/_update?retry_on_conflict=3"
+          path << "&parent=#{parent}" if parent
+
+          connection.json_post path, params
+        end
+      end
+
+      def delete_document(id,  parent: nil, index_name: alias_name)
+        raise "Cannot delete document with empty id" if id.blank?
         index_name ||= alias_name
 
         if batch = current_bulk_batch
-          batch << { delete: { _index: index_name, _type: type, _id: id } }
+          instructions = { _index: index_name, _type: type, _id: id, _retry_on_conflict: 3 }
+          instructions[:parent] = parent if parent
+          batch << { delete: instructions }
         else
-          connection.json_delete "/#{index_name}/#{type}/#{id}"
+          path = "/#{index_name}/#{type}/#{id}"
+          path << "&parent=#{parent}" if parent
+
+          connection.json_delete path
         end
       end
 
       def delete_by_query(query)
-        connection.json_delete "/#{alias_name}/#{type}/_query", query
+        scan_search = create_scan_search query
+
+        scan_search.each_slice do |ids|
+          bulk do
+            ids.each { |id| delete_document(id) }
+          end
+        end
       end
 
       def record_exists?(id)
@@ -53,6 +120,18 @@ module ElasticRecord
         get "_explain", elastic_query
       end
 
+      def create_scan_search(elastic_query, options = {})
+        options[:batch_size] ||= 100
+        options[:keep_alive] ||= ElasticRecord::Config.scroll_keep_alive
+
+        search_options = {search_type: 'scan', size: options[:batch_size], scroll: options[:keep_alive]}
+        json = search(elastic_query, search_options)
+
+        ScanSearch.new(self, json['_scroll_id'], options).tap do |scan_search|
+          scan_search.total_hits = json['hits']['total']
+        end
+      end
+
       def scroll(scroll_id, scroll_keep_alive)
         options = {scroll_id: scroll_id, scroll: scroll_keep_alive}
         connection.json_get("/_search/scroll?#{options.to_query}")
@@ -64,7 +143,7 @@ module ElasticRecord
         yield
 
         if current_bulk_batch.any?
-          body = current_bulk_batch.map { |action| "#{ActiveSupport::JSON.encode(action)}\n" }.join
+          body = current_bulk_batch.map { |action| "#{ElasticRecord::JSON.encode(action)}\n" }.join
           results = connection.json_post("/_bulk?#{options.to_query}", body)
           verify_bulk_results(results)
         end
@@ -72,12 +151,10 @@ module ElasticRecord
         connection.bulk_stack.pop
       end
 
-      def bulk_add(batch, index_name = nil)
-        index_name ||= alias_name
-
+      def bulk_add(batch, index_name: alias_name)
         bulk do
           batch.each do |record|
-            index_record(record, index_name)
+            index_record(record, index_name: index_name)
           end
         end
       end

data/lib/elastic_record/index/manage.rb

@@ -23,14 +23,6 @@ module ElasticRecord
         end
       end
 
-      def open(index_name)
-        connection.json_post("/#{index_name}/_open")
-      end
-
-      def close(index_name)
-        connection.json_post("/#{index_name}/_close")
-      end
-
       def exists?(index_name)
         connection.head("/#{index_name}") == '200'
       end

data/lib/elastic_record/index/mapping.rb

@@ -16,22 +16,13 @@ module ElasticRecord
         end
       end
 
-      def delete_mapping(index_name = alias_name)
-        connection.json_delete "/#{index_name}/#{type}"
-      end
-
       def mapping
         @mapping ||= {
-          _source: {
-            enabled: false
+          properties: {
           },
           _all: {
             enabled: false
           },
-          properties: {
-            created_at: {type: "date", index: "not_analyzed", format: "dateOptionalTime"},
-            updated_at: {type: "date", index: "not_analyzed", format: "dateOptionalTime"}
-          },
           dynamic_templates: [
             {
               no_string_analyzing: {

data/lib/elastic_record/json.rb

@@ -0,0 +1,29 @@
+module ElasticRecord
+  module JSON
+    class << self
+      def parser
+        @@parser ||= :active_support
+      end
+
+      def parser=(value)
+        @@parser = value
+      end
+
+      def decode(json)
+        if ElasticRecord::JSON.parser == :oj
+          Oj.compat_load(json)
+        else
+          ActiveSupport::JSON.decode(json)
+        end
+      end
+
+      def encode(data)
+        if ElasticRecord::JSON.parser == :oj
+          Oj.dump(data, mode: :compat)
+        else
+          ActiveSupport::JSON.encode(data)
+        end
+      end
+    end
+  end
+end

data/lib/elastic_record/relation.rb

@@ -22,10 +22,6 @@ module ElasticRecord
       search_results['hits']['total']
     end
 
-    def facets
-      search_results['facets']
-    end
-
     def aggregations
       search_results['aggregations']
     end
@@ -47,6 +43,11 @@ module ElasticRecord
       search_hits.map { |hit| hit['_id'] }
     end
 
+    def delete_all
+      find_ids_in_batches { |ids| klass.delete(ids) }
+      klass.elastic_index.delete_by_query(as_elastic)
+    end
+
     def ==(other)
       to_a == other
     end
@@ -72,7 +73,10 @@ module ElasticRecord
       end
 
       def search_results
-        @search_results ||= klass.elastic_index.search(as_elastic)
+        @search_results ||= begin
+          options = search_type_value ? {search_type: search_type_value} : {}
+          klass.elastic_index.search(as_elastic, options.update(fields: ''))
+        end
       end
 
       def load_hits(ids)

data/lib/elastic_record/relation/batches.rb

@@ -1,29 +1,5 @@
 module ElasticRecord
   class Relation
-    class ScanSearch
-      attr_reader :scroll_id
-      attr_accessor :total_hits
-
-      def initialize(model, scroll_id, options = {})
-        @model     = model
-        @scroll_id = scroll_id
-        @options   = options
-      end
-
-      def request_more_ids
-        json = @model.elastic_index.scroll(@scroll_id, keep_alive)
-        json['hits']['hits'].map { |hit| hit['_id'] }
-      end
-
-      def keep_alive
-        @options[:keep_alive] || (raise "Must provide a :keep_alive option")
-      end
-
-      def requested_batch_size
-        @options[:batch_size]
-      end
-    end
-
     module Batches
       def find_each(options = {})
         find_in_batches(options) do |records|
@@ -38,11 +14,11 @@ module ElasticRecord
       end
 
       def find_ids_in_batches(options = {}, &block)
-        scan_search = create_scan_search(options)
+        create_scan_search(options).each_slice(&block)
+      end
 
-        while (hit_ids = scan_search.request_more_ids).any?
-          hit_ids.each_slice(scan_search.requested_batch_size, &block)
-        end
+      def create_scan_search(options)
+        elastic_index.create_scan_search(as_elastic, options)
       end
 
       def reindex
@@ -50,18 +26,6 @@ module ElasticRecord
           elastic_index.bulk_add(batch)
         end
       end
-
-      def create_scan_search(options = {})
-        options[:batch_size] ||= 100
-        options[:keep_alive] ||= ElasticRecord::Config.scroll_keep_alive
-
-        search_options = {search_type: 'scan', size: options[:batch_size], scroll: options[:keep_alive]}
-        json = klass.elastic_index.search(as_elastic, search_options)
-
-        ElasticRecord::Relation::ScanSearch.new(klass, json['_scroll_id'], options).tap do |scan_search|
-          scan_search.total_hits = json['hits']['total']
-        end
-      end
     end
   end
 end

data/lib/elastic_record/relation/none.rb

@@ -9,10 +9,6 @@ module ElasticRecord
         0
       end
 
-      def facets
-        {}
-      end
-
       def aggregations
         {}
       end

data/lib/elastic_record/relation/search_methods.rb

@@ -1,6 +1,33 @@
 module ElasticRecord
   class Relation
     module SearchMethods
+      class FilterChain
+        def initialize(scope)
+          @scope = scope
+        end
+
+        def not(*filters)
+          add_filter_nodes_to_scope(filters) do |filter_node|
+            Arelastic::Filters::Not.new(filter_node)
+          end
+        end
+
+        def nested(path, *filters)
+          add_filter_nodes_to_scope(filters) do |filter_node|
+            Arelastic::Filters::Nested.new(path, filter_node)
+          end
+        end
+
+        def add_filter_nodes_to_scope(filters)
+          filter_value = @scope.send(:build_filter_nodes, filters).map do |filter_node|
+            yield filter_node
+          end
+
+          @scope.filter_values += filter_value
+          @scope
+        end
+      end
+
       Relation::MULTI_VALUE_METHODS.each do |name|
         define_method "#{name}_values" do
           @values[name] || []
@@ -35,8 +62,12 @@ module ElasticRecord
         self
       end
 
-      def filter(*args)
-        clone.filter!(*args)
+      def filter(opts = :chain, *rest)
+        if opts == :chain
+          FilterChain.new(clone)
+        else
+          clone.filter!(opts, *rest)
+        end
       end
 
       def find_by(*args)
@@ -78,18 +109,13 @@ module ElasticRecord
         end
       end
 
-      def facet!(name_or_facet, options = {})
-        if name_or_facet.is_a?(String)
-          self.facet_values += [arelastic.facet[name_or_facet].terms(name_or_facet, options)]
-        else
-          self.facet_values += [name_or_facet]
-        end
-
+      def search_type!(type)
+        self.search_type_value = type
         self
       end
 
-      def facet(facet_or_name, options = {})
-        clone.facet! facet_or_name, options
+      def search_type(type)
+        clone.search_type! type
       end
 
       def aggregate!(aggregation)
@@ -149,7 +175,6 @@ module ElasticRecord
             build_query_and_filter(query_value, filter_values),
             build_limit(limit_value),
             build_offset(offset_value),
-            build_facets(facet_values),
             build_aggregations(aggregation_values),
             build_orders(order_values)
           ].compact
@@ -178,9 +203,17 @@ module ElasticRecord
         end
 
         def build_filter(filters)
-          nodes = []
+          nodes = build_filter_nodes(filters)
 
-          filters.map do |filter|
+          if nodes.size == 1
+            nodes.first
+          elsif nodes.size > 1
+            Arelastic::Filters::And.new(nodes)
+          end
+        end
+
+        def build_filter_nodes(filters)
+          filters.each_with_object([]) do |filter, nodes|
             if filter.is_a?(Arelastic::Filters::Filter)
               nodes << filter
             elsif filter.is_a?(ElasticRecord::Relation)
@@ -200,27 +233,8 @@ module ElasticRecord
               end
             end
           end
-
-          if nodes.size == 1
-            nodes.first
-          elsif nodes.size > 1
-            Arelastic::Filters::And.new(nodes)
-          end
         end
 
-        # def normalize_value(value)
-        #   case value
-        #   when true
-        #     "T"
-        #   when false
-        #     "F"
-        #   when Time
-        #     value.iso8601
-        #   else
-        #     value
-        #   end
-        # end
-
         def build_limit(limit)
           if limit
             Arelastic::Searches::Size.new(limit)
@@ -237,10 +251,6 @@ module ElasticRecord
           Arelastic::Searches::Aggregations.new(aggregations) unless aggregations.empty?
         end
 
-        def build_facets(facets)
-          Arelastic::Searches::Facets.new(facets) unless facets.empty?
-        end
-
         def build_orders(orders)
           return if orders.empty?
 
@@ -248,7 +258,7 @@ module ElasticRecord
             if order.is_a?(Arelastic::Sorts::Sort)
               order
             else
-              Arelastic::Sorts::Sort.new(order)
+              Arelastic::Sorts::Field.new(order)
             end
           end