es_query_builder 2.0.0 → 2.0.1

data/lib/queries/base_query_builder.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'query_builder'
+module Queries
+  # Wraps a query keyword around the query of the given object
+  class BaseQueryBuilder < QueryBuilder
+    NAME = 'query'
+
+    # @params [QueryBuilder] inner_query
+    #   query object whose query is to be wrapped around query keyword
+    def initialize(inner_query:)
+      @inner_query = inner_query
+    end
+
+    # @return [Hash] serialized query hash for the object
+    def query
+      query = { name.intern => inner_query.query }
+      query
+    end
+
+    # @!visibility protected
+    # Returns inner_query
+    def inner_query_expr
+      @inner_query
+    end
+  end
+end

data/lib/queries/bool_query_builder.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative 'query_builder'
+module Queries
+  # A query that matches documents matching boolean combinations of
+  # other queries. The bool query maps to Lucene BooleanQuery.
+  # It is built using one or more boolean clauses,
+  # each clause with a typed occurrence
+  #    QueryComponents
+  #       should: queries that may appear in the matching documents and
+  #                will contribute to scoring
+  #       must: queries that must appear in the matching documents and
+  #             will contribute to scoring
+  #       must_not: queries that must not appear in the matching documents and
+  #                 will contribute to scoring
+  #       filter: queries that must appear in the matching documents but
+  #               don't contribute to scoring
+  #       minimum_should_match: minimum should match as interger or percentage
+  class BoolQueryBuilder < QueryBuilder
+    NAME = 'bool'
+
+    def initialize
+      @should_queries = []
+      @must_queries = []
+      @mustnot_queries = []
+      @filter_queries = []
+      @minimum_should_match = nil
+    end
+
+    # @return [Hash] returns serialized query hash for this object
+    def query
+      query = {}
+      bool_query = common_query
+      bool_query[:should] = @should_queries.map(&:query)
+      bool_query[:must] = @must_queries.map(&:query)
+      bool_query[:must_not] = @mustnot_queries.map(&:query)
+      bool_query[:filter] = @filter_queries.map(&:query)
+      bool_query[:minimum_should_match] = @minimum_should_match
+      bool_query[:boost] = @boost
+      query[name.intern] = bool_query.compact
+      query
+    end
+
+    # @!visibility protected
+    # @return [Array<QueryBuilder>] the list of filter queries
+    def filter_expr
+      @filter_queries
+    end
+
+    # @param [QueryBuilder] query_builder
+    #   filter query to be added
+    # @return [BoolQueryBuilder] modified self
+    # adds a filter query
+    def filter(query_builder)
+      if query_builder.is_a?(Array)
+        @filter_queries += query_builder
+      else
+        @filter_queries.append(query_builder)
+      end
+      self
+    end
+
+    # @!visibility protected
+    # @return [Array<QueryBuilder>] the list of should queries
+    def should_expr
+      @should_queries
+    end
+
+    # @param [QueryBuilder] query_builder
+    #   should query to be added
+    # @return [BoolQueryBuilder] modified self
+    # adds a should query
+    def should(query_builder)
+      if query_builder.is_a?(Array)
+        @should_queries += query_builder
+      else
+        @should_queries.append(query_builder)
+      end
+      self
+    end
+
+    # @!visibility protected
+    # @return [Array<QueryBuilder>] the list of must queries
+    def must_expr
+      @must_queries
+    end
+
+    # @param [QueryBuilder] query_builder
+    # must query to be added
+    # @return [BoolQueryBuilder] modified self
+    # adds a must query
+    def must(query_builder)
+      if query_builder.is_a?(Array)
+        @must_queries += query_builder
+      else
+        @must_queries.append(query_builder)
+      end
+      self
+    end
+
+    # @!visibility protected
+    # @return [Array<QueryBuilder>] the list of must_not queries
+    def must_not_expr
+      @mustnot_queries
+    end
+
+    # @param [QueryBuilder] query_builder
+    #   must_not query to be added
+    # @return [BoolQueryBuilder] modified self
+    # adds a must_not query
+    def must_not(query_builder)
+      if query_builder.is_a?(Array)
+        @mustnot_queries += query_builder
+      else
+        @mustnot_queries.append(query_builder)
+      end
+      self
+    end
+
+    # @!visibility protected
+    # @return [Integer] minimum should match value for this query
+    def minimum_should_match_expr
+      @minimum_should_match
+    end
+
+    # @param [Integer] value
+    #   minimum number of should conditions to fulfill
+    # @return [BoolQueryBuilder] modified self
+    # sets the minimum should match value
+    # for the given query object
+    def minimum_should_match(value)
+      raise 'Minimum Should match cannot be nil' if value.nil?
+
+      @minimum_should_match = value
+      self
+    end
+
+    # @return [Boolean] returns true iff this query builder has at least one
+    #   should, must, must not or filter clause
+    def clauses?
+      shuld_clause = @should_queries.present?
+      must_clause = @must_queries.present?
+      mustnot_clause = @mustnot_queries.present?
+      filter_clause = @filter_queries.present?
+      shuld_clause && must_clause && mustnot_clause && filter_clause
+    end
+  end
+end

