ferret 0.1.0

data/lib/ferret/search/prefix_query.rb

@@ -0,0 +1,47 @@
+module Ferret::Search
+  # A Query that matches documents containing terms with a specified prefix. A
+  # PrefixQuery is built by QueryParser for input like +app*+. 
+  class PrefixQuery < Query 
+    attr_reader :prefix
+    # Constructs a query for terms starting with +prefix+. 
+    def initialize(prefix) 
+      super()
+      @prefix = prefix
+    end
+
+    def rewrite(reader)
+      bq = BooleanQuery.new(true)
+      enumerator = reader.terms_from(@prefix)
+      begin 
+        prefix_text = @prefix.text
+        prefix_length = prefix_text.length
+        prefix_field = @prefix.field
+        begin 
+          term = enumerator.term
+          if (term.nil? or
+            term.field != prefix_field or
+            term.text[0,prefix_length] != prefix_text)
+            break
+          end
+            tq = TermQuery.new(term)                        # found a match
+            tq.boost = boost()                              # set the boost
+            bq.add_query(tq, BooleanClause::Occur::SHOULD)  # add to query
+            #puts("added " + term)
+        end while (enumerator.next?)
+      ensure 
+        enumerator.close()
+      end
+      return bq
+    end
+
+    # Prints a user-readable version of this query. 
+    def to_s(f) 
+      buffer = ""
+      buffer << "#{@prefix.field}:" if @prefix.field != f
+      buffer << "#{@prefix.text}*"
+      buffer << "^#{boost()}" if boost() != 1.0 
+      return buffer
+    end
+
+  end
+end

data/lib/ferret/search/query.rb

@@ -0,0 +1,111 @@
+module Ferret::Search
+  # The abstract base class for queries.
+  # Instantiable subclasses are:
+  #    * TermQuery
+  #    * MultiTermQuery
+  #    * BooleanQuery
+  #    * WildcardQuery
+  #    * PhraseQuery
+  #    * PrefixQuery
+  #    * MultiPhraseQuery
+  #    * FuzzyQuery
+  #    * RangeQuery
+  #    * Span::SpanQuery
+  #
+  # A parser for queries is contained in:
+  #    * Ferret::QueryParser::QueryParser
+  #
+  class Query
+    # documents matching this query clause will (in addition to the normal
+    # weightings) have their score multiplied by the boost factor. It is
+    # 1.0 be default.
+    attr_accessor :boost
+
+    def initialize()
+      @boost = 1.0
+    end
+
+    # Prints a query to a string, with +field+ as the default field for
+    # terms.  The representation used is one that is supposed to be readable
+    # by Ferret::QueryParser::QueryParser. However, there are the following
+    # limitations:
+    # * If the query was created by the parser, the printed representation
+    #   may not be exactly what was parsed. For example, characters that need
+    #   to be escaped will be represented without the required backslash.
+    # * Some of the more complicated queries (e.g. span queries)
+    #   don't have a representation that can be parsed by QueryParser.
+    def to_s(field=nil)
+      raise NotImplementedError
+    end
+
+    # Expert: Constructs an appropriate Weight implementation for this query.
+    # 
+    # Only implemented by primitive queries, which re-write to themselves.
+    def create_weight(searcher)
+      raise NotImplementedError
+    end
+
+    # Expert: Constructs and initializes a Weight for a top-level query. 
+    def weight(searcher)
+      query = searcher.rewrite(self)
+      weight = query.create_weight(searcher)
+      sum = weight.sum_of_squared_weights()
+      norm = similarity(searcher).query_norm(sum)
+      weight.normalize(norm)
+      return weight
+    end
+
+    # Expert: called to re-write queries into primitive queries. 
+    def rewrite(reader)
+      return self
+    end
+
+    # Expert: called when re-writing queries under MultiSearcher.
+    # 
+    # Only implemented by derived queries, with no #create_weight()
+    # implementatation.
+    def combine(queries) 
+      queries.each do |query|
+        if self != query
+          raise ArgumentError
+        end
+      end
+      return self
+    end
+
+    # Expert: adds all terms occuring in this query to the terms set
+    def extract_terms(terms) 
+      raise NotImplementedError
+    end
+
+
+    # Expert: merges the clauses of a set of BooleanQuery's into a single
+    # BooleanQuery.
+    # 
+    # A utility for use by #combine() implementations.
+    def merge_boolean_queries(queries) 
+      all_clauses = Set.new
+      queries.each do |query|
+        query.clauses.each do |clause|
+          all_clauses << clause
+        end
+      end
+
+      coord_disabled = queries.size==0 ? false : queries[0].coord_disabled?
+      result = BooleanQuery.new(coord_disabled)
+      all_clauses.each do |clause|
+        result << clause
+      end
+      return result
+    end
+
+    # Expert: Returns the Similarity implementation to be used for this
+    # query.  Subclasses may override this method to specify their own
+    # Similarity implementation, perhaps one that delegates through that of
+    # the Searcher.  By default the Searcher's Similarity implementation is
+    # returned.
+    def similarity(searcher) 
+      return searcher.similarity
+    end
+  end
+end

