sunspot 2.0.0 → 2.5.0

data/lib/sunspot/query.rb

@@ -1,8 +1,9 @@
-%w(filter abstract_field_facet connective boost_query date_field_facet range_facet dismax
-   field_facet highlighting pagination restriction common_query
+%w(filter abstract_field_facet abstract_json_field_facet connective boost_query date_field_facet field_json_facet
+   range_facet range_json_facet date_field_json_facet abstract_fulltext dismax join
+   field_list field_facet highlighting pagination restriction common_query spellcheck
    standard_query more_like_this more_like_this_query geo geofilt bbox query_facet
-   scope sort sort_composite text_field_boost function_query
-   composite_fulltext field_group).each do |file|
+   scope sort sort_composite text_field_boost function_query field_stats
+   composite_fulltext group group_query).each do |file|
   require(File.join(File.dirname(__FILE__), 'query', file))
 end
 module Sunspot

data/lib/sunspot/query/abstract_field_facet.rb

@@ -1,8 +1,6 @@
 module Sunspot
   module Query
     class AbstractFieldFacet
-      include RSolr::Char
-
       def initialize(field, options)
         @field, @options = field, options
       end

data/lib/sunspot/query/abstract_fulltext.rb

@@ -0,0 +1,76 @@
+module Sunspot
+  module Query
+
+    #
+    # Solr query abstraction
+    #
+    class AbstractFulltext
+      attr_reader :fulltext_fields
+
+      #
+      # Assign a new boost query and return it.
+      #
+      def create_boost_query(factor)
+        @boost_queries << boost_query = BoostQuery.new(factor)
+        boost_query
+      end
+
+      #
+      # Add a boost function
+      #
+      def add_additive_boost_function(function_query)
+        @additive_boost_functions << function_query
+      end
+
+      #
+      # Add a multiplicative boost function
+      #
+      def add_multiplicative_boost_function(function_query)
+        @multiplicative_boost_functions << function_query
+      end
+
+      #
+      # Add a fulltext field to be searched, with optional boost.
+      #
+      def add_fulltext_field(field, boost = nil)
+        @fulltext_fields[field.indexed_name] = TextFieldBoost.new(field, boost)
+      end
+
+      #
+      # Add a phrase field for extra boost.
+      #
+      def add_phrase_field(field, boost = nil)
+        @phrase_fields ||= []
+        @phrase_fields << TextFieldBoost.new(field, boost)
+      end
+
+      #
+      # Set highlighting options for the query. If fields is empty, the
+      # Highlighting object won't pass field names at all, which means
+      # the dismax's :qf parameter will be used by Solr.
+      #
+      def add_highlight(fields=[], options={})
+        @highlights << Highlighting.new(fields, options)
+      end
+
+      #
+      # Determine if a given field is being searched. Used by DSL to avoid
+      # overwriting boost parameters when injecting defaults.
+      #
+      def has_fulltext_field?(field)
+        @fulltext_fields.has_key?(field.indexed_name)
+      end
+
+      private
+
+      def escape_param(key, value)
+        "#{key}='#{escape_quotes(Array(value).join(" "))}'"
+      end
+
+      def escape_quotes(value)
+        return value unless value.is_a? String
+        value.gsub(/(['"])/, '\\\\\1')
+      end
+    end
+  end
+end

data/lib/sunspot/query/abstract_json_field_facet.rb

@@ -0,0 +1,70 @@
+module Sunspot
+  module Query
+    class AbstractJsonFieldFacet
+
+      attr_accessor :field
+
+      DISTINCT_STRATEGIES = [:unique, :hll]
+
+      def initialize(field, options, setup)
+        @field, @options, @setup = field, options, setup
+      end
+
+      def init_params
+        params = {}
+        params[:limit] = @options[:limit] unless @options[:limit].nil?
+        params[:mincount] = @options[:minimum_count] unless @options[:minimum_count].nil?
+        params[:sort] = { @options[:sort] => @options[:sort_type]||'desc' } unless @options[:sort].nil?
+        params[:prefix] = @options[:prefix] unless @options[:prefix].nil?
+        params[:offset] = @options[:offset] unless @options[:offset].nil?
+
+        if !@options[:distinct].nil?
+          dist_opts = @options[:distinct]
+          raise Exception.new("Need to specify a strategy") if dist_opts[:strategy].nil?
+          raise Exception.new("The strategy must be one of #{DISTINCT_STRATEGIES}") unless DISTINCT_STRATEGIES.include?(dist_opts[:strategy])
+          @stategy = dist_opts[:strategy]
+          @group_by = dist_opts[:group_by].nil? ? @field : @setup.field(dist_opts[:group_by])
+          params[:field] = @group_by.indexed_name
+          params[:facet] = {}
+          params[:facet][:distinct] = "#{@stategy}(#{@field.indexed_name})"
+        end
+
+        params
+      end
+
+      def get_params
+        query = field_name_with_local_params
+        nested_params = recursive_nested_params(@options)
+
+        if !nested_params.nil?
+          query[@field.name][:facet] ||= {}
+          query[@field.name][:facet].merge!(nested_params)
+        end
+        query
+      end
+
+      def to_params
+        { 'json.facet' => self.get_params.to_json }
+      end
+
+      private
+
+      def recursive_nested_params(options)
+        if !options[:nested].nil? && options[:nested].is_a?(Hash)
+          opts = options[:nested]
+          field_name = opts[:field]
+
+          options = Sunspot::Util.extract_options_from([opts])
+          params = Sunspot::Util.parse_json_facet(field_name, options, @setup).field_name_with_local_params
+          if !opts.nil?
+            nested_params = recursive_nested_params(opts)
+            params[field_name][:facet] = nested_params unless nested_params.nil?
+          end
+
+          params
+        end
+      end
+
+    end
+  end
+end

data/lib/sunspot/query/bbox.rb

@@ -5,8 +5,12 @@ module Sunspot
         @field, @first_corner, @second_corner = field, first_corner, second_corner
       end
 
+      def to_solr_conditional
+        "[#{@first_corner.join(",")} TO #{@second_corner.join(",")}]"
+      end
+
       def to_params
-        filter = "#{@field.indexed_name}:[#{@first_corner.join(",")} TO #{@second_corner.join(",")}]"
+        filter = "#{@field.indexed_name}:#{to_solr_conditional}"
 
         {:fq => filter}
       end

data/lib/sunspot/query/common_query.rb

@@ -12,17 +12,22 @@ module Sunspot
         end
 
         @pagination = nil
-        @parameter_adjustment = nil
+        @parameter_adjustments = []
       end
 
-      def solr_parameter_adjustment=(block)
-        @parameter_adjustment = block
+      def add_parameter_adjustment(block)
+        @parameter_adjustments << block
       end
 
       def add_sort(sort)
         @sort << sort
       end
 
+      def add_field_list(field_list)
+        @components << field_list
+        field_list
+      end
+
       def add_group(group)
         @components << group
         group
@@ -48,14 +53,27 @@ module Sunspot
         geo
       end
 
-      def paginate(page, per_page, offset = nil)
+      def add_stats(stats)
+        @components << stats
+        stats
+      end
+
+      def add_spellcheck(options = {})
+        @components << Spellcheck.new(options)
+      end
+
+      def paginate(page, per_page, offset = nil, cursor = nil)
         if @pagination
           @pagination.offset = offset
           @pagination.page = page
           @pagination.per_page = per_page
+          @pagination.cursor = cursor
         else
-          @components << @pagination = Pagination.new(page, per_page, offset)
+          @components << @pagination = Pagination.new(page, per_page, offset, cursor)
         end
+
+        # cursor pagination requires a sort containing a uniqueKey field
+        add_sort(Sunspot::Query::Sort.special(:solr_id).new('asc')) if cursor and !@sort.include?('id ')
       end
 
       def to_params
@@ -63,7 +81,11 @@ module Sunspot
         @components.each do |component|
           Sunspot::Util.deep_merge!(params, component.to_params)
         end
-        @parameter_adjustment.call(params) if @parameter_adjustment
+
+        @parameter_adjustments.each do |_block|
+          _block.call(params)
+        end
+
         params[:q] ||= '*:*'
         params
       end
@@ -80,6 +102,9 @@ module Sunspot
         @pagination.per_page if @pagination
       end
 
+      def cursor
+        @pagination.cursor if @pagination
+      end
 
       private
 

data/lib/sunspot/query/composite_fulltext.rb

@@ -5,31 +5,81 @@ module Sunspot
         @components = []
       end
 
-      def add(keywords)
+      def add_fulltext(keywords)
         @components << dismax = Dismax.new(keywords)
         dismax
       end
+
+      def add_join(keywords, target, from, to)
+        @components << join = Join.new(keywords, target, from, to)
+        join
+      end
       
       def add_location(field, lat, lng, options)
         @components << location = Geo.new(field, lat, lng, options)
         location
       end
 
+      def add_disjunction
+        @components << disjunction = Disjunction.new
+        disjunction
+      end
+
+      def add_conjunction
+        @components << conjunction = Conjunction.new
+        conjunction
+      end
+
       def to_params
-        case @components.length
-        when 0
+        if @components.length == 0
           {}
-        when 1
-          @components.first.to_params.merge(:fl => '* score')
+        elsif @components.length > 1 or @components.find { |c| c.is_a?(Join) }
+          to_subquery.merge(:fl => '* score')
         else
-          to_subqueries.merge(:fl => '* score')
+          @components.first.to_params.merge(:fl => '* score')
+        end
+      end
+
+      def to_subquery
+        return {} unless @components.any?
+
+        params = @components.map(&:to_subquery).inject({:q => []}) do |res, subquery|
+          res[:q] << subquery.delete(:q) if subquery[:q]
+          res.merge(subquery)
         end
+
+        params[:q] = params[:q].size > 1 ? "(#{params[:q].join(" #{connector} ")})" : params[:q].join
+        params
+      end
+    end
+
+    class Disjunction < CompositeFulltext
+      #
+      # No-op - this is already a disjunction
+      #
+      def add_disjunction
+        self
+      end
+
+      private
+
+      def connector
+        'OR'
+      end
+    end
+
+    class Conjunction < CompositeFulltext
+      #
+      # No-op - this is already a conjunction
+      #
+      def add_conjunction
+        self
       end
 
       private
 
-      def to_subqueries
-        { :q => @components.map { |dismax| dismax.to_subquery }.join(' ') }
+      def connector
+        'AND'
       end
     end
   end

data/lib/sunspot/query/date_field_json_facet.rb

@@ -0,0 +1,25 @@
+module Sunspot
+  module Query
+    class DateFieldJsonFacet < AbstractJsonFieldFacet
+
+      def initialize(field, options, setup)
+        raise Exception.new('Need to specify a time_range') if options[:time_range].nil?
+        @start = options[:time_range].first
+        @end = options[:time_range].last
+        @gap = "+#{options[:gap] || 86400}SECONDS"
+        super
+      end
+
+      def field_name_with_local_params
+        params = {}
+        params[:type] = 'range'
+        params[:field] = @field.indexed_name
+        params[:start] = @field.to_indexed(@start)
+        params[:end] = @field.to_indexed(@end)
+        params[:gap] = @gap
+        params.merge!(init_params)
+        { @field.name => params }
+      end
+    end
+  end
+end

data/lib/sunspot/query/dismax.rb

@@ -6,14 +6,15 @@ module Sunspot
     # designed to process user-entered phrases, and search for individual
     # words across a union of several fields.
     #
-    class Dismax
+    class Dismax < AbstractFulltext
       attr_writer :minimum_match, :phrase_slop, :query_phrase_slop, :tie
 
       def initialize(keywords)
         @keywords = keywords
         @fulltext_fields = {}
         @boost_queries = []
-        @boost_functions = []
+        @additive_boost_functions = []
+        @multiplicative_boost_functions = []
         @highlights = []
 
         @minimum_match = nil
@@ -30,35 +31,38 @@ module Sunspot
         params = { :q => @keywords }
         params[:fl] = '* score'
         params[:qf] = @fulltext_fields.values.map { |field| field.to_boosted_field }.join(' ')
-        params[:defType] = 'dismax'
+        params[:defType] = 'edismax'
+        params[:mm] = @minimum_match if @minimum_match
+        params[:ps] = @phrase_slop if @phrase_slop
+        params[:qs] = @query_phrase_slop if @query_phrase_slop
+        params[:tie] = @tie if @tie
+
         if @phrase_fields
           params[:pf] = @phrase_fields.map { |field| field.to_boosted_field }.join(' ')
         end
+
         unless @boost_queries.empty?
           params[:bq] = @boost_queries.map do |boost_query|
             boost_query.to_boolean_phrase
           end
         end
-        unless @boost_functions.empty?
-          params[:bf] = @boost_functions.map do |boost_function|
-            boost_function.to_s
+
+        unless @additive_boost_functions.empty?
+          params[:bf] = @additive_boost_functions.map do |additive_boost_function|
+            additive_boost_function.to_s
           end
         end
-        if @minimum_match
-          params[:mm] = @minimum_match
-        end
-        if @phrase_slop
-          params[:ps] = @phrase_slop
-        end
-        if @query_phrase_slop
-          params[:qs] = @query_phrase_slop
-        end
-        if @tie
-          params[:tie] = @tie
+
+        unless @multiplicative_boost_functions.empty?
+          params[:boost] = @multiplicative_boost_functions.map do |multiplicative_boost_function|
+            multiplicative_boost_function.to_s
+          end
         end
+
         @highlights.each do |highlight|
           Sunspot::Util.deep_merge!(params, highlight.to_params)
         end
+
         params
       end
 
@@ -69,68 +73,18 @@ module Sunspot
         params = self.to_params
         params.delete :defType
         params.delete :fl
-        keywords = params.delete(:q)
-        options = params.map { |key, value| escape_param(key, value) }.join(' ')
-        "_query_:\"{!dismax #{options}}#{escape_quotes(keywords)}\""
-      end
 
-      #
-      # Assign a new boost query and return it.
-      #
-      def create_boost_query(factor)
-        @boost_queries << boost_query = BoostQuery.new(factor)
-        boost_query
-      end
+        keywords = escape_quotes(params.delete(:q))
+        options = params.map { |key, value| escape_param(key, value) }.join(' ')
 
-      # 
-      # Add a boost function
-      #
-      def add_boost_function(function_query)
-        @boost_functions << function_query
+        { :q => "_query_:\"{!edismax #{options}}#{keywords}\"" }
       end
 
       #
       # Add a fulltext field to be searched, with optional boost.
       #
       def add_fulltext_field(field, boost = nil)
-        @fulltext_fields[field.indexed_name] = TextFieldBoost.new(field, boost)
-      end
-
-      #
-      # Add a phrase field for extra boost.
-      #
-      def add_phrase_field(field, boost = nil)
-        @phrase_fields ||= []
-        @phrase_fields << TextFieldBoost.new(field, boost)
-      end
-
-      #
-      # Set highlighting options for the query. If fields is empty, the
-      # Highlighting object won't pass field names at all, which means
-      # the dismax's :qf parameter will be used by Solr.
-      #
-      def add_highlight(fields=[], options={})
-        @highlights << Highlighting.new(fields, options)
-      end
-
-      #
-      # Determine if a given field is being searched. Used by DSL to avoid
-      # overwriting boost parameters when injecting defaults.
-      #
-      def has_fulltext_field?(field)
-        @fulltext_fields.has_key?(field.indexed_name)
-      end
-
-
-      private
-      
-      def escape_param(key, value)
-        "#{key}='#{escape_quotes(Array(value).join(" "))}'"
-      end
-
-      def escape_quotes(value)
-        return value unless value.is_a? String
-        value.gsub(/(['"])/, '\\\\\1')
+        super unless field.is_a?(Sunspot::JoinField)
       end
 
     end