def test_numeric_range():
schema = fields.Schema(id=fields.STORED, number=fields.NUMERIC)
qp = default.QueryParser("number", schema)
teststart = 40
testend = 100
q = qp.parse("[%s to *]" % teststart)
assert q == query.NullQuery
q = qp.parse("[%s to]" % teststart)
assert q.__class__ == query.NumericRange
assert q.start == teststart
assert q.end is None
q = qp.parse("[to %s]" % testend)
assert q.__class__ == query.NumericRange
assert q.start is None
assert q.end == testend
q = qp.parse("[%s to %s]" % (teststart, testend))
assert q.__class__ == query.NumericRange
assert q.start == teststart
assert q.end == testend
def test_fieldname_chars():
s = fields.Schema(abc123=fields.TEXT, nisbah=fields.KEYWORD)
qp = default.QueryParser("content", s)
fieldmap = {'nisbah': [u('\u0646\u0633\u0628\u0629')], 'abc123': ['xyz']}
qp.add_plugin(plugins.FieldAliasPlugin(fieldmap))
q = qp.parse(u("abc123:456"))
assert q.__class__ == query.Term
assert q.fieldname == u('abc123')
assert q.text == u('456')
q = qp.parse(u("abc123:456 def"))
assert text_type(q) == u("(abc123:456 AND content:def)")
q = qp.parse(
u('\u0646\u0633\u0628\u0629:\u0627\u0644\u0641\u0644\u0633'
'\u0637\u064a\u0646\u064a'))
assert q.__class__ == query.Term
assert q.fieldname == u('nisbah')
assert q.text == u(
'\u0627\u0644\u0641\u0644\u0633\u0637\u064a\u0646\u064a')
q = qp.parse(u("abc123 (xyz:123 OR qrs)"))
assert text_type(q) == "(content:abc123 AND (abc123:123 OR content:qrs))"
def test_singlequotes():
p = default.QueryParser(
"t", None, [plugins.WhitespacePlugin(),
plugins.SingleQuotePlugin()])
assert repr(p.process(
"a 'b c' d")) == "<AndGroup <None:'a'>, <None:'b c'>, <None:'d'>>"
def test_empty_querystring():
s = fields.Schema(content=fields.TEXT, title=fields.TEXT, id=fields.ID)
qp = default.QueryParser("content", s)
q = qp.parse(u(""))
assert q == query.NullQuery
def test_fieldname_fieldname():
qp = default.QueryParser("a", None)
q = qp.parse("a:b:")
assert q == query.Term("a", "b:")
def test_roundtrip():
parser = default.QueryParser("a", None)
q = parser.parse(u("a OR ((b AND c AND d AND e) OR f OR g) ANDNOT h"))
assert text_type(
q
) == "((a:a OR (a:b AND a:c AND a:d AND a:e) OR a:f OR a:g) ANDNOT a:h)"
def test_whitespace():
p = default.QueryParser("t", None, [plugins.WhitespacePlugin()])
assert repr(
p.tag("hello there amiga")
) == "<AndGroup <None:'hello'>, < >, <None:'there'>, < >, <None:'amiga'>>"
def test_euro_chars():
schema = fields.Schema(text=fields.TEXT)
qp = default.QueryParser("text", schema)
q = qp.parse(u("stra\xdfe"))
assert q.__class__ == query.Term
assert q.text == u("stra\xdfe")
def test_wild():
p = default.QueryParser("t", None, [plugins.WhitespacePlugin(),
plugins.WildcardPlugin()])
assert_equal(repr(p.process("a b*c? d")),
"<AndGroup <None:'a'>, <None:Wild 'b*c?'>, <None:'d'>>")
def test_analyzing_terms():
schema = fields.Schema(text=fields.TEXT(analyzer=analysis.StemmingAnalyzer()))
qp = default.QueryParser("text", schema)
q = qp.parse(u("Indexed!"))
assert_equal(q.__class__, query.Term)
assert_equal(q.text, "index")
def test_stopped():
schema = fields.Schema(text=fields.TEXT)
qp = default.QueryParser("text", schema)
q = qp.parse(u("a b"), debug=True)
assert_equal(q, query.NullQuery)
def test_groups():
p = default.QueryParser("t", None, [plugins.WhitespacePlugin(),
plugins.GroupPlugin()])
ns = p.process("a ((b c) d) e")
assert_equal(repr(ns), "<AndGroup <None:'a'>, <AndGroup <AndGroup <None:'b'>, <None:'c'>>, <None:'d'>>, <None:'e'>>")
def test_phrase():
p = default.QueryParser("t", None, [plugins.WhitespacePlugin(),
plugins.PhrasePlugin()])
assert_equal(repr(p.process('a "b c"')), "<AndGroup <None:'a'>, <None:PhraseNode 'b c'~1>>")
assert_equal(repr(p.process('"b c" d')), "<AndGroup <None:PhraseNode 'b c'~1>, <None:'d'>>")
assert_equal(repr(p.process('"b c"')), "<AndGroup <None:PhraseNode 'b c'~1>>")
def test_function_plugin():
class FakeQuery(query.Query):
def __init__(self, children, *args, **kwargs):
self.children = children
self.args = args
self.kwargs = kwargs
self.fieldname = None
def __hash__(self):
return hash(tuple(self.children)) ^ hash(self.args)
def __unicode__(self):
qs = "|".join(str(q) for q in self.children)
args = ",".join(self.args)
kwargs = ",".join(
sorted("%s:%s" % item for item in self.kwargs.items()))
return u("<%s %s %s>") % (qs, args, kwargs)
__str__ = __unicode__
def fuzzy(qs, prefix=0, maxdist=2):
prefix = int(prefix)
maxdist = int(maxdist)
return query.FuzzyTerm(qs[0].fieldname,
qs[0].text,
prefixlength=prefix,
maxdist=maxdist)
fp = plugins.FunctionPlugin({"foo": FakeQuery, "fuzzy": fuzzy})
qp = default.QueryParser("f", None)
qp.add_plugin(fp)
def check(qstring, target):
q = qp.parse(u(qstring), normalize=False)
assert str(q) == target
check("alfa #foo charlie delta",
"(f:alfa AND < > AND f:charlie AND f:delta)")
check("alfa #foo(charlie delta) echo",
"(f:alfa AND <f:charlie|f:delta > AND f:echo)")
check("alfa #foo(charlie AND delta) echo",
"(f:alfa AND <(f:charlie AND f:delta) > AND f:echo)")
check("alfa #foo[a] charlie delta",
"(f:alfa AND < a > AND f:charlie AND f:delta)")
check("alfa #foo[a, b](charlie delta) echo",
"(f:alfa AND <f:charlie|f:delta a,b > AND f:echo)")
check("alfa #foo[a,b,c=d](charlie AND delta) echo",
"(f:alfa AND <(f:charlie AND f:delta) a,b c:d> AND f:echo)")
check("alfa #foo[a,b,c=d]() (charlie AND delta)",
"(f:alfa AND < a,b c:d> AND ((f:charlie AND f:delta)))")
check(
"alfa #foo[a=1,b=2](charlie AND delta)^2.0 echo",
"(f:alfa AND <(f:charlie AND f:delta) a:1,b:2,boost:2.0> AND f:echo)")
check("alfa #fuzzy[maxdist=2](bravo) charlie",
"(f:alfa AND f:bravo~2 AND f:charlie)")
def test_prefix():
p = default.QueryParser(
"t", None, [plugins.WhitespacePlugin(),
plugins.PrefixPlugin()])
assert repr(p.process(
"a b* c")) == "<AndGroup <None:'a'>, <None:'b'*>, <None:'c'>>"
def test_boosts():
qp = default.QueryParser("t", None)
q = qp.parse("alfa ((bravo^2)^3)^4 charlie")
assert q.__unicode__() == "(t:alfa AND t:bravo^24.0 AND t:charlie)"
def test_wildcard2():
qp = default.QueryParser("content", None)
q = qp.parse(u("*the?e*"))
assert_equal(q.__class__, query.Wildcard)
assert_equal(q.text, "*the?e*")
def test_stopped():
schema = fields.Schema(text=fields.TEXT)
qp = default.QueryParser("text", schema)
q = qp.parse(u("a b"))
assert q == query.NullQuery
def test_sq_range():
p = default.QueryParser("t", None, [plugins.WhitespacePlugin(),
plugins.SingleQuotePlugin(),
plugins.RangePlugin()])
assert_equal(repr(p.process("['a b' to ']']")),
"<AndGroup <None:['a b' ']']>>")
def test_many_clauses():
qs = "1" + (" OR 1" * 1000)
parser = default.QueryParser("content", None)
parser.parse(qs)
def test_unicode_num():
schema = fields.Schema(num=fields.NUMERIC)
parser = default.QueryParser(u("num"), schema=schema)
q = parser.parse(u("num:1"))
_ = text_type(q)
def test_fieldname_space():
qp = default.QueryParser("a", None)
q = qp.parse("Man Ray: a retrospective")
assert text_type(q) == "(a:Man AND a:Ray: AND a:a AND a:retrospective)"
def test_phrase_boost():
qp = default.QueryParser("f", None)
q = qp.parse(u('Dahmen ANDMAYBE "Besov Spaces"^9'))
assert isinstance(q, query.AndMaybe)
assert q[0] == query.Term("f", u("Dahmen"))
assert q[1] == query.Phrase("f", [u("Besov"), u("Spaces")], boost=9)
def test_operators():
p = default.QueryParser(
"t", None, [plugins.WhitespacePlugin(),
plugins.OperatorsPlugin()])
ns = p.process("a OR b")
assert repr(ns) == "<AndGroup <OrGroup <None:'a'>, <None:'b'>>>"
def test_andmaybe_none():
schema = fields.Schema(f=fields.TEXT, year=fields.NUMERIC)
qp = default.QueryParser("f", schema)
_ = qp.parse(u("Dahmen ANDMAYBE @year:[2000 TO]"))