es_query_builder 2.0.0 → 2.0.1

data/lib/queries/geo_distance_query_builder.rb

@@ -0,0 +1,126 @@
+# Filters documents that include only hits that exists within a specific distance from a geo point. 
+require_relative 'query_builder'
+module Queries
+  class GeoDistanceQueryBuilder < QueryBuilder
+
+    NAME = 'geo_distance'
+    DEFAULT_DISTANCE_UNIT = ::Enums::DistanceUnits.meters
+
+=begin
+    @params:
+      field_name: geo_point field in the document which is matched with the given query
+      point: center point for this query
+      distance: The radius of the circle centred on the specified location. Points which fall into this circle are considered to be matches.
+      distance_unit: The distance can be specified in various units. See Distance Units.
+      distance_type: How to compute the distance. Can either be arc (default),
+                     or plane (faster, but inaccurate on long distances and close to the poles)
+      writable_name: Optional name field to identify the query
+      validation_method: Set to IGNORE_MALFORMED to accept geo points with invalid latitude or longitude,
+                         set to COERCE to additionally try and infer correct coordinates (default is STRICT).
+      ignore_unmapped: When set to true the ignore_unmapped option will ignore an unmapped field and will not match any documents for this query.
+                       When set to false (the default value) the query will throw an exception if the field is not mapped.
+=end
+
+    def initialize field_name:
+      @field_name = field_name
+      @point = nil
+      @distance = nil
+      @distance_unit = DEFAULT_DISTANCE_UNIT.distance_unit
+      @distance_type = nil
+      @writable_name = nil
+      @validation_method = nil
+      @ignore_unmapped = nil
+    end
+
+    def query
+      query = {}
+      geo_query = self.common_query
+      geo_query[@field_name] = @point.settings
+      geo_query[:distance] = @distance.to_s + @distance_unit.to_s
+      geo_query[:distance_type] = @distance_type
+      geo_query[:writable_name] = @writable_name
+      geo_query[:validation_method] = @validation_method
+      geo_query[:ignore_unmapped] = @ignore_unmapped
+      query[name.intern] = geo_query
+      return query
+    end
+
+  # Returns point
+    def point_expr
+      return @point
+    end
+
+  # Sets point
+    def point point
+      @point = point
+      return self
+    end
+
+  # Returns field_name
+    def field_name_expr
+      return @field_name
+    end
+
+  # Returns distance
+    def distance_expr
+      return @distance
+    end
+
+  # Returns distance_unit
+    def distance_unit_expr
+      return @distance_unit
+    end
+
+  # Sets distance and distance_unit
+    def distance distance, distance_unit= nil
+      @distance = distance
+      @distance_unit = distance_unit.distance_unit if distance_unit.present?
+      return self
+    end
+
+  # Returns distance_type
+    def distance_type_expr
+      return @distance_type
+    end
+
+  # Sets distance_type
+    def distance_type distance_type
+      @distance_type = distance_type.distance_type
+      return self
+    end
+
+  # Returns writable_name
+    def writable_name_expr
+      return @writable_name
+    end
+
+  # Sets writable_name
+    def writable_name writable_name
+      @writable_name = writable_name
+      return self
+    end
+
+  # Returns validation_method
+    def validation_method_expr
+      return @validation_method
+    end
+
+  # Sets validation_method
+    def validation_method validation_method
+      @validation_method = validation_method.validation_method
+      return self
+    end
+
+  # Returns ignore_unmapped
+    def ignore_unmapped_expr
+      return @ignore_unmapped
+    end
+
+  # Sets ignore_unmapped
+    def ignore_unmapped ignore_unmapped
+      @ignore_unmapped = ignore_unmapped
+      return self
+    end
+
+  end
+end

data/lib/queries/match_all_query_builder.rb

@@ -0,0 +1,16 @@
+# The most simple query, which matches all documents
+require_relative 'query_builder'
+module Queries
+  class MatchAllQueryBuilder < QueryBuilder
+
+    NAME = 'match_all'
+
+    def query
+      query = {}
+      matchall_query = self.common_query
+      query[name.intern] = matchall_query
+      return query
+    end
+
+  end
+end

data/lib/queries/match_query_builder.rb

