elasticated 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38febd11375f1593d887dfa64c008e6b559e4b77
-  data.tar.gz: 6cfaa6521ae4d55a7ed9ca37cc415acc33c02cf8
+  metadata.gz: 7c6d361a271487eaaa00bad98fc637d71577f84f
+  data.tar.gz: a1ad71c40b64d1681fe08558eaf0a6b7d19e49e2
 SHA512:
-  metadata.gz: 4c0663916c7c1b3137c42065d5e51cc2dee51d4b70e53b2ae4ce4a8f199be8830c4fc4eea8da1e05b4409230b32baed127fcbbde692958351fea2cf4af9a0000
-  data.tar.gz: 853799f2868ad8a545ee100558195d421c9c591f6fd7e71a1a0d5c1698b313edb5f4513e62f6600a9c06d0eec211efb29c05e48063ab0683ab91cadbf423b030
+  metadata.gz: c3c712d491f5846c8445765b5532fc0c3de738a429be5d00e1bbd6c11f1812e711eaaaa6facf0edad4a6563570aa243b15e748652ebbc82d0aebd3d1d329eacc
+  data.tar.gz: 40d195a39ecea6dc083487956a8442b69f7cf27e5947274a22f55c5fce64640f2708a53e16a3acd77fade4bb2e32cd38d4cff420e953d200293d28b5156cb524

data/README.md

@@ -1,3 +1,125 @@
-# elasticated
+# Elasticated
 
 Elasticsearch Wrapper, with Query & Mapping Builders
+
+**HOW TO** instantiate a repository
+```ruby
+repository = Elasticated::Repository.new # pointing to localhost
+repository = Elasticated::Repository.new host: 'http://user:pass@192.168.1.2:9200' # pointing to some secured server
+repository = Elasticated::Repository.new host: 'myhost', index: 'myindex', type: 'mytype' # pointing to some type of some index
+```
+
+**HOW TO** build a query
+```ruby
+query = Query.build do
+  filter do
+    equal :first_name, 'Pablo'
+  end
+  conditions do
+    between :age, 20, 25
+    must_not do
+      wildcard :second_name, 'Santiago*'
+    end
+    should do
+      gt :age, 23
+      lt :age, 22
+    end
+    minimum_should_match 1
+  end
+  post do
+    equal :city, 'CABA'
+  end
+  aggregations do
+    group :register_number, size: 10
+  end
+  from 5
+  size 15
+end
+query.build # see the result
+```
+
+**HOW TO** execute a search
+```ruby
+repository = Repository.new
+query = Query.new
+repository.execute_count query
+repository.execute_search query
+repository.execute_aggregations query
+repository.execute_aggregated_search query
+repository.delete_by query
+repository.exists? query
+```
+
+**HOW TO** build a document, index or update it
+```ruby
+document = Document.create do |doc|
+  doc.id = 'my_unique_id'
+  doc.index = 'myindex'
+  doc.type = 'mytype'
+  doc.source = { user: 'Pablo', some_field: 'some_value' }
+end
+repository = Repository.new
+repository.index_document document
+repository.update_document document
+```
+
+**HOW TO** start a *resumable* scroll
+```ruby
+repository = Elasticated::Repository.new
+query = Elasticated::Query.new
+# prepare the 'search' object
+search = repository.prepare_search query, index: 'my_index', type: 'my_type'
+# fetch the first page of results
+results = search.start
+# get the scroll_id, and use it again later
+scroll_id = search.scroll_id # also results.scroll_id is valid
+```
+
+**HOW TO** resume a scroll
+```ruby
+repository = Elasticated::Repository.new
+scroll_id = '...' # the scroll_id returned by the 'search' object
+# prepare the 'search' object
+search = repository.restore_search scroll_id
+# fetch the next page of results
+results = search.fetch
+# fetch all pages until the search ends
+results.append search.fetch until search.completed?
+```
+
+**HOW TO** build a mapping
+```ruby
+mapping = Elasticated::Mapping.build do
+  type :content do
+    date :date
+    string :user
+    analyzed_string :user_alias
+    nested :user_purchases do
+      long :purchase_id
+      string :items
+    end
+    object :user_info do
+      string :address
+    end
+  end
+end
+```
+
+**HOW TO** configure the gem
+```ruby
+Elasticated.configure do |config|
+  config.logger = Elasticated::Loggers::DefaultLogger.new
+  config.scroll_expiration_time = '3m'
+  config.scroll_page_size = 500
+  config.search_page_size = 1000
+end
+```
+
+**HOW TO** configure some specific repository
+```ruby
+repository = Repository.new
+repository.logger = Elasticated::Loggers::DefaultLogger.new
+repository.scroll_expiration_time = '3m'
+repository.scroll_page_size = 500
+repository.search_page_size = 1000
+```

