search_flip 1.0.0

data/irb.rb

@@ -0,0 +1,7 @@
+
+require "irb"
+$:.unshift "./lib"
+
+require "./test/test_helper.rb"
+
+IRB.start

data/lib/search_flip/aggregatable.rb

@@ -0,0 +1,69 @@
+
+module SearchFlip
+  # The SearchFlip::Aggregatable mixin provides handy methods for using
+  # the ElasticSearch aggregation framework, which can be chained with
+  # each other, all other criteria methods and even nested.
+  #
+  # @example
+  #   ProductIndex.where(available: true).aggregate(:tags, size: 50)
+  #   OrderIndex.aggregate(revenue: { sum: { field: "price" }})
+
+  module Aggregatable
+    def self.included(base)
+      base.class_eval do
+        attr_accessor :aggregation_values
+      end
+    end
+
+    # Adds an arbitrary aggregation to the request which can be chained as well
+    # as nested. Check out the examples and ElasticSearch docs for further
+    # details.
+    #
+    # @example Basic usage with optons
+    #   query = CommentIndex.where(public: true).aggregate(:user_id, size: 100)
+    #
+    #   query.aggregations(:user_id)
+    #   # => { 4 => #<SearchFlip::Result ...>, 7 => #<SearchFlip::Result ...>, ... }
+    #
+    # @example Simple range aggregation
+    #   ranges = [{ to: 50 }, { from: 50, to: 100 }, { from: 100 }]
+    #
+    #   ProductIndex.aggregate(price_range: { range: { field: "price", ranges: ranges }})
+    #
+    # @example Basic nested aggregation
+    #   # When nesting aggregations, the return value of the aggregate block is
+    #   # used.
+    #
+    #   OrderIndex.aggregate(:user_id, order: { revenue: "desc" }) do |aggregation|
+    #     aggregation.aggregate(revenue: { sum: { field: "price" }})
+    #   end
+    #
+    # @example Nested histogram aggregation
+    #   OrderIndex.aggregate(histogram: { date_histogram: { field: "price", interval: "month" }}) do |aggregation|
+    #     aggregation.aggregate(:user_id)
+    #   end
+    #
+    # @example Nested aggregation with filters
+    #   OrderIndex.aggregate(average_price: {}) do |aggregation|
+    #     aggregation = aggregation.match_all
+    #     aggregation = aggregation.where(user_id: current_user.id) if current_user
+    #
+    #     aggregation.aggregate(average_price: { avg: { field: "price" }})
+    #   end
+
+    def aggregate(field_or_hash, options = {}, &block)
+      fresh.tap do |criteria|
+        hash = field_or_hash.is_a?(Hash) ? field_or_hash : { field_or_hash => { terms: { field: field_or_hash }.merge(options) } }
+
+        if block
+          aggregation = block.call(SearchFlip::Aggregation.new)
+
+          field_or_hash.is_a?(Hash) ? hash[field_or_hash.keys.first].merge!(aggregation.to_hash) : hash[field_or_hash].merge!(aggregation.to_hash)
+        end
+
+        criteria.aggregation_values = (aggregation_values || {}).merge(hash)
+      end
+    end
+  end
+end
+

data/lib/search_flip/aggregation.rb

@@ -0,0 +1,57 @@
+
+module SearchFlip
+  # The SearchFlip::Aggregation class puts together everything
+  # required to use the ElasticSearch aggregation framework via mixins and
+  # adds a method to convert it to a hash format to be used in the request.
+
+  class Aggregation
+    include SearchFlip::Filterable
+    include SearchFlip::Aggregatable
+
+    # @api private
+    #
+    # Converts the aggregation to a hash format that can be used in the request.
+    #
+    # @return [Hash] A hash version of the aggregation
+
+    def to_hash
+      res = {}
+      res[:aggregations] = aggregation_values if aggregation_values
+
+      if must_values || search_values || must_not_values || should_values || filter_values
+        if SearchFlip.version.to_i >= 2
+          res[:filter] = {
+            bool: {}.
+              merge(must_values || search_values ? { must: (must_values || []) + (search_values || []) } : {}).
+              merge(must_not_values ? { must_not: must_not_values } : {}).
+              merge(should_values ? { should: should_values } : {}).
+              merge(filter_values ? { filter: filter_values } : {})
+          }
+        else
+          filters = (filter_values || []) + (must_not_values || []).map { |must_not_value| { not: must_not_value } }
+
+          queries = {}.
+            merge(must_values || search_values ? { must: (must_values || []) + (search_values || []) } : {}).
+            merge(should_values ? { should: should_values } : {})
+
+          filters_and_queries = filters + (queries.size > 0 ? [bool: queries] : [])
+
+          res[:filter] = filters_and_queries.size > 1 ? { and: filters_and_queries } : filters_and_queries.first
+        end
+      end
+
+      res
+    end
+
+    # @api private
+    #
+    # Simply dups the object for api compatability.
+    #
+    # @return [SearchFlip::Aggregation] The dupped object
+
+    def fresh
+      dup
+    end
+  end
+end
+

data/lib/search_flip/bulk.rb