@@ -0,0 +1,181 @@
+# Match query is a query that analyzes the text and constructs a query as the result of the analysis.
+require_relative 'query_builder'
+module Queries
+  class MatchQueryBuilder < QueryBuilder
+=begin
+   @params: analyzer, auto_generate_synonyms_phrase_query, cutoff_frequency, field_name, fuzziness, fuzzy_transposition,
+            lenient, max_expansions, minimum_should_match, operator, prefix_length, value, zero_terms_query
+      analyzer: analyzer to be used for this query
+      auto_generate_synonyms_phrase_query: The match query supports multi-terms synonym expansion with the synonym_graph token filter.
+                                           When this filter is used, the parser creates a phrase query for each multi-terms synonyms.
+                                           For example, the following synonym: "ny, new york" would produce:
+                                           (ny OR ("new york"))
+      cutoff_frequency: cutoff value in [0..1] (or absolute number >=1) representing the maximum threshold of a terms document frequency 
+                        to be considered a low frequency term.
+      field_name: name of the field to be queried
+      fuzziness: fuzziness used when evaluated to a fuzzy query type
+      fuzzy_transposition: fuzzy transpositions (ab → ba) are allowed by default but can be disabled by setting fuzzy_transpositions to false
+      max_expansions: max_expansions limit the number of matching docs that will be returned
+      minimum_should_match: minimum number of cases to match in case of or query
+      value: value to be matched in that field in the documents
+      zero_terms_query: If the analyzer used removes all tokens in a query like a stop filter does, the default behavior is to match no documents at all.
+                        In order to change that the zero_terms_query option can be used, which accepts none (default) and all which corresponds to a match_all query.
+      fuzzy_prefix_length: prefix length provides the number of characters from beginning that have to be exactly matched
+=end
+
+    NAME = "match"
+
+    def initialize field_name: , value: nil
+      @field_name = field_name
+      @value = value
+      @zero_terms_query = nil
+      @analyzer = nil
+      @auto_generate_synonyms_phrase_query = nil
+      @cutoff_frequency = nil
+      @fuzziness = nil
+      @fuzzy_transpositions = nil
+      @max_expansions = nil
+      @minimum_should_match = nil
+      @operator = nil
+      @prefix_length = nil
+      @zero_terms_query = nil
+    end
+
+    def query
+      query = {}
+      match_query = {}
+      field_options = self.common_query
+      field_options[:query] = @value
+      field_options[:operator] = @operator if @operator.present?
+      field_options[:analyzer] = @analyzer if @analyzer.present?
+      field_options[:auto_generate_synonyms_phrase_query] = @auto_generate_synonyms_phrase_query if @auto_generate_synonyms_phrase_query.present?
+      field_options[:cutoff_frequency] = @cutoff_frequency if @cutoff_frequency.present?
+      field_options[:fuzzy_prefix_length] = @fuzzy_prefix_length if @fuzzy_prefix_length.present?
+      field_options[:max_expansions] = @max_expansions if @max_expansions.present?
+      field_options[:fuzzy_transpositions] = @fuzzy_transpositions if @fuzzy_transpositions.present?
+      field_options[:minimum_should_match] = @minimum_should_match if @minimum_should_match.present?
+      field_options[:zero_terms_query] = @zero_terms_query if @zero_terms_query.present?
+      field_options[:fuzziness] = @fuzziness if @fuzziness.present?
+      match_query[@field_name.to_s.intern] = field_options
+      query[name.intern] = match_query
+      return query
+    end
+
+  ########## FIELD NAME ##########
+  # returns field_name
+    def field_name_expr
+      return @field_name
+    end
+
+  ########## FIELD VALUE ##########
+  # returns value
+    def value_expr
+      return @value
+    end
+
+  ########## SEARCH ANALYZER ##########
+  # return analyzer
+    def analyzer_expr
+      return @analyzer
+    end
+  # sets analyzer
+    def analyzer value
+      @analyzer = value
+      return self
+    end
+
+
+  ########## AUTO GENERATE SYNONYMS PHRASE QUERY ##########
+  # returns auto_generate_synonyms_phrase_query
+    def auto_generate_synonyms_phrase_query_expr
+      return @auto_generate_synonyms_phrase_query
+    end
+  # sets auto_generate_synonyms_phrase_query
+    def auto_generate_synonyms_phrase_query value
+      @auto_generate_synonyms_phrase_query = value
+      return self
+    end
+
+
+  ########## CUTOFF FREQUENCY ##########
+  # returns cutoff_frequency
+    def cutoff_frequency_expr
+      return @cutoff_frequency
+    end
+  # sets cutoff_frequency
+    def cutoff_frequency value
+      @cutoff_frequency = value
+      return self
+    end
+
+
+  ########## FUZZINESS VALUE ##########
+  # returns fuzziness
+    def fuzziness_expr
+      return @fuzziness
+    end
+  # sets fuzziness
+    def fuzziness fuzziness
+      @fuzziness = fuzziness.fuzziness
+      return self
+    end
+
+  ########## PREFIX LENGTH ########
+  # returns prefix_length
+    def fuzzy_prefix_length_expr
+      return @prefix_length
+    end
+  # sets prefix_length
+    def fuzzy_prefix_length value
+      @prefix_length = value
+      return self
+    end
+
+  ########## MAX EXPANSIONS ##########
+  # returns max_expansions
+    def max_expansions_expr
+      return @max_expansions
+    end
+  # sets max_expansions
+    def max_expansions value
+      @max_expansions = value
+      return self    
+    end
+
+  ########## FUZZY TRANSPOSITIONS ##########
+  # returns fuzzy_transpositions
+    def fuzzy_transpositions_expr
+      return @fuzzy_transpositions
+    end
+  # sets fuzzy_transpositions
+    def fuzzy_transpositions value
+      @fuzzy_transpositions = value
+      return self
+    end
+
+  ########## MINIMUM SHOULD ##########
+  # returns minimum_should_match
+    def minimum_should_match_expr
+      return @minimum_should_match
+    end
+  # sets minimum_should_match
+    def minimum_should_match value
+      @minimum_should_match = value
+      return self
+    end
+
+  ########## ZERO TERMS ##########
+  # returns zero_terms_query
+    def zero_terms_query_expr
+      return @zero_terms_query
+    end
+  # sets zero_terms_query
+    def zero_terms_query zero_terms_query
+      @zero_terms_query = zero_terms_query.zero_term
+      return self
+    end
+
+  end
+end
+
+