data/lib/ferret/search/query_filter.rb

@@ -0,0 +1,51 @@
+module Ferret::Search
+  require 'monitor'
+  # Constrains search results to only match those which also match a provided
+  # query.  Results are cached, so that searches after the first on the same
+  # index using this filter are much faster.
+  # 
+  # This could be used, for example, with a RangeQuery on a suitably formatted
+  # date field to implement date filtering.  One could re-use a single
+  # QueryFilter that matches, e.g., only documents modified within the last
+  # week.  The QueryFilter and RangeQuery would only need to be reconstructed
+  # once per day.
+  class QueryFilter < Filter 
+
+    # Constructs a filter which only matches documents matching
+    # +query+.
+    def initialize(query) 
+      @query = query
+      @cache = nil 
+    end
+
+    def bits(reader)
+
+      if (@cache == nil) 
+        @cache = Ferret::Utils::WeakKeyHash.new.extend(MonitorMixin)
+      end
+
+      @cache.synchronize() do # check cache
+        bits = @cache[reader]
+        if bits
+          return bits
+        end
+      end
+
+      bits = Ferret::Utils::BitVector.new()
+
+      IndexSearcher.new(reader).search_each(@query) do |doc, score|
+        bits.set(doc)  # set bit for hit
+      end
+
+      @cache.synchronize() do # update cache
+        @cache[reader] = bits
+      end
+
+      return bits
+    end
+
+    def to_s() 
+      return "QueryFilter(#{@query})"
+    end
+  end
+end

data/lib/ferret/search/range_filter.rb

@@ -0,0 +1,103 @@
+module Ferret::Search
+  # A Filter that restricts search results to a range of values in a given
+  # field.
+  # 
+  # This code borrows heavily from RangeQuery, but is implemented as a Filter.
+  class RangeFilter < Filter 
+    include Ferret::Index
+
+    # field_name:: The field this range applies to
+    # lower_term:: The lower bound on this range
+    # upper_term:: The upper bound on this range
+    # include_lower:: Does this range include the lower bound?
+    # include_upper:: Does this range include the upper bound?
+    def initialize(field_name, lower_term, upper_term, include_lower, include_upper) 
+      @field_name = field_name
+      @lower_term = lower_term
+      @upper_term = upper_term
+      @include_lower = include_lower
+      @include_upper = include_upper
+      
+      if (lower_term.nil? and upper_term.nil?) 
+        raise ArgumentError, "At least one value must be non-nil"
+      end
+      if (include_lower and lower_term.nil?) 
+        raise ArgumentError, "The lower bound must be non-nil to be inclusive"
+      end
+      if (include_upper and upper_term.nil?) 
+        raise ArgumentError, "The upper bound must be non-nil to be inclusive"
+      end
+      if (upper_term and lower_term and upper_term < lower_term)
+        raise ArgumentError, "The lower bound must less than the upper bound"
+      end
+    end
+    
+    # Constructs a filter for field +field_name+ matching less than or equal to
+    # +upper_term+.
+    def RangeFilter.new_less(field_name, upper_term, include_upper = true) 
+      return RangeFilter.new(field_name, nil, upper_term, false, include_upper)
+    end
+
+    # Constructs a filter for field +field_name+ matching greater than or equal
+    # to +lower_term+.
+    def RangeFilter.new_more(field_name, lower_term, include_lower = true) 
+      return RangeFilter.new(field_name, lower_term, nil, include_lower, false)
+    end
+    
+    # Returns a BitVector with true for documents which should be permitted in
+    # search results, and false for those that should not.
+    def bits(reader)
+      bits = Ferret::Utils::BitVector.new()
+      term_enum = reader.terms_from(Term.new(@field_name, @lower_term||""))
+      
+      begin 
+        if (term_enum.term() == nil) 
+          return bits
+        end
+        check_lower = !@include_lower # make adjustments to set to exclusive
+      
+        term_docs = reader.term_docs
+        begin 
+          begin 
+            term = term_enum.term()
+            break if (term.nil? or term.field != @field_name) 
+
+            if (!check_lower or @lower_term.nil? or term.text > @lower_term) 
+              check_lower = false
+              if @upper_term
+                compare = @upper_term <=> term.text
+                # if beyond the upper term, or is exclusive and
+                # this is equal to the upper term, break out 
+                if ((compare < 0) or (!@include_upper and compare == 0))
+                  break
+                end
+              end
+              # we have a good term, find the docs 
+              
+              term_docs.seek(term_enum)
+              while term_docs.next?
+                bits.set(term_docs.doc)
+              end
+            end
+          end while term_enum.next?
+        ensure 
+          term_docs.close()
+        end
+      ensure 
+        term_enum.close()
+      end
+
+      return bits
+    end
+    
+    def to_s() 
+      buffer = "#{@field_name}:"
+      buffer << "[" if @include_lower
+      buffer << @lower_term if @lower_term
+      buffer << "-"
+      buffer << @upper_term if @upper_term
+      buffer << @include_upper ? "]" : "end"
+      return buffer
+    end
+  end
+end

