def _compile_query(self, ixreader):
from whoosh.fields import NUMERIC
from whoosh.support.numeric import tiered_ranges
field = ixreader.schema[self.fieldname]
if not isinstance(field, NUMERIC):
raise Exception("NumericRange: field %r is not numeric" %
self.fieldname)
start = field.prepare_number(self.start)
end = field.prepare_number(self.end)
subqueries = []
# Get the term ranges for the different resolutions
for starttext, endtext in tiered_ranges(field.type, field.signed,
start, end, field.shift_step,
self.startexcl, self.endexcl):
if starttext == endtext:
subq = terms.Term(self.fieldname, starttext)
else:
subq = TermRange(self.fieldname, starttext, endtext)
subqueries.append(subq)
if len(subqueries) == 1:
q = subqueries[0]
elif subqueries:
q = nary.Or(subqueries, boost=self.boost)
else:
return qcore.NullQuery
if self.constantscore:
q = wrappers.ConstantScoreQuery(q, self.boost)
return q
def normalize(self):
if not self.words:
return qcore.NullQuery
if len(self.words) == 1:
t = terms.Term(self.fieldname, self.words[0])
if self.char_ranges:
t.startchar, t.endchar = self.char_ranges[0]
return t
words = [w for w in self.words if w is not None]
return self.__class__(self.fieldname, words, slop=self.slop,
boost=self.boost, char_ranges=self.char_ranges)
def normalize(self):
if self.start in ('', None) and self.end in (u('\uffff'), None):
from whoosh.query import Every
return Every(self.fieldname, boost=self.boost)
elif self.start == self.end:
if self.startexcl or self.endexcl:
return qcore.NullQuery
return terms.Term(self.fieldname, self.start, boost=self.boost)
else:
return TermRange(self.fieldname, self.start, self.end,
self.startexcl, self.endexcl,
boost=self.boost)
def _compile_query(self, ixreader):
from whoosh.fields import NUMERIC
from whoosh.util.numeric import tiered_ranges
field = ixreader.schema[self.fieldname]
if not isinstance(field, NUMERIC):
raise Exception("NumericRange: field %r is not numeric" %
self.fieldname)
start = self.start
if start is not None:
start = field.prepare_number(start)
end = self.end
if end is not None:
end = field.prepare_number(end)
subqueries = []
stb = field.sortable_to_bytes
# Get the term ranges for the different resolutions
ranges = tiered_ranges(
field.numtype,
field.bits,
field.signed,
start,
end,
field.shift_step,
self.startexcl,
self.endexcl,
)
for startnum, endnum, shift in ranges:
if startnum == endnum:
subq = terms.Term(self.fieldname, stb(startnum, shift))
else:
startbytes = stb(startnum, shift)
endbytes = stb(endnum, shift)
subq = TermRange(self.fieldname, startbytes, endbytes)
subqueries.append(subq)
if len(subqueries) == 1:
q = subqueries[0]
elif subqueries:
q = compound.Or(subqueries, boost=self.boost)
else:
return qcore.NullQuery
if self.constantscore:
q = wrappers.ConstantScoreQuery(q, self.boost)
return q
def _and_query(self):
return compound.And([terms.Term(self.fieldname, word)
for word in self.words])