data/elasticated.gemspec

@@ -25,5 +25,6 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'elasticsearch'
   spec.add_runtime_dependency 'hash_ext', '~> 0.1.1'
+  spec.add_runtime_dependency 'timing', '~> 0.0', '>= 0.0.9'
 
 end

data/lib/elasticated.rb

@@ -1,6 +1,10 @@
 require 'json'
 require 'hash_ext'
 require 'elasticsearch'
+require 'timing'
+
+require_relative 'elasticated/loggers/silent_logger'
+require_relative 'elasticated/loggers/default_logger'
 
 require_relative 'elasticated/helpers'
 require_relative 'elasticated/block_evaluation'
@@ -8,7 +12,6 @@ require_relative 'elasticated/clonable'
 require_relative 'elasticated/inspectionable'
 require_relative 'elasticated/configuration'
 require_relative 'elasticated/configurable'
-require_relative 'elasticated/default_logger'
 
 # query conditions
 
@@ -48,15 +51,20 @@ require_relative 'elasticated/aggregations/terms_aggregation'
 
 require_relative 'elasticated/aggregations/histogram_aggregation'
 require_relative 'elasticated/aggregations/date_histogram_aggregation'
+require_relative 'elasticated/aggregations/safe_date_histogram_aggregation'
 
 require_relative 'elasticated/aggregations/single_value_aggregation'
 require_relative 'elasticated/aggregations/cardinality_aggregation'
-require_relative 'elasticated/aggregations/count_distinct_aggregation'
+require_relative 'elasticated/aggregations/value_count_aggregation'
+require_relative 'elasticated/aggregations/missing_aggregation'
+
+require_relative 'elasticated/aggregations/stats_aggregation'
 
 require_relative 'elasticated/aggregations/group_aggregation'
-require_relative 'elasticated/aggregations/count_aggregation'
 require_relative 'elasticated/aggregations/sum_distinct_aggregation'
 
+require_relative 'elasticated/aggregations/geohash_grid_aggregation'
+
 require_relative 'elasticated/aggregations/count_filtered_aggregation'
 require_relative 'elasticated/aggregations/filter_aggregation_evaluator'
 require_relative 'elasticated/aggregations/filter_aggregation'
@@ -78,6 +86,13 @@ require_relative 'elasticated/results'
 
 require_relative 'elasticated/client'
 require_relative 'elasticated/repository'
+require_relative 'elasticated/repository/search'
+require_relative 'elasticated/repository/intelligent_search'
+require_relative 'elasticated/repository/single_page_search'
+require_relative 'elasticated/repository/normal_search'
+require_relative 'elasticated/repository/scroll_search'
+require_relative 'elasticated/repository/scan_scroll_search'
+require_relative 'elasticated/repository/resumable_search'
 
 require_relative 'elasticated/mapping'
 require_relative 'elasticated/mapping/partial'

data/lib/elasticated/aggregations/filter_aggregation.rb

@@ -2,11 +2,13 @@ module Elasticated
   class FilterAggregation < Aggregation
     include Subaggregated
 
