def _query_filter(self):
criterias = []
for k, v in self.query_params.items():
if k == 'correspondent__id':
criterias.append(query.Term('correspondent_id', v))
elif k == 'tags__id__all':
for tag_id in v.split(","):
criterias.append(query.Term('tag_id', tag_id))
elif k == 'document_type__id':
criterias.append(query.Term('type_id', v))
elif k == 'correspondent__isnull':
criterias.append(query.Term("has_correspondent", v == "false"))
elif k == 'is_tagged':
criterias.append(query.Term("has_tag", v == "true"))
elif k == 'document_type__isnull':
criterias.append(query.Term("has_type", v == "false"))
elif k == 'created__date__lt':
criterias.append(
query.DateRange("created", start=None, end=isoparse(v)))
elif k == 'created__date__gt':
criterias.append(
query.DateRange("created", start=isoparse(v), end=None))
elif k == 'added__date__gt':
criterias.append(
query.DateRange("added", start=isoparse(v), end=None))
elif k == 'added__date__lt':
criterias.append(
query.DateRange("added", start=None, end=isoparse(v)))
if len(criterias) > 0:
return query.And(criterias)
else:
return None
def test_gtlt():
schema = fields.Schema(a=fields.KEYWORD, b=fields.NUMERIC,
c=fields.KEYWORD,
d=fields.NUMERIC(float), e=fields.DATETIME)
qp = qparser.QueryParser("a", schema)
qp.add_plugin(plugins.GtLtPlugin())
qp.add_plugin(dateparse.DateParserPlugin())
q = qp.parse(u("a:hello b:>100 c:<=z there"))
assert_equal(q.__class__, query.And)
assert_equal(len(q), 4)
assert_equal(q[0], query.Term("a", "hello"))
assert_equal(q[1], query.NumericRange("b", 100, None, startexcl=True))
assert_equal(q[2], query.TermRange("c", None, 'z'))
assert_equal(q[3], query.Term("a", "there"))
q = qp.parse(u("hello e:>'29 mar 2001' there"))
assert_equal(q.__class__, query.And)
assert_equal(len(q), 3)
assert_equal(q[0], query.Term("a", "hello"))
# As of this writing, date ranges don't support startexcl/endexcl
assert_equal(q[1], query.DateRange("e", datetime(2001, 3, 29, 0, 0), None))
assert_equal(q[2], query.Term("a", "there"))
q = qp.parse(u("a:> alfa c:<= bravo"))
assert_equal(text_type(q), "(a:a: AND a:alfa AND a:c: AND a:bravo)")
qp.remove_plugin_class(plugins.FieldsPlugin)
qp.remove_plugin_class(plugins.RangePlugin)
q = qp.parse(u("hello a:>500 there"))
assert_equal(text_type(q), "(a:hello AND a:a: AND a:500 AND a:there)")
def query(self, parser):
from whoosh import query
fieldname = self.fieldname or parser.fieldname
return query.DateRange(fieldname,
self.start,
self.end,
boost=self.boost)
def query(self, parser):
from whoosh import query
fieldname = self.fieldname or parser.fieldname
start = self.starttime
end = self.endtime
if start is None and end is None:
return query.Every(fieldname)
else:
return query.DateRange(fieldname, start, end, boost=self.boost)
def test_daterange_empty_field():
schema = fields.Schema(test=fields.DATETIME)
ix = RamStorage().create_index(schema)
writer = ix.writer()
writer.add_document(test=None)
writer.commit()
with ix.searcher() as s:
q = query.DateRange("test", datetime.fromtimestamp(0), datetime.today())
r = s.search(q)
assert_equal(len(r), 0)
def query(self, parser):
from whoosh import query
field = parser.schema[self.fieldname]
dt = self.timeobj
if isinstance(self.timeobj, datetime):
return query.Term(self.fieldname, field.to_text(dt),
boost=self.boost)
elif isinstance(self.timeobj, timespan):
return query.DateRange(self.fieldname, dt.start, dt.end,
boost=self.boost)
else:
raise Exception("Unknown time object: %r" % dt)
def query(self, parser):
from whoosh import query
fieldname = self.fieldname or parser.fieldname
field = parser.schema[fieldname]
dt = self.dt
if isinstance(self.dt, datetime):
btext = field.to_bytes(dt)
return query.Term(fieldname, btext, boost=self.boost)
elif isinstance(self.dt, timespan):
return query.DateRange(fieldname, dt.start, dt.end,
boost=self.boost)
else:
raise Exception("Unknown time object: %r" % dt)
