def testOrExpressions(self):
expression = cqlToExpression('field0=value0 AND field1=value1 OR field2 = value2')
self.assertEquals(QueryExpression(
operator='OR',
operands=[
QueryExpression(
operator='AND',
operands=[
QE('field0=value0'),
QE('field1=value1'),
]
),
QE('field2=value2'),
]
), expression)
expression2 = cqlToExpression('(field0=value0 AND field1=value1) OR field2 = value2')
self.assertEquals(expression, expression2)
expression = cqlToExpression('field0=value0 AND (field1=value1 OR field2 = value2)')
self.assertEquals(QueryExpression(
operator='AND',
operands=[
QE('field0=value0'),
QueryExpression(
operator='OR',
operands=[
QE('field1=value1'),
QE('field2=value2'),
]
),
]
), expression)
def testReplaceWith(self):
qe = cqlToExpression('aap AND noot')
replacement = cqlToExpression('fiets')
qe.operands[1].replaceWith(replacement)
self.assertEquals(cqlToExpression('aap AND fiets'), qe)
qe.operands[0].replaceWith(cqlToExpression('boom OR vis'))
self.assertEquals(cqlToExpression('(boom OR vis) AND fiets'), qe)
def testJoin(self):
remote = SynchronousRemote(host='localhost', port=self.httpPort, path='/remote')
q = ComposedQuery('main', query=cqlToExpression('*'))
q.addMatch(dict(core='main', uniqueKey=KEY_PREFIX+'field'), dict(core='main2', key=KEY_PREFIX+'field'))
q.start=0
q.stop=100
q.addFilterQuery(core='main', query=cqlToExpression('field2=value0 OR field2=value1'))
q.addFacet(core='main2', facet=dict(fieldname='untokenized.field2', maxTerms=5))
response = remote.executeComposedQuery(query=q)
self.assertEquals(19, response.total)
self.assertEquals(set([
'record:10', 'record:11', 'record:20', 'record:21', 'record:30',
'record:31', 'record:40', 'record:41', 'record:50', 'record:51',
'record:60', 'record:61', 'record:70', 'record:71', 'record:80',
'record:81', 'record:90', 'record:91', 'record:100'
]), set([hit.id for hit in response.hits]))
self.assertEquals([{
'fieldname': 'untokenized.field2',
'path': [],
'terms': [
{'count': 27, 'term': 'value3'},
{'count': 22, 'term': 'value0'},
{'count': 19, 'term': 'value5'},
{'count': 19, 'term': 'value7'},
{'count': 19, 'term': 'value9'},
]
}], response.drilldownData)
def testIter(self):
qe = cqlToExpression('aap NOT (noot OR title=mies)')
result = list(qe.iter())
self.assertEquals(qe, result[0])
self.assertEquals(cqlToExpression('aap'), result[1])
r2 = cqlToExpression('noot OR title=mies')
r2.must_not = True
self.assertEquals(r2, result[2])
self.assertEquals(cqlToExpression('noot'), result[3])
self.assertEquals(cqlToExpression('title=mies'), result[4])
def testAndExpressionMoreThanOne(self):
expression = cqlToExpression('field0=value0 AND field1=value1 AND field2 = value2')
self.assertEquals("AND", expression.operator)
self.assertEquals(3, len(expression.operands))
self.assertEquals([QE('field0=value0'), QE('field1=value1'), QE('field2=value2')], expression.operands)
expression = cqlToExpression('field0=value0 AND (field1=value1 AND field2=value2)')
self.assertEquals(QueryExpression(
operator='AND',
operands=[QE('field0=value0'), QE('field1=value1'), QE('field2=value2')],
), expression)
def executeQuery(self, query=None, core=None, filterQueries=None, **kwargs):
if 'cqlAbstractSyntaxTree' in kwargs:
query = kwargs.pop('cqlAbstractSyntaxTree')
expression = cqlToExpression(query)
if core is None:
core = self._defaultCore
convertMethod = self._converts[core]
if filterQueries:
filterQueries = [convertMethod(cqlToExpression(ast)) for ast in filterQueries]
response = yield self.any.executeQuery(core=core, luceneQuery=convertMethod(expression), filterQueries=filterQueries, **kwargs)
raise StopIteration(response)
def testEquals(self):
self.assertEquals(QueryExpression(index='field', relation='=', term='term'), QueryExpression(index='field', relation='=', term='term'))
self.assertEquals(cqlToExpression('field=value AND otherfield=othervalue'), QueryExpression(operator='AND', operands=[QE('field=value'), QE('otherfield=othervalue')]))
self.assertTrue(QueryExpression.searchterm('a') == QueryExpression.searchterm('a'))
self.assertFalse(QueryExpression.searchterm('a') != QueryExpression.searchterm('a'))
self.assertFalse(QueryExpression.searchterm('a') == QueryExpression.searchterm('b'))
self.assertTrue(QueryExpression.searchterm('a') != QueryExpression.searchterm('b'))
def testRemoteServiceWithBadCore(self):
remote = SynchronousRemote(host='localhost',
port=self.httpPort,
path='/remote')
self.assertRaises(
IOError, lambda: remote.executeQuery(cqlToExpression('*'),
core='doesnotexist'))
def testNot(self):
expression = cqlToExpression('term NOT thisterm')
self.assertEquals(QueryExpression(
operator='AND',
operands=[
QE('term'),
QE('thisterm', must_not=True),
]
), expression)
def testJoinWithSortAndMissingValue(self):
remote = SynchronousRemote(host='localhost', port=self.httpPort, path='/remote')
q = ComposedQuery('main', query=cqlToExpression('*'))
q.addMatch(dict(core='main', uniqueKey=KEY_PREFIX+'field'), dict(core='main2', key=KEY_PREFIX+'field'))
q.addFacet(core='main2', facet=dict(fieldname='untokenized.field2', maxTerms=5))
q.addSortKey(dict(core="main", sortBy="sorted.field4", sortDescending=True))
response = remote.executeComposedQuery(query=q)
self.assertEqual("record:1", response.hits[0].id)
del q._sortKeys[:]
q.addSortKey(dict(core="main", sortBy="sorted.field4", sortDescending=False))
response = remote.executeComposedQuery(query=q)
self.assertEqual("record:1", response.hits[0].id)
def executeQuery(self,
query=None,
core=None,
filterQueries=None,
**kwargs):
if 'cqlAbstractSyntaxTree' in kwargs:
query = kwargs.pop('cqlAbstractSyntaxTree')
expression = cqlToExpression(query)
if core is None:
core = self._defaultCore
convertMethod = self._converts[core]
if filterQueries:
filterQueries = [
convertMethod(cqlToExpression(ast)) for ast in filterQueries
]
response = yield self.any.executeQuery(
core=core,
luceneQuery=convertMethod(expression),
filterQueries=filterQueries,
**kwargs)
raise StopIteration(response)
def testPrettyPrint(self):
expression = cqlToExpression('aap NOT (noot OR title=mies)')
prettyTrue = expression.toString(pretty_print=True)
self.assertEquals("""\
AND
'aap'
!OR
'noot'
'title = mies'\
""", prettyTrue)
prettyDefault = expression.toString()
self.assertEquals(prettyTrue, prettyDefault)
prettyFalse = expression.toString(pretty_print=False)
self.assertEquals("AND['aap', !OR['noot', 'title = mies']]", prettyFalse)
def testNotNested(self):
expression = cqlToExpression('term NOT (A AND B)')
self.assertEquals(QueryExpression(
operator='AND',
operands=[
QE('term'),
QueryExpression(
operator='AND',
must_not=True,
operands=[
QE('A'),
QE('B'),
]
),
]
), expression)
def compose(self, ast):
return self._queryExpressionToLuceneQuery.convert(cqlToExpression(ast))
def testStrWithIndexAndQuotes(self):
qe = cqlToExpression('field="aap noot"')
self.assertEquals("QueryExpression(index='field', term='aap noot', relation='=', must_not=False, relation_boost=None, operator=None)", repr(qe))
self.assertEquals('\'field = "aap noot"\'', str(qe))
def testAndExpression(self):
expression = cqlToExpression('field0=value0 AND field1=value1')
self.assertEquals("AND", expression.operator)
self.assertEquals(2, len(expression.operands))
self.assertEquals(['field0', 'field1'], [e.index for e in expression.operands])
def compose(self, ast):
return self._queryExpressionToLuceneQuery.convert(cqlToExpression(ast))
def testSimpleExpressionWithoutIndex(self):
expression = cqlToExpression('value')
self.assertEquals(None, expression.index)
self.assertEquals(None, expression.relation)
self.assertEquals("value", expression.term)
def testSimpleQuotedTermExpression(self):
expression = cqlToExpression('"the value"')
self.assertEquals(None, expression.index)
self.assertEquals(None, expression.relation)
self.assertEquals("the value", expression.term)
self.assertEquals('\'"the value"\'', str(expression))
def testRemoteServiceWithBadCore(self):
remote = SynchronousRemote(host='localhost', port=self.httpPort, path='/remote')
self.assertRaises(IOError, lambda: remote.executeQuery(cqlToExpression('*'), core='doesnotexist'))
def testSimpleExpressionWithParenthesis(self):
expression = cqlToExpression('((field=value))')
self.assertEquals("field", expression.index)
self.assertEquals("=", expression.relation)
self.assertEquals("value", expression.term)
def testRepr(self):
qe = cqlToExpression('aap NOT (noot OR title=mies)')
self.assertEquals("QueryExpression(operator='AND', operands=[QueryExpression(index=None, term='aap', relation=None, must_not=False, relation_boost=None, operator=None), QueryExpression(operator='OR', operands=[QueryExpression(index=None, term='noot', relation=None, must_not=False, relation_boost=None, operator=None), QueryExpression(index='title', term='mies', relation='=', must_not=False, relation_boost=None, operator=None)], must_not=True, relation_boost=None)], must_not=False, relation_boost=None)", repr(qe))
self.assertEquals(qe, eval(repr(qe)))
def testRemoteServiceOnBadPath(self):
remote = SynchronousRemote(host='localhost', port=self.httpPort, path='/does/not/exist')
self.assertRaises(IOError, lambda: remote.executeQuery(cqlToExpression('*')))
def testRemoteService(self):
remote = SynchronousRemote(host='localhost', port=self.httpPort, path='/remote')
response = remote.executeQuery(cqlToExpression('*'))
self.assertEquals(100, response.total)
def testRemoteServiceOnBadPath(self):
remote = SynchronousRemote(host='localhost', port=self.httpPort, path='/does/not/exist')
self.assertRaises(IOError, lambda: remote.executeQuery(cqlToExpression('*')))
def testRemoteService(self):
remote = SynchronousRemote(host='localhost', port=self.httpPort, path='/remote')
response = remote.executeQuery(cqlToExpression('*'))
self.assertEquals(100, response.total)
def testBoost(self):
expression = cqlToExpression("title =/boost=2.0 cats")
self.assertEqual(QE('title=cats', relation_boost=2.0), expression)
def testAsDictFromDict(self):
expression = cqlToExpression('aap NOT (noot OR title=mies) AND subject =/boost=3.0 boeien')
d = expression.asDict()
self.assertEquals(dict, type(d))
self.assertEquals(expression, QueryExpression.fromDict(d))
def testAcceptsCqlAstAndQueryExpression(self):
a = cqlToExpression('field = value')
b = cqlToExpression(parseCql('field = value'))
c = cqlToExpression(b)
self.assertEquals(a, b)
self.assertEquals(a, c)
def testSimpleExpression(self):
expression = cqlToExpression(parseCql('field=value'))
self.assertEquals("field", expression.index)
self.assertEquals("=", expression.relation)
self.assertEquals("value", expression.term)