@@ -0,0 +1,152 @@
+
+module SearchFlip
+  # The SearchFlip::Bulk class implements the bulk support, ie it collects
+  # single requests and emits batches of requests.
+  #
+  # @example
+  #   SearchFlip::Bulk.new "http://127.0.0.1:9200/index/type/_bulk" do |bulk|
+  #     bulk.create record.id, MyIndex.serialize(record)
+  #     bulk.index record.id, MyIndex.serialize(record), version: record.version, version_type: "external"
+  #     bulk.delete record.id, routing: record.user_id
+  #     bulk.update record.id, doc: MyIndex.serialize(record)
+  #   end
+
+  class Bulk
+    class Error < StandardError; end
+
+    attr_accessor :url, :count, :options, :ignore_errors
+
+    # Builds and yields a new Bulk object, ie initiates the buffer, yields,
+    # sends batches of records each time the buffer is full, and sends a final
+    # batch after the yielded code returns and there are still documents
+    # present within the buffer.
+    #
+    # @example Basic use
+    #   SearchFlip::Bulk.new "http://127.0.0.1:9200/index/type/_bulk" do |bulk|
+    #     # ...
+    #   end
+    #
+    # @example Ignore certain errors
+    #   SearchFlip::Bulk.new "http://127.0.0.1:9200/index/type/_bulk", 1_000, ignore_errors: [409] do |bulk|
+    #     # ...
+    #   end
+    #
+    # @param url [String] The endpoint to send bulk requests to
+    # @param count [Fixnum] The maximum number of documents per bulk request
+    # @param options [Hash] Options for the bulk requests
+    # @option options ignore_errors [Array, Fixnum] Errors that should be
+    #   ignored. If you eg want to ignore errors resulting from conflicts,
+    #   you can specify to ignore 409 here.
+    # @option options raise [Boolean] If you want the bulk requests to never
+    #   raise any exceptions (fire and forget), you can pass false here.
+    #   Default is true.
+
+    def initialize(url, count = 1_000, options = {})
+      self.url = url
+      self.count = count
+      self.options = options
+      self.ignore_errors = Array(options[:ignore_errors]).to_set if options[:ignore_errors]
+
+      init
+
+      yield self
+
+      upload if @num > 0
+    end
+
+    # Adds an index request to the bulk batch.
+    #
+    # @param id [Fixnum, String] The document/record id
+    # @param json [String] The json document
+    # @param options [options] Options for the index request, like eg routing
+    #   and versioning
+
+    def index(id, object, options = {})
+      perform :index, id, SearchFlip::JSON.generate(object), options
+    end
+
+    # Adds an index request to the bulk batch
+    #
+    # @see #index
+
+    def import(*args)
+      index(*args)
+    end
+
+    # Adds a create request to the bulk batch.
+    #
+    # @param id [Fixnum, String] The document/record id
+    # @param json [String] The json document
+    # @param options [options] Options for the index request, like eg routing
+    #   and versioning
+
+    def create(id, object, options = {})
+      perform :create, id, SearchFlip::JSON.generate(object), options
+    end
+
+    # Adds a update request to the bulk batch.
+    #
+    # @param id [Fixnum, String] The document/record id
+    # @param json [String] The json document
+    # @param options [options] Options for the index request, like eg routing
+    #   and versioning
+
+    def update(id, object, options = {})
+      perform :update, id, SearchFlip::JSON.generate(object), options
+    end
+
+    # Adds a delete request to the bulk batch.
+    #
+    # @param id [Fixnum, String] The document/record id
+    # @param options [options] Options for the index request, like eg routing
+    #   and versioning
+
+    def delete(id, options = {})
+      perform :delete, id, nil, options
+    end
+
+    private
+
+    def init
+      @payload = ""
+      @num = 0
+    end
+
+    def upload
+      response = SearchFlip::HTTPClient.headers(accept: "application/json", content_type: "application/x-ndjson").put(url, body: @payload, params: ignore_errors ? {} : { filter_path: "errors" })
+
+      return if options[:raise] == false
+
+      parsed_response = response.parse
+
+      return unless parsed_response["errors"]
+
+      raise(SearchFlip::Bulk::Error, response[0 .. 30]) unless ignore_errors
+
+      parsed_response["items"].each do |item|
+        item.each do |_, _item|
+          status = _item["status"]
+
+          raise(SearchFlip::Bulk::Error, SearchFlip::JSON.generate(_item)) if !status.between?(200, 299) && !ignore_errors.include?(status)
+        end
+      end
+    ensure
+      init
+    end
+
+    def perform(action, id, json = nil, options = {})
+      @payload << SearchFlip::JSON.generate(action => options.merge(_id: id))
+      @payload << "\n"
+
+      if json
+        @payload << json
+        @payload << "\n"
+      end
+
+      @num += 1
+
+      upload if @num >= count
+    end
+  end
+end
+

data/lib/search_flip/config.rb

@@ -0,0 +1,21 @@
+
+module SearchFlip
+  # Queries and returns the ElasticSearch version used.
+  #
+  # @example
+  #   SearchFlip.version # => e.g. 2.4.1
+  #
+  # @return [String] The ElasticSearch version
+
+  def self.version
+    @version ||= SearchFlip::HTTPClient.get("#{Config[:base_url]}/").parse["version"]["number"]
+  end
+
+  Config = {
+    index_prefix: nil,
+    base_url: "http://127.0.0.1:9200",
+    bulk_limit: 1_000,
+    auto_refresh: false
+  }
+end
+