data/lib/queries/constant_score_query_builder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'query_builder'
+module Queries
+  # A query that wraps a filter and simply returns a constant score
+  # equal to the query boost for every document in the filter.
+  class ConstantScoreQueryBuilder < QueryBuilder
+    NAME = 'constant_score'
+
+    # @params [QueryBuilder] inner_query query for whose
+    #   matching documents constant score is to be set
+    # @params [Numeric] boost boosting value
+    def initialize(inner_query:)
+      @inner_query = inner_query
+    end
+
+    # @return [Hash] serialized json query for the object
+    def query
+      query = {}
+      cs_query = common_query
+      cs_query[:filter] = @inner_query.query if @inner_query.present?
+      query[name.intern] = cs_query
+      query
+    end
+
+    # Returns inner_query
+    # @!visibility protected
+    def inner_query_expr
+      @inner_query
+    end
+  end
+end

data/lib/queries/dis_max_query_builder.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'query_builder'
+module Queries
+  # A query that generates the union of documents produced
+  # by its sub-queries, and that scores each document
+  # with the maximum score for that document as produced by any sub-query,
+  # plus a tie breaking increment for any additional matching sub-queries.
+  class DisMaxQueryBuilder < QueryBuilder
+    # @!visibility protected
+    DEFAULT_TIE_BREAKER = 0.0
+    # @!visibility protected
+    NAME = 'dis_max'
+
+    def initialize
+      @queries = []
+      @tie_breaker = DEFAULT_TIE_BREAKER
+    end
+
+    def query
+      query = {}
+      dm_query = common_query
+      dm_query[:queries] = @queries.map(&:query) if @queries.present?
+      dm_query[:tie_breaker] = @tie_breaker
+      query[name.intern] = dm_query
+      query
+    end
+
+    # an immutable list copy of the current sub-queries of this disjunction
+    # @!visibilty protected
+    def inner_queries_expr
+      @queries
+    end
+
+    # returns the tie breaker value
+    # @!visibility protected
+    def tie_breaker_expr
+      @tie_breaker
+    end
+
+    # @params [Numeric] value tie_breaker value
+    #   tie_breaker:
+    #   the score of each non-maximum disjunct for a document is multiplied
+    #   by this weight and added into the final score. If non-zero,
+    #   the value should be small, on the order of 0.1, which says that
+    #   10 occurrences of word in a lower-scored field that is also in a
+    #   higher scored field is just as good as a unique word in the lower
+    #   scored field (i.e., one that is not in any higher scored field).
+    # adds the tie_breaker value
+    # @return [DisMaxQueryBuilder]
+    #   modified self
+    def tie_breaker(value)
+      raise 'Tie Breaker value is nil' if value.nil?
+
+      @tie_breaker = value
+      self
+    end
+
+    # @params [QueryBuilder] query subquery to be added to the dismax query
+    # add a sub-query to this disjunction
+    # @return [DisMaxQueryBuilder]
+    #   modified self
+    def add(query)
+      raise 'Query for Dismax is nil' if query.nil?
+
+      @queries.append(query)
+      self
+    end
+  end
+end

data/lib/queries/exists_query_builder.rb

@@ -0,0 +1,32 @@
+# Returns documents that contain a value other than null or [] in a provided field.
+require_relative 'query_builder'
+module Queries
+  class ExistsQueryBuilder < QueryBuilder
+
+    NAME = "exists"
+
+    attr_reader :field_name
+
+=begin
+    @params:
+      field_name: name of the field the existence of whose value is checked
+=end
+    def initialize field_name:
+      @field_name= field_name
+    end
+
+    def query
+      query = {}
+      exists_query = self.common_query
+      exists_query[:field] = @field_name
+      query[name.intern] = exists_query
+      return query
+    end
+
+  # returns field_name
+    def field_name_expr
+      return @field_name
+    end
+    
+  end
+end

data/lib/queries/function_score_query_builder.rb