data/lib/ferret/search/range_query.rb

@@ -0,0 +1,139 @@
+module Ferret::Search
+  # A Query that matches documents within an exclusive range. A RangeQuery
+  # is built by QueryParser for input like +[010 120]+.
+  class RangeQuery < Query
+    include Ferret::Index
+
+    attr_reader :lower_term, :upper_term
+
+    # Constructs a query selecting all terms greater than
+    # +lower_term+ but less than +upper_term+.
+    # There must be at least one term and either term may be nil,
+    # in which case there is no bound on that side, but if there are
+    # two terms, both terms *must* be for the same field.
+    #
+    # field:: The field this range applies to
+    # lower_term:: The lower bound on this range
+    # upper_term:: The upper bound on this range
+    # include_lower:: Does this range include the lower bound?
+    # include_upper:: Does this range include the upper bound?
+    def initialize(field, lower_term, upper_term, include_lower, include_upper) 
+      super()
+      @field = field
+      @lower_term = lower_term
+      @upper_term = upper_term
+      @include_lower = include_lower
+      @include_upper = include_upper
+      
+      if (lower_term.nil? and upper_term.nil?) 
+        raise ArgumentError, "At least one value must be non-nil"
+      end
+      if (include_lower and lower_term.nil?) 
+        raise ArgumentError, "The lower bound must be non-nil to be inclusive"
+      end
+      if (include_upper and upper_term.nil?) 
+        raise ArgumentError, "The upper bound must be non-nil to be inclusive"
+      end
+      if (upper_term and lower_term and upper_term < lower_term)
+        raise ArgumentError, "The lower bound must less than the upper bound"
+      end
+    end
+    
+    # Constructs a query for field +field+ matching less than or equal to
+    # +upper_term+.
+    def RangeQuery.new_less(field, upper_term, include_upper = true) 
+      return RangeQuery.new(field, nil, upper_term, false, include_upper)
+    end
+
+    # Constructs a query for field +field+ matching greater than or equal
+    # to +lower_term+.
+    def RangeQuery.new_more(field, lower_term, include_lower = true) 
+      return RangeQuery.new(field, lower_term, nil, include_lower, false)
+    end
+
+    def rewrite(reader)
+      bq = BooleanQuery.new(true)
+      term_enum = reader.terms_from(Term.new(@field, @lower_term||""))
+
+      begin 
+        check_lower = !@include_lower
+        test_field = field()
+        begin 
+          term = term_enum.term
+
+          break if term.nil? or term.field != @field         
+          if (!check_lower or @lower_term.nil? or term.text > @lower_term) 
+            check_lower = false
+            if @upper_term
+              compare = @upper_term <=> term.text
+
+              # if beyond the upper term, or is exclusive and
+              # this is equal to the upper term, break out 
+              if ((compare < 0) or (not @include_upper and compare == 0))
+                break
+              end
+            end
+            tq = TermQuery.new(term) # found a match
+            tq.boost = boost()       # set the boost
+            bq.add_query(tq, BooleanClause::Occur::SHOULD) # add to query
+          end
+        end while term_enum.next?
+      ensure 
+        term_enum.close()
+      end
+      return bq
+    end
+
+    # Returns the field name for this query 
+    attr_reader :field, :lower_term, :upper_term, :include_lower, :include_upper
+
+    # Prints a user-readable version of this query. 
+    def to_s(f=nil)
+      buffer = ""
+      buffer << "#{@field}:" if field() != f
+
+      if @lower_term
+        buffer << (@include_lower ? "[" : "{")
+        buffer << @lower_term
+      else
+        buffer << "|"
+      end
+
+      buffer << " " if @upper_term and @lower_term
+
+      if @upper_term
+        buffer << @upper_term
+        buffer << (@include_upper ? "]" : "}")
+      else
+        buffer << "|"
+      end
+
+      if boost() != 1.0
+        buffer << "^#{boost()}"
+      end
+      return buffer 
+    end
+
+    # Returns true iff +o+ is equal to this. 
+    def eql?(o) 
+      return ((o.instance_of?(RangeQuery)) and 
+          (boost() == o.boost()) and
+          (@include_upper == o.include_upper) and
+          (@include_lower == o.include_lower) and
+          (@upper_term == o.upper_term) and
+          (@lower_term == o.lower_term) and
+          (@field == o.field))
+    end
+    alias :== :eql?
+
+    # Returns a hash code value for this object.
+    def hash() 
+      return (boost().hash ^
+              @field.hash ^
+              @lower_term.hash ^
+              @upper_term.hash ^
+              @include_lower.hash ^
+              @include_upper.hash)
+    end
+  end
+end