sunspot 2.1.1 → 2.2.0

data/lib/sunspot/query.rb

@@ -1,5 +1,5 @@
-%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 connective boost_query date_field_facet range_facet abstract_fulltext dismax join
+   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 field_stats
    composite_fulltext field_group).each do |file|

data/lib/sunspot/query/abstract_fulltext.rb

@@ -0,0 +1,69 @@
+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_boost_function(function_query)
+        @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/common_query.rb

@@ -53,14 +53,22 @@ module Sunspot
         stats
       end
 
-      def paginate(page, per_page, offset = nil)
+      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
@@ -85,6 +93,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/dismax.rb

@@ -6,7 +6,7 @@ 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)
@@ -31,34 +31,31 @@ module Sunspot
         params[:fl] = '* score'
         params[:qf] = @fulltext_fields.values.map { |field| field.to_boosted_field }.join(' ')
         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
           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
-        end
+
         @highlights.each do |highlight|
           Sunspot::Util.deep_merge!(params, highlight.to_params)
         end
+
         params
       end
 
@@ -69,68 +66,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_:\"{!edismax #{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

data/lib/sunspot/query/function_query.rb

@@ -4,7 +4,6 @@ module Sunspot
     # Abstract class for function queries.
     #
     class FunctionQuery 
-      include RSolr::Char
 
       def ^(y)
         @boost_amount = y
@@ -34,7 +33,7 @@ module Sunspot
       end
 
       def to_s
-        "#{escape(@field.indexed_name)}" << (@boost_amount ? "^#{@boost_amount}" : "")
+        "#{Util.escape(@field.indexed_name)}" << (@boost_amount ? "^#{@boost_amount}" : "")
       end
     end
 

data/lib/sunspot/query/geo.rb

@@ -21,7 +21,7 @@ module Sunspot
       end
 
       def to_subquery
-        "(#{to_boolean_query})"
+        { :q => "(#{to_boolean_query})" }
       end
 
       private

data/lib/sunspot/query/join.rb

@@ -0,0 +1,90 @@
+module Sunspot
+  module Query
+
+    #
+    # Solr full-text queries use Solr's JoinRequestHandler.
+    #
+    class Join < AbstractFulltext
+      attr_writer :minimum_match, :phrase_slop, :query_phrase_slop, :tie
+
+      def initialize(keywords, target, from, to)
+        @keywords = keywords
+        @target = target
+        @from = from
+        @to = to
+
+        @fulltext_fields = {}
+
+        @minimum_match = nil
+      end
+
+      #
+      # The query as Solr parameters
+      #
+      def to_params
+        params = { :q => @keywords }
+        params[:fl] = '* score'
+        params[:qf] = @fulltext_fields.values.map { |field| field.to_boosted_field }.join(' ')
+        params[:defType] = 'join'
+        params[:mm] = @minimum_match if @minimum_match
+
+        params
+      end
+
+      #
+      # Serialize the query as a Solr nested subquery.
+      #
+      def to_subquery
+        params = self.to_params
+        params.delete :defType
+        params.delete :fl
+
+        keywords = escape_quotes(params.delete(:q))
+        options = params.map { |key, value| escape_param(key, value) }.join(' ')
+        q_name = "q#{@target.name}#{self.object_id}"
+        fq_name = "f#{q_name}"
+
+        {
+          :q => "_query_:\"{!join from=#{@from} to=#{@to} v=$#{q_name} fq=$#{fq_name}}\"",
+          q_name => "_query_:\"{!edismax #{options}}#{keywords}\"",
+          fq_name => "type:#{@target.name}"
+        }
+      end
+
+      #
+      # Assign a new boost query and return it.
+      #
+      def create_boost_query(factor)
+      end
+
+      #
+      # Add a boost function
+      #
+      def add_boost_function(function_query)
+      end
+
+      #
+      # Add a fulltext field to be searched, with optional boost.
+      #
+      def add_fulltext_field(field, boost = nil)
+        super if field.is_a?(Sunspot::JoinField) &&
+          field.target == @target && field.from == @from && field.to == @to
+      end
+
+      #
+      # Add a phrase field for extra boost.
+      #
+      def add_phrase_field(field, boost = nil)
+      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={})
+      end
+
+    end
+  end
+end

data/lib/sunspot/query/pagination.rb

@@ -6,14 +6,18 @@ module Sunspot
     # reference to it and updates it if pagination is changed.
     #
     class Pagination #:nodoc:
-      attr_reader :page, :per_page, :offset
+      attr_reader :page, :per_page, :offset, :cursor
 
-      def initialize(page = nil, per_page = nil, offset = nil)
-        self.offset, self.page, self.per_page = offset, page, per_page
+      def initialize(page = nil, per_page = nil, offset = nil, cursor = nil)
+        self.offset, self.page, self.per_page, self.cursor = offset, page, per_page, cursor
       end
 
       def to_params
-        { :start => start, :rows => rows }
+        if @cursor
+          { :cursorMark => @cursor, :rows => rows }
+        else
+          { :start => start, :rows => rows }
+        end
       end
 
       def page=(page)
@@ -28,6 +32,10 @@ module Sunspot
         @offset = offset.to_i
       end
 
+      def cursor=(cursor)
+        @cursor = cursor if cursor
+      end
+
       private
 
       def start