@@ -0,0 +1,170 @@
+require_relative 'query_builder'
+module Queries
+  class FunctionScoreQueryBuilder < QueryBuilder
+
+    NAME = "function_score"
+
+=begin
+    @params:
+      query: query that specifies the documents to retrieve
+      filter_functions: function to be associated with an optional filter, meaning it will be executed only for the documents that match the given filter
+      score_mode: how results of individual score functions will be aggregated
+      boost_mode: how the combined result of score functions will influence the final score together with the sub query score
+      max_boost: maximum boost that will be applied by function score
+      min_score: used to exclude documents that do not meet a certain score threshold
+      score_function: function that defines how the documents will be scored
+=end
+
+    def initialize query: nil, score_function: nil, filter_functions: [], boost_mode: nil
+      @function_query = query
+      @score_builder = score_function
+      @filter_functions = filter_functions
+      @score_mode = nil
+      @boost_mode = boost_mode
+      @max_boost = nil
+      @min_score = nil
+    end
+
+    def query
+      query = {}
+      fs_query = self.common_query
+      fs_query[:query] = @function_query.query if @function_query.present?
+      fs_query[:functions] = @filter_functions.map{|ff| ff.query} if @filter_functions.present?
+      fs_query[:score_mode] = @score_mode if @score_mode.present?
+      fs_query[:boost_mode] = @boost_mode if @boost_mode.present?
+      fs_query[:max_boost] = @max_boost if @max_boost.present?
+      fs_query[:min_score] = @min_score if @min_score.present?
+      fs_query.merge!(@score_builder.function) 
+      query[name.intern] = fs_query
+      return query
+    end
+
+  ########## Function Query ##########
+  # returns query
+    def query_expr
+      return @function_query
+    end
+
+  ########## Score Function ##########
+  # returns score_function
+    def score_function_expr
+      return @score_builder
+    end
+
+  ##########  BOOST MODE  #########################
+  # returns the Boost mode for the query
+    def boostmode_expr
+      return @boostmode
+    end
+  # sets the Boost mode for the query.
+    def boostmode combine_function
+      @boost_mode = combine_function.combine_function
+      return self
+    end
+
+
+  ########## FILTER FUNCTIONS ##########
+  # returns the filters and functions
+    def filter_functions_expr
+      return @filter_functions
+    end
+  # sets filter function/s to query
+    def filter_function filter_function
+      @filter_functions.append(filter_function)
+      return self
+    end
+
+  ######### MAX BOOST ##########
+  # returns max_boost
+    def max_boost_expr
+      return @max_boost
+    end
+  # sets max_boost
+    def max_boost value
+      raise "Max Boost cannot be nil value" if value.nil?
+      @max_boost = value.to_f
+      return self
+    end
+
+
+  ########## SCORE MODE ##########
+  # returns the score mode for the query.
+    def score_mode_expr
+      return @score_mode
+    end
+  # sets the score mode for the query.
+    def score_mode score_mode
+      @score_mode = score_mode.score_mode
+      return self
+    end
+
+
+  ########## MIN SCORE ##########
+  # returns the min score for the query
+    def min_score_expr
+      return @min_score
+    end
+  # sets the min score for the query
+    def min_score value
+      raise "Min Score cannot be nil value" if value.nil?
+      @min_score = value.to_f
+      return self
+    end
+
+  ########## Filter Function Builder Class ##########
+=begin
+    Function to be associated with an optional filter, meaning it will be executed only for the documents that match the given filter.
+=end
+    class FilterFunctionBuilder
+      include AttributesReader
+      # attr_reader :filter, :score_builder, :weight
+
+=begin
+      @params:
+        filter: filter to select the documents
+        weight: weight to be multiplied to function score before combining
+        score_function: function for scoring matching documents
+=end
+
+      def initialize filter: nil, score_function: nil
+        @filter = filter
+        @score_builder = score_function
+      end
+
+      def query
+        query = {}
+        query[:filter] = @filter.query if @filter.present?
+        query[:weight] = @weight if @weight.present?
+        query.merge!(@score_builder.query) if @score_builder.present?
+        return query
+      end
+
+
+  ########## Filter Query ##########
+  # returns filter query of the given filter function builder object
+      def filter_expr
+        return @filter
+      end
+
+
+  ########## Score Function ##########
+  # returns score function of the given filter function builder object
+      def score_function_expr
+        return @score_builder
+      end
+
+
+  ########## Multiplicative Weight ##########
+  # returns the weight for the filter function
+      def weight_expr
+        return @weight
+      end
+  # sets the weight for the filter function
+      def weight value
+        @weight = value.to_f
+        return self
+      end
+
+    end
+  end
+end