Class: Ferret::Search::Spans::SpanNearQuery

Inherits:
SpanQuery show all
Defined in:
lib/ferret/search/spans/span_near_query.rb

Overview

Matches spans which are near one another. One can specify slop, the maximum number of intervening unmatched positions, as well as whether matches are required to be in-order.

Instance Attribute Summary collapse

Attributes inherited from Query

#boost

Instance Method Summary collapse

Methods inherited from SpanQuery

#create_weight

Methods inherited from Query

#combine, #create_weight, #extract_terms, #merge_boolean_queries, #similarity, #weight

Constructor Details

#initialize(clauses, slop, in_order) ⇒ SpanNearQuery

Construct a SpanNearQuery. Matches spans matching a span from each clause, with up to slop total unmatched positions between them. When in_order is true, the spans from each clause must be ordered as in clauses.



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/ferret/search/spans/span_near_query.rb', line 11

def initialize(clauses, slop, in_order) 
  super()
  # copy clauses array into an ArrayList
  @clauses = Array.new(clauses.length)
  @field = nil
  clauses.each_index do |i|
    clause = clauses[i]
    if i == 0 # check field
      @field = clause.field()
    elsif clause.field() != @field
      raise ArgumentError, "Clauses must have same field."
    end
    @clauses[i] = clause
  end

  @slop = slop
  @in_order = in_order
end

Instance Attribute Details

#field ⇒ Object (readonly)

Returns the value of attribute field.



39
40
41
 
# File 'lib/ferret/search/spans/span_near_query.rb', line 39

def field
  @field
end

Instance Method Details

#clauses ⇒ Object

Return the clauses whose spans are matched.



31
 
# File 'lib/ferret/search/spans/span_near_query.rb', line 31

def clauses() @clauses end

#eql?(o) ⇒ Boolean Also known as: ==

Returns true iff o is equal to this.

Returns:

  • (Boolean) 


88
89
90
91
92
93
94
95
96
97
 
# File 'lib/ferret/search/spans/span_near_query.rb', line 88

def eql?(o) 
  return false if (o == nil or self.class() != o.class())

  return false if (@in_order != o.in_order?)
  return false if (@slop != o.slop)
  return false if (@clauses != o.clauses)
  return false if (@field != o.field)

  return true
end

#hash ⇒ Object 



100
101
102
103
104
105
106
 
# File 'lib/ferret/search/spans/span_near_query.rb', line 100

def hash() 
  result = @clauses.hash()
  result += @slop * 29
  result +=  (@in_order ? 1 : 0)
  result ^= @field.hash()
  return result
end

#in_order? ⇒ Boolean

Return true if matches are required to be in-order.

Returns:

  • (Boolean) 


37
 
# File 'lib/ferret/search/spans/span_near_query.rb', line 37

def in_order?() @in_order end

#rewrite(reader) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/ferret/search/spans/span_near_query.rb', line 68

def rewrite(reader)
  clone = nil
  @clauses.each_index do |i|
    clause = @clauses[i]
    query = clause.rewrite(reader)
    if (query != clause) # clause rewrote: must clone
      if (clone == nil)
        clone = self.clone()
      end
      clone.clauses[i] = query
    end
  end
  if (clone != nil) 
    return clone                        # some clauses rewrote
  else 
    return self                         # no clauses rewrote
  end
end

#slop ⇒ Object

Return the maximum number of intervening unmatched positions permitted.



34
 
# File 'lib/ferret/search/spans/span_near_query.rb', line 34

def slop() @slop end

#spans(reader) ⇒ Object 



56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/ferret/search/spans/span_near_query.rb', line 56

def spans(reader)
  if (@clauses.size() == 0)                      # optimize 0-clause case
    return SpanOrQuery.new(@clauses).spans(reader)
  end

  if (@clauses.size() == 1)                      # optimize 1-clause case
    return @clauses[0].spans(reader)
  end

  return NearSpansEnum.new(self, reader)
end

#terms ⇒ Object 



41
42
43
44
45
46
47
 
# File 'lib/ferret/search/spans/span_near_query.rb', line 41

def terms() 
  terms = []
  @clauses.each do |clause|
    terms += clause.terms
  end
  return terms
end

#to_s(field = nil) ⇒ Object 



49
50
51
52
53
54
 
# File 'lib/ferret/search/spans/span_near_query.rb', line 49

def to_s(field = nil) 
  buffer = "span_near(["
  buffer << @clauses.map {|c| c.to_s(field)}.join(", ")
  buffer << "], #{@stop}, #{@in_order})"
  return buffer
end