-    attr_accessor :_evaluator, :_filter_name
+    attr_accessor :_evaluator, :_filter_name, :compact, :include_count
 
     def initialize(filter_name, *args, &block)
-      self._filter_name = filter_name
+      self._filter_name  = filter_name
       super
+      self.compact       = extra_params.delete(:compact) { false }
+      self.include_count = extra_params.delete(:include_count) { true }
       initialize_subaggregations FilterAggregationEvaluator.new, &block
     end
 
@@ -23,10 +25,15 @@ module Elasticated
     end
 
     def parse(response)
-      response_body = response
-      ret = { 'count' => response_body['doc_count'] }
-      ret.merge! parse_subaggregations(response_body)
-      ret
+      count = response['doc_count']
+
+      if _subaggregations.empty?
+        compact ? count : { 'count' => count }
+      else
+        parse_subaggregations(response).tap do |h|
+          h['count'] = count if include_count
+        end
+      end
     end
 
   end

data/lib/elasticated/aggregations/geohash_grid_aggregation.rb

@@ -0,0 +1,28 @@
+module Elasticated
+  class GeohashGridAggregation < Aggregation
+
+    def default_name
+      "geohash_grid_by_#{field}"
+    end
+
+    # TODO: this is exactly the same as in SingleValueAggregation
+    def build
+      operation_info = { field: field }
+      operation_info.merge! extra_params
+      { operation => operation_info }
+    end
+
+    def parse(response)
+      response['buckets'].each_with_object({}) do |bucket, hash|
+        hash[bucket['key']] = bucket['doc_count']
+      end
+    end
+
+    protected
+
+    def operation
+      :geohash_grid
+    end
+
+  end
+end

data/lib/elasticated/aggregations/group_aggregation.rb

@@ -2,8 +2,12 @@ module Elasticated
   class GroupAggregation < TermsAggregation
     include Subaggregated
 
+    attr_accessor :compact, :include_count
+
     def initialize(field, *args, &block)
       super
+      self.compact       = extra_params.delete(:compact) { false }
+      self.include_count = extra_params.delete(:include_count) { true }
       initialize_subaggregations &block
     end
 
@@ -12,16 +16,21 @@ module Elasticated
     end
 
     def build
-      aggregation_struct = super
-      aggregation_struct.merge! build_subaggregations
-      aggregation_struct
+      super.merge build_subaggregations
     end
 
     def parse(response)
-      response['buckets'].inject({}) do |hash, bucket|
-        bucket_hash = { 'count' => bucket['doc_count'] }
-        bucket_hash.merge! parse_subaggregations(bucket)
-        hash.merge bucket['key'] => bucket_hash
+      response['buckets'].each_with_object({}) do |bucket, hash|
+        count = bucket['doc_count']
+
+        hash[bucket['key']] =
+          if _subaggregations.empty?
+            compact ? count : { 'count' => count }
+          else
+            parse_subaggregations(bucket).tap do |h|
+              h['count'] = count if include_count
+            end
+          end
       end
     end
 

data/lib/elasticated/aggregations/missing_aggregation.rb

@@ -0,0 +1,34 @@
+module Elasticated
+  class MissingAggregation < SingleValueAggregation
+    include Subaggregated
+
+    attr_accessor :compact
+
+    def initialize(field, *args, &block)
+      super
+      self.compact = extra_params.delete(:compact) { false }
+      initialize_subaggregations &block
+    end
+
+    # implementation
+    def operation
+      :missing
+    end
+
+    # TODO: this is exactly the same as in GroupAggregation
+    def build
+      super.merge build_subaggregations
+    end
+
+    def parse(response)
+      _subaggregations.empty? ? super : parse_subaggregations(response)
+    end
+
+    protected
+
+    def result_key
+      'doc_count'
+    end
+
+  end
+end

data/lib/elasticated/aggregations/range_aggregation.rb