data/lib/queries/nested_query_builder.rb

@@ -0,0 +1,55 @@
+=begin
+  Nested query allows to query nested objects / docs (see nested mapping). The query is executed against the nested objects / docs 
+  as if they were indexed as separate docs (they are, internally) and resulting in the root parent doc (or parent nested mapping).
+=end
+require_relative 'query_builder'
+module Queries
+  class NestedQueryBuilder < QueryBuilder
+
+    NAME = "nested"
+
+    attr_reader :path, :inner_query, :score_mode
+
+=begin
+    @params:
+      path: The query path points to the nested object path.
+      score_mode: The score_mode allows to set how inner children matching affects scoring of parent.
+                  It defaults to avg, but can be sum, min, max and none.
+      inner_query: query includes the query that will run on the nested docs matching the direct path, and joining with the root parent docs
+
+    Any fields referenced inside the query must use the complete path (fully qualified)
+=end
+    def initialize path:, inner_query:, score_mode: nil, type: :query
+      @path = path
+      @inner_query = inner_query
+      @score_mode = score_mode.score_mode if score_mode.present?
+      @type = type
+    end
+
+    def query
+      query = {}
+      nested_query = self.common_query
+      nested_query[:path] = @path if @path.present?
+      nested_query[@type] = @inner_query.query if @inner_query.present?
+      nested_query[:score_mode] = @score_mode if @score_mode.present?
+      query[name.intern] = nested_query
+      return query
+    end
+
+  # returns path
+    def path_expr
+      return @path
+    end
+
+  # returns inner_query
+    def inner_query_expr
+      return @inner_query
+    end
+
+  # returns score_mode
+    def score_mode_expr
+      return @score_mode
+    end
+
+  end
+end

data/lib/queries/nested_sort_query_builder.rb

@@ -0,0 +1,44 @@
+require_relative 'query_builder'
+module Queries
+  class NestedSortQueryBuilder < QueryBuilder
+
+    NAME = "nested"
+
+    attr_reader :path, :inner_query
+
+=begin
+    @params:
+      path: The query path points to the nested object path.
+      inner_query: query includes the query that will run on the nested docs matching the direct path, and joining with the root parent docs
+
+    Any fields referenced inside the query must use the complete path (fully qualified)
+=end
+    def initialize path:, inner_query:
+      @path = path
+      @inner_query = inner_query
+    end
+
+    def query
+      nested_query = self.common_query
+      nested_query[:path] = @path if @path.present?
+      nested_query[:filter] = @inner_query.query if @inner_query.present?
+      return nested_query
+    end
+
+  # returns path
+    def path_expr
+      return @path
+    end
+
+  # returns inner_query
+    def inner_query_expr
+      return @inner_query
+    end
+
+  # returns score_mode
+    def score_mode_expr
+      return @score_mode
+    end
+
+  end
+end

data/lib/queries/query_builder.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'abstract_query_builder'
+require_relative '../attributes_reader'
+module Queries
+  # Base Class for all query classes
+  #    QueryComponents
+  #      boost: documents matching the query are boosted by
+  #             the value
+  class QueryBuilder
+    include AbstractQueryBuilder
+    include AttributesReader
+
+    NAME = 'base'
+
+    # @!visibility protected
+    # @return [Numeric] the boost for this query
+    def boost_expr
+      @boost
+    end
+
+    # @param [Numeric]
+    #   value boost value for the query
+    # @return [QueryBuilder] modified self
+    # sets the boost value for this query
+    def boost(value)
+      raise 'boost value is nil' if value.nil?
+
+      @boost = value
+      self
+    end
+  end
+end