@@ -2,10 +2,12 @@ module Elasticated
   class RangeAggregation < Aggregation
     include Subaggregated
 
-    attr_accessor :_conditions
+    attr_accessor :_conditions, :compact, :include_count
 
     def initialize(field, *args, &block)
       super
+      self.compact = extra_params.delete(:compact) { false }
+      self.include_count = extra_params.delete(:include_count) { true }
       initialize_subaggregations RangeAggregationEvaluator.new, &block
     end
 
@@ -24,10 +26,17 @@ module Elasticated
     end
 
     def parse(response)
-      response['buckets'].inject({}) do |hash, (key_name, values)|
-        range_body = { 'count' => values['doc_count'] }
-        range_body.merge! parse_subaggregations(values)
-        hash.merge key_name => range_body
+      response['buckets'].each_with_object({}) do |(key_name, values), hash|
+        count = values['doc_count']
+
+        hash[key_name] =
+          if _subaggregations.empty?
+            compact ? count : { 'count' => count }
+          else
+            parse_subaggregations(values).tap do |h|
+              h['count'] = count if include_count
+            end
+          end
       end
     end
 

data/lib/elasticated/aggregations/safe_date_histogram_aggregation.rb

@@ -0,0 +1,86 @@
+module Elasticated
+  class SafeDateHistogramAggregation < HistogramAggregation
+    include Subaggregated
+
+    DEFAULT_INTERVAL  = '1d'
+
+    attr_accessor :offset, :time_zone, :points, :compact, :include_count
+
+    def initialize(field, opts={}, &block)
+      self.offset    = opts.delete(:offset)
+      self.time_zone = opts.delete(:time_zone)
+      self.points    = opts.fetch(:points)
+      opts.delete(:points)
+      self.compact   = opts.delete(:compact) { false }
+      self.include_count = opts.delete(:include_count) { true }
+      interval = opts.delete(:interval) || DEFAULT_INTERVAL
+      super field, interval, opts, &block
+    end
+
+    def build
+      terms = { field: field, interval: safe_interval.to_s }
+      if offset # '1.4 style'
+        terms.merge! pre_offset: offset
+        terms.merge! post_offset: offset
+      end
+      if time_zone
+        terms.merge! time_zone: time_zone
+      end
+      terms.merge! extra_params
+      aggregation_struct = { date_histogram: terms }
+      aggregation_struct.merge! build_subaggregations
+      aggregation_struct
+    end
+
+    def parse(response)
+      response['buckets'].each_with_object({}) do |bucket, hash|
+        count = bucket['doc_count']
+        key = build_key(bucket)
+
+        if _subaggregations.empty?
+          hash[key] ||= 0
+          if compact
+            hash[key] = hash[key] + count
+          else
+            hash[key]['count'] ||= 0
+            hash[key]['count'] = hash[key]['count'] + count
+          end
+        else
+          parsed_subaggregations = parse_subaggregations(bucket)
+          hash[key] = value_for(parsed_subaggregations, hash, key).tap do |h|
+            h['count'] = count if include_count
+          end
+        end
+      end
+    end
+
+    protected
+
+    def build_key(bucket)
+      time = Timing::TimeInZone.at bucket['key'] / 1000, time_zone
+
+      if parsed_interval == safe_interval
+        time.iso8601
+      else
+        points.select { |p| p <= time.iso8601 }.sort.reverse.first
+      end
+    end
+
+    def safe_interval
+      parsed_interval > Timing::Interval.days(1) ? Timing::Interval.days(1) : parsed_interval
+    end
+
+    def parsed_interval
+      Timing::Interval.parse interval
+    end
+
+    def value_for(aggregation_value, hash, key)
+      if aggregation_value.is_a? Hash
+        Helpers.hash_sum(hash.fetch(key, {}), aggregation_value)
+      else
+        hash.fetch(key, 0) + aggregation_value
+      end
+    end
+
+  end
+end