def testIsSingleCoreQuery(self): cq = ComposedQuery('coreA') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.setCoreQuery('coreA', query='A') self.assertTrue(cq.isSingleCoreQuery()) cq.addUnite(dict(core='coreA', query='Q5'), dict(core='coreB', query='Q6')) self.assertFalse(cq.isSingleCoreQuery())
def testUniteMakesItTwoCoreQuery(self): cq = ComposedQuery('coreA') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.setCoreQuery('coreA', query='A') cq.addUnite(dict(core='coreA', query='Q5'), dict(core='coreB', query='Q6')) cq.validate() self.assertEquals(set(['coreA', 'coreB']), cq.cores)
def testUnite(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query=None) cq.setCoreQuery(core='coreB', query=None) cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='AQuery'), dict(core='coreB', query='anotherQuery')) self.assertEquals([('coreA', 'AQuery'), ('coreB', 'anotherQuery')], cq.unites)
def testConvertAllQueriesWithUnqualifiedTermFields(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query='Q0') cq.addFilterQuery('coreA', 'Q1') cq.addFilterQuery('coreA', 'Q2') cq.setCoreQuery(core='coreB', query='Q3') cq.addFilterQuery('coreB', 'Q4') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='Q5'), dict(core='coreB', query='Q6')) cq.unqualifiedTermFields = [('field0', 2.0), ('field1', 3.0)] convertCoreA = lambda query, unqualifiedTermFields=None, **kwargs: "Converted_A_{0}_{1}".format( query, not unqualifiedTermFields is None) convertCoreB = lambda query, **kwargs: "Converted_B_{0}".format(query) cq.convertWith(coreA=convertCoreA, coreB=convertCoreB) self.assertEquals("Converted_A_Q0_True", cq.queryFor('coreA')) self.assertEquals(["Converted_A_Q1_True", "Converted_A_Q2_True"], cq.filterQueriesFor('coreA')) self.assertEquals("Converted_B_Q3", cq.queryFor('coreB')) self.assertEquals(["Converted_B_Q4"], cq.filterQueriesFor('coreB')) self.assertEqual(1, len(cq.unites)) uniteQueries = list(cq.unites[0].queries()) self.assertEquals('Converted_A_Q5_True', uniteQueries[0][0]['query']) self.assertEquals('Converted_B_Q6', uniteQueries[1][0]['query'])
def testAsDictFromDict(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query='Q0') cq.addFilterQuery(core='coreA', query='Q1') cq.addFilterQuery(core='coreA', query='Q2') cq.addFacet(core='coreA', facet='F0') cq.addFacet(core='coreA', facet='F1') cq.setCoreQuery(core='coreB', query='Q3') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='AQuery'), dict(core='coreB', query='anotherQuery')) cq.start = 0 cq.sortKeys = [dict(sortBy='field', sortDescending=True)] cq.clustering = True cq.clusteringConfig = {'clusteringEps': 0.2} d = cq.asDict() cq2 = ComposedQuery.fromDict(d) self.assertEquals('coreA', cq2.resultsFrom) self.assertEquals(0, cq2.start) self.assertEquals(None, cq2.stop) self.assertEquals(['Q0', 'Q1', 'Q2'], cq2.queriesFor('coreA')) self.assertEquals(['F0', 'F1'], cq2.facetsFor('coreA')) self.assertEquals('keyA', cq2.keyName('coreA', 'coreB')) self.assertEquals('keyB', cq2.keyName('coreB', 'coreA')) self.assertEqual(1, len(cq2.unites)) queries = list(cq2.unites[0].queries()) self.assertEquals(({'core': 'coreA', 'keyName': 'keyA', 'query': 'AQuery'}, 'keyA'), queries[0]) self.assertEquals(({'core': 'coreB', 'keyName': 'keyB', 'query': 'anotherQuery'}, 'keyA'), queries[1]) self.assertEquals({'clusteringEps': 0.2}, cq2.clusteringConfig)
def testFilterQueries(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query='Q0') cq.addFilterQuery(core='coreA', query='Q1') cq.addFilterQuery(core='coreA', query='Q2') cq.addFacet(core='coreA', facet='F0') cq.addFacet(core='coreA', facet='F1') cq.setCoreQuery(core='coreB', query='Q3') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='AQuery'), dict(core='coreB', query='anotherQuery')) self.assertEquals(None, cq.stop) self.assertEquals(None, cq.start) self.assertEquals([], cq.sortKeys) cq.stop = 10 cq.start = 0 cq.sortKeys = [dict(sortBy='field', sortDescending=True)] self.assertEquals('Q0', cq.queryFor('coreA')) self.assertEquals(['Q1', 'Q2'], cq.filterQueriesFor('coreA')) self.assertEquals(['F0', 'F1'], cq.facetsFor('coreA')) self.assertEquals(10, cq.stop) self.assertEquals(0, cq.start) self.assertEquals([dict(sortBy='field', sortDescending=True)], cq.sortKeys)
def testUniteMakesItTwoCoreQuery(self): q = ComposedQuery('coreA') q.setCoreQuery(core='coreA', query=luceneQueryFromCql('Q=true')) q.addMatch(dict(core='coreA', uniqueKey=KEY_PREFIX+'A'), dict(core='coreB', key=KEY_PREFIX+'B')) q.addUnite(dict(core='coreA', query=luceneQueryFromCql('U=true')), dict(core='coreB', query=luceneQueryFromCql('N=true'))) result = returnValueFromGenerator(self.dna.any.executeComposedQuery(q)) self.assertEquals(3, result.total) self.assertEquals(set(['A-QU', 'A-MQ', 'A-MQU']), self.hitIds(result.hits))
def testUniteResultFromTwoIndexesCachedAfterUpdate(self): q = ComposedQuery('coreA') q.setCoreQuery(core='coreA', query=luceneQueryFromCql('Q=true'), facets=[ dict(fieldname='cat_Q', maxTerms=10), dict(fieldname='cat_U', maxTerms=10), ]) q.setCoreQuery(core='coreB', query=None, facets=[ dict(fieldname='cat_N', maxTerms=10), dict(fieldname='cat_O', maxTerms=10), ]) q.addMatch(dict(core='coreA', uniqueKey=KEY_PREFIX+'A'), dict(core='coreB', key=KEY_PREFIX+'B')) q.addUnite(dict(core='coreA', query=luceneQueryFromCql('U=true')), dict(core='coreB', query=luceneQueryFromCql('N=true'))) resultOne = returnValueFromGenerator(self.dna.any.executeComposedQuery(q)) self.assertEquals(3, resultOne.total) self.assertEquals([{ 'terms': [ {'count': 3, 'term': u'true'} ], 'path': [], 'fieldname': u'cat_Q' }, { 'terms': [ {'count': 2, 'term': u'true'}, {'count': 1, 'term': u'false'} ], 'path': [], 'fieldname': u'cat_U' }, { 'terms': [ {'count': 2, 'term': u'true'} ], 'path': [], 'fieldname': u'cat_N' }, { 'terms': [ {'count': 1, 'term': u'true'}, {'count': 1, 'term': u'false'}, ], 'path': [], 'fieldname': u'cat_O' }], resultOne.drilldownData) self.addDocument(self.luceneA, identifier='A-MQU', keys=[('A', 8 )], fields=[('M', 'true' ), ('Q', 'false' ), ('U', 'true' ), ('S', '8')]) resultAgain = returnValueFromGenerator(self.dna.any.executeComposedQuery(q)) self.assertEquals(2, resultAgain.total) self.assertEquals([{ 'terms': [ {'count': 2, 'term': u'true'} ], 'path': [], 'fieldname': u'cat_Q' }, { 'terms': [ {'count': 1, 'term': u'false'}, {'count': 1, 'term': u'true'}, ], 'path': [], 'fieldname': u'cat_U' }, { 'terms': [ {'count': 1, 'term': u'true'} ], 'path': [], 'fieldname': u'cat_N' }, { 'terms': [ {'count': 1, 'term': u'true'} ], 'path': [], 'fieldname': u'cat_O' }], resultAgain.drilldownData)
def testUnite(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query=None) cq.setCoreQuery(core='coreB', query=None) cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='AQuery'), dict(core='coreB', query='anotherQuery')) self.assertEqual(1, len(cq.unites)) queries = list(cq.unites[0].queries()) self.assertEquals(({'query': 'AQuery', 'keyName': 'keyA', 'core': 'coreA'}, 'keyA'), queries[0]) self.assertEquals(({'query': 'anotherQuery', 'keyName': 'keyB', 'core': 'coreB'}, 'keyA'), queries[1])
def testAtMostOneMultiCoreOr(self): composedQuery = ComposedQuery('coreA') composedQuery.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) composedQuery.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreC', key='keyC')) composedQuery.addUnite(dict(core='coreA', query='qA'), dict(core='coreB', query='qB')) self.assertRaises( ValueError, lambda: composedQuery.addUnite( dict(core='coreA', query='qA'), dict('coreC', query='qC')))
def testConvertComposedQuery(self): q = ComposedQuery('A') q.setCoreQuery(core='A', query=parseString('valueAQ')) q.setCoreQuery(core='B', query=parseString('valueBQ')) q.addMatch(dict(core='A', uniqueKey='keyA'), dict(core='B', key='keyB')) q.addUnite(dict(core='A', query=parseString('fieldUA exact valueUA')), dict(core='B', query=parseString('fieldUB exact valueUB'))) q.validate() consume(self.dna.any.executeComposedQuery(query=q)) self.assertEquals(['executeComposedQuery'], self.observer.calledMethodNames()) self.assertEquals(repr(TermQuery(Term('fieldA', 'valueaq'))), repr(q.queryFor('A'))) self.assertEquals(repr(TermQuery(Term('fieldB', 'valuebq'))), repr(q.queryFor('B')))
def testConvertComposedQuery(self): q = ComposedQuery('A') q.setCoreQuery(core='A', query=cqlToExpression('valueAQ')) q.setCoreQuery(core='B', query=cqlToExpression('valueBQ')) q.addMatch(dict(core='A', uniqueKey='keyA'), dict(core='B', key='keyB')) q.addUnite(dict(core='A', query=cqlToExpression('fieldUA exact valueUA')), dict(core='B', query=cqlToExpression('fieldUB exact valueUB'))) q.validate() consume(self.dna.any.executeComposedQuery(query=q)) self.assertEquals(['executeComposedQuery'], self.observer.calledMethodNames()) self.assertEquals("{'type': 'TermQuery', 'term': {'field': 'fieldA', 'value': u'valueaq'}, 'boost': 1.0}", repr(q.queryFor('A'))) self.assertEquals("{'type': 'TermQuery', 'term': {'field': 'fieldB', 'value': u'valuebq'}, 'boost': 1.0}", repr(q.queryFor('B')))
def testConvertAllQueries(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query='Q0') cq.addFilterQuery('coreA', 'Q1') cq.addFilterQuery('coreA', 'Q2') cq.setCoreQuery(core='coreB', query='Q3') cq.addFilterQuery('coreB', 'Q4') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='Q5'), dict(core='coreB', query='Q6')) convertCoreA = lambda query: "Converted_A_{0}".format(query) convertCoreB = lambda query: "Converted_B_{0}".format(query) cq.convertWith(coreA=convertCoreA, coreB=convertCoreB) self.assertEquals("Converted_A_Q0", cq.queryFor('coreA')) self.assertEquals(["Converted_A_Q1", "Converted_A_Q2"], cq.filterQueriesFor('coreA')) self.assertEquals("Converted_B_Q3", cq.queryFor('coreB')) self.assertEquals(["Converted_B_Q4"], cq.filterQueriesFor('coreB')) self.assertEquals([('coreA', 'Converted_A_Q5'), ('coreB', 'Converted_B_Q6')], cq.unites)
def testAsDictFromDict(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query='Q0') cq.addFilterQuery(core='coreA', query='Q1') cq.addFilterQuery(core='coreA', query='Q2') cq.relationalFilter = '{"type": "madeUpJoinQuery"}' cq.addFacet(core='coreA', facet='F0') cq.addFacet(core='coreA', facet='F1') cq.setCoreQuery(core='coreB', query='Q3') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='AQuery'), dict(core='coreB', query='anotherQuery')) cq.start = 0 cq.sortKeys = [dict(sortBy='field', sortDescending=True)] cq.clustering = True cq.clusteringConfig = {'clusteringEps': 0.2} cq.rankQueryScoreRatio = 0.75 d = cq.asDict() cq2 = ComposedQuery.fromDict(d) self.assertEquals('coreA', cq2.resultsFrom) self.assertEquals(0, cq2.start) self.assertEquals(None, cq2.stop) self.assertEquals(['Q0', 'Q1', 'Q2'], cq2.queriesFor('coreA')) self.assertEquals('{"type": "madeUpJoinQuery"}', cq2.relationalFilter) self.assertEquals(['F0', 'F1'], cq2.facetsFor('coreA')) self.assertEquals('keyA', cq2.keyName('coreA', 'coreB')) self.assertEquals('keyB', cq2.keyName('coreB', 'coreA')) self.assertEqual(1, len(cq2.unites)) queries = list(cq2.unites[0].queries()) self.assertEquals(({ 'core': 'coreA', 'keyName': 'keyA', 'query': 'AQuery' }, 'keyA'), queries[0]) self.assertEquals(({ 'core': 'coreB', 'keyName': 'keyB', 'query': 'anotherQuery' }, 'keyA'), queries[1]) self.assertEquals({'clusteringEps': 0.2}, cq2.clusteringConfig) self.assertEquals(0.75, cq2.rankQueryScoreRatio)
def testConvertComposedQuery(self): q = ComposedQuery('A') q.setCoreQuery(core='A', query=cqlToExpression('valueAQ')) q.setCoreQuery(core='B', query=cqlToExpression('valueBQ')) q.addMatch(dict(core='A', uniqueKey='keyA'), dict(core='B', key='keyB')) q.addUnite( dict(core='A', query=cqlToExpression('fieldUA exact valueUA')), dict(core='B', query=cqlToExpression('fieldUB exact valueUB'))) q.validate() consume(self.dna.any.executeComposedQuery(query=q)) self.assertEquals(['executeComposedQuery'], self.observer.calledMethodNames()) self.assertEquals( "{'type': 'TermQuery', 'term': {'field': 'fieldA', 'value': u'valueaq'}, 'boost': 1.0}", repr(q.queryFor('A'))) self.assertEquals( "{'type': 'TermQuery', 'term': {'field': 'fieldB', 'value': u'valuebq'}, 'boost': 1.0}", repr(q.queryFor('B')))
def testUnite(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query=None) cq.setCoreQuery(core='coreB', query=None) cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='AQuery'), dict(core='coreB', query='anotherQuery')) self.assertEqual(1, len(cq.unites)) queries = list(cq.unites[0].queries()) self.assertEquals(({ 'query': 'AQuery', 'keyName': 'keyA', 'core': 'coreA' }, 'keyA'), queries[0]) self.assertEquals(({ 'query': 'anotherQuery', 'keyName': 'keyB', 'core': 'coreB' }, 'keyA'), queries[1])
def testUniteAndFacets(self): q = ComposedQuery('coreA') q.setCoreQuery(core='coreA', query=luceneQueryFromCql('Q=true'), facets=[ dict(fieldname='cat_Q', maxTerms=10), dict(fieldname='cat_U', maxTerms=10), ]) q.setCoreQuery(core='coreB', query=None, facets=[ dict(fieldname='cat_N', maxTerms=10), dict(fieldname='cat_O', maxTerms=10), ]) q.addMatch(dict(core='coreA', uniqueKey=KEY_PREFIX+'A'), dict(core='coreB', key=KEY_PREFIX+'B')) q.addUnite(dict(core='coreA', query=luceneQueryFromCql('U=true')), dict(core='coreB', query=luceneQueryFromCql('N=true'))) result = returnValueFromGenerator(self.dna.any.executeComposedQuery(q)) self.assertEquals(3, result.total) self.assertEquals([{ 'terms': [ {'count': 3, 'term': u'true'}, ], 'path': [], 'fieldname': u'cat_Q' }, { 'terms': [ {'count': 2, 'term': u'true'}, {'count': 1, 'term': u'false'}, ], 'path': [], 'fieldname': u'cat_U' }, { 'terms': [ {'count': 2, 'term': u'true'}, ], 'path': [], 'fieldname': u'cat_N' }, { 'terms': [ {'count': 1, 'term': u'true'}, {'count': 1, 'term': u'false'}, ], 'path': [], 'fieldname': u'cat_O' }], result.drilldownData)
def testConversionOfComposedQuery(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query=parseString('Q0'), filterQueries=['Q1', 'Q2'], facets=['F0', 'F1']) cq.setCoreQuery(core='coreB', query='Q3', filterQueries=['Q4']) cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='AQuery'), dict(core='coreB', query='anotherQuery')) cq.start = 0 cq.sortKeys = [dict(sortBy='field', sortDescending=True)] kwargs = {'q': cq} dump = jsonDumpMessage(message='aMessage', **kwargs) self.assertEquals(str, type(dump)) message, kwargs = jsonLoadMessage(dump) self.assertEquals('aMessage', message) cq2 = kwargs['q'] self.assertEquals(parseString('Q0'), cq2.queryFor('coreA'))
def testUniteResultFromTwoIndexesCached(self): q = ComposedQuery('coreA') q.setCoreQuery(core='coreA', query=luceneQueryFromCql('Q=true'), facets=[ dict(fieldname='cat_Q', maxTerms=10), dict(fieldname='cat_U', maxTerms=10), ]) q.setCoreQuery(core='coreB', query=None, facets=[ dict(fieldname='cat_N', maxTerms=10), dict(fieldname='cat_O', maxTerms=10), ]) q.addMatch(dict(core='coreA', uniqueKey=KEY_PREFIX+'A'), dict(core='coreB', key=KEY_PREFIX+'B')) q.addUnite(dict(core='coreA', query=luceneQueryFromCql('U=true')), dict(core='coreB', query=luceneQueryFromCql('N=true'))) resultOne = returnValueFromGenerator(self.dna.any.executeComposedQuery(q)) q = ComposedQuery('coreA') q.setCoreQuery(core='coreA', query=luceneQueryFromCql('U=true')) q.addMatch(dict(core='coreA', uniqueKey=KEY_PREFIX+'A'), dict(core='coreB', key=KEY_PREFIX+'B')) q.addUnite(dict(core='coreA', query=luceneQueryFromCql('U=false')), dict(core='coreB', query=luceneQueryFromCql('N=true'))) ignoredResult = returnValueFromGenerator(self.dna.any.executeComposedQuery(q)) q = ComposedQuery('coreA') q.setCoreQuery(core='coreA', query=luceneQueryFromCql('Q=true'), facets=[ dict(fieldname='cat_Q', maxTerms=10), dict(fieldname='cat_U', maxTerms=10), ]) q.setCoreQuery(core='coreB', query=None, facets=[ dict(fieldname='cat_N', maxTerms=10), dict(fieldname='cat_O', maxTerms=10), ]) q.addMatch(dict(core='coreA', uniqueKey=KEY_PREFIX+'A'), dict(core='coreB', key=KEY_PREFIX+'B')) q.addUnite(dict(core='coreA', query=luceneQueryFromCql('U=true')), dict(core='coreB', query=luceneQueryFromCql('N=true'))) resultAgain = returnValueFromGenerator(self.dna.any.executeComposedQuery(q)) self.assertEquals(resultOne.total, resultAgain.total) self.assertEquals(resultOne.hits, resultAgain.hits) self.assertEquals(resultOne.drilldownData, resultAgain.drilldownData)
def testAsDictFromDict(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query='Q0') cq.addFilterQuery(core='coreA', query='Q1') cq.addFilterQuery(core='coreA', query='Q2') cq.addFacet(core='coreA', facet='F0') cq.addFacet(core='coreA', facet='F1') cq.setCoreQuery(core='coreB', query='Q3') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='AQuery'), dict(core='coreB', query='anotherQuery')) cq.start = 0 cq.sortKeys = [dict(sortBy='field', sortDescending=True)] d = cq.asDict() cq2 = ComposedQuery.fromDict(d) self.assertEquals('coreA', cq2.resultsFrom) self.assertEquals(0, cq2.start) self.assertEquals(None, cq2.stop) self.assertEquals(['Q0', 'Q1', 'Q2'], cq2.queriesFor('coreA')) self.assertEquals(['F0', 'F1'], cq2.facetsFor('coreA')) self.assertEquals('keyA', cq2.keyName('coreA')) self.assertEquals('keyB', cq2.keyName('coreB'))
def testRepr(self): class AQuery(object): def __repr__(self): return 'NOT USED' def __str__(self): return 'AQuery' cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query='Q0') cq.addFilterQuery(core='coreA', query='Q1') cq.addFilterQuery(core='coreA', query='Q2') cq.relationalFilter = '{"type": "MadeUpJoinQuery"}' cq.addFacet(core='coreA', facet='F0') cq.addFacet(core='coreA', facet='F1') cq.setCoreQuery(core='coreB', query='Q3') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query=AQuery()), dict(core='coreB', query='anotherQuery')) cq.start = 0 cq.sortKeys = [dict(sortBy='field', sortDescending=True)] cq.storedFields = ['stored_field'] self.assertEquals({ 'type': 'ComposedQuery', 'query': { "cores": ["coreB", "coreA"], "drilldownQueries": {}, "facets": {"coreA": ["F0", "F1"]}, "filterQueries": {"coreA": ["Q1", "Q2"]}, "matches": {"coreA->coreB": [{"core": "coreA", "uniqueKey": "keyA"}, {"core": "coreB", "key": "keyB"}]}, "otherCoreFacetFilters": {}, "queries": {"coreA": "Q0", "coreB": "Q3"}, "rankQueries": {}, 'relationalFilter': '{"type": "MadeUpJoinQuery"}', "resultsFrom": "coreA", "sortKeys": [{"sortBy": "field", "sortDescending": True}], "start": 0, "storedFields": ['stored_field'], "unites": [{"A": ["coreA", "AQuery"], "B": ["coreB", "anotherQuery"]}] } }, cq.infoDict())
def testConvertAllQueriesWithUnqualifiedTermFields(self): cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query='Q0') cq.addFilterQuery('coreA', 'Q1') cq.addFilterQuery('coreA', 'Q2') cq.setCoreQuery(core='coreB', query='Q3') cq.addFilterQuery('coreB', 'Q4') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='Q5'), dict(core='coreB', query='Q6')) cq.unqualifiedTermFields = [('field0', 2.0), ('field1', 3.0)] convertCoreA = lambda query, unqualifiedTermFields=None, **kwargs: "Converted_A_{0}_{1}".format(query, not unqualifiedTermFields is None) convertCoreB = lambda query, **kwargs: "Converted_B_{0}".format(query) cq.convertWith(coreA=convertCoreA, coreB=convertCoreB) self.assertEquals("Converted_A_Q0_True", cq.queryFor('coreA')) self.assertEquals(["Converted_A_Q1_True", "Converted_A_Q2_True"], cq.filterQueriesFor('coreA')) self.assertEquals("Converted_B_Q3", cq.queryFor('coreB')) self.assertEquals(["Converted_B_Q4"], cq.filterQueriesFor('coreB')) self.assertEqual(1, len(cq.unites)) uniteQueries = list(cq.unites[0].queries()) self.assertEquals('Converted_A_Q5_True', uniteQueries[0][0]['query']) self.assertEquals('Converted_B_Q6', uniteQueries[1][0]['query'])
def testStartStopSortKeys(self): q = ComposedQuery('coreA') q.setCoreQuery(core='coreA', query=luceneQueryFromCql('Q=true')) q.setCoreQuery(core='coreB', query=None) q.addMatch(dict(core='coreA', uniqueKey=KEY_PREFIX+'A'), dict(core='coreB', key=KEY_PREFIX+'B')) q.addUnite(dict(core='coreA', query=luceneQueryFromCql('U=true')), dict(core='coreB', query=luceneQueryFromCql('N=true'))) q.sortKeys=[dict(sortBy='S', sortDescending=False)] result = returnValueFromGenerator(self.dna.any.executeComposedQuery(q)) self.assertEquals(3, result.total) self.assertEquals(set(['A-QU', 'A-MQ', 'A-MQU']), self.hitIds(result.hits)) q.sortKeys=[dict(sortBy='S', sortDescending=True)] result = returnValueFromGenerator(self.dna.any.executeComposedQuery(q)) self.assertEquals(3, result.total) self.assertEquals(set(['A-MQU', 'A-MQ', 'A-QU']), self.hitIds(result.hits)) q.stop = 2 result = returnValueFromGenerator(self.dna.any.executeComposedQuery(q)) self.assertEquals(3, result.total) self.assertEquals(set(['A-MQU', 'A-MQ']), self.hitIds(result.hits)) q.stop = 10 q.start = 1 result = returnValueFromGenerator(self.dna.any.executeComposedQuery(q)) self.assertEquals(3, result.total) self.assertEquals(set(['A-MQ', 'A-QU']), self.hitIds(result.hits))
def NOT_YET_SUPPORTED_testUniteAndFacetsResultsFromCoreB(self): q = ComposedQuery('coreB') q.setCoreQuery(core='coreA', query=luceneQueryFromCql('Q=true')) q.setCoreQuery(core='coreB', query=None, facets=[ dict(fieldname='cat_N', maxTerms=10), dict(fieldname='cat_O', maxTerms=10), ]) q.addMatch(dict(core='coreA', uniqueKey=KEY_PREFIX + 'A'), dict(core='coreB', key=KEY_PREFIX + 'B')) q.addUnite(dict(core='coreA', query=luceneQueryFromCql('U=true')), dict(core='coreB', query=luceneQueryFromCql('N=true'))) result = returnValueFromGenerator(self.dna.any.executeComposedQuery(q)) self.assertEquals(set(['B-N>A-MQ', 'B-N>MQU']), self.hitIds(result.hits)) self.assertEquals(2, result.total) self.assertEquals([{ 'terms': [ {'count': 2, 'term': u'true'}, ], 'fieldname': u'cat_N' }, { 'terms': [ {'count': 1, 'term': u'false'}, {'count': 1, 'term': u'true'}, ], 'fieldname': u'cat_O' }], result.drilldownData)
def testUniteQueriesFor(self): cq = ComposedQuery('coreA') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query='Q5'), dict(core='coreB', query='Q6')) self.assertEquals(['Q5'], cq.uniteQueriesFor('coreA')) self.assertEquals(['Q6'], cq.uniteQueriesFor('coreB'))
def NOT_YET_SUPPORTED_testUniteResultsFromCoreB(self): q = ComposedQuery('coreB') q.addMatch(dict(core='coreA', uniqueKey=KEY_PREFIX +'A'), dict(core='coreB', key=KEY_PREFIX +'B')) q.addUnite(dict(core='coreA', query=luceneQueryFromCql('U=true')), dict(core='coreB', query=luceneQueryFromCql('N=true'))) result = returnValueFromGenerator(self.dna.any.executeComposedQuery(q)) self.assertEquals(['B-N', 'B-N>A-M', 'B-N>A-MQ', 'B-N>A-MQU', 'B-N>A-MU', 'B-P>A-MQU', 'B-P>A-MU', ], sorted(result.hits))
def testRepr(self): class AQuery(object): def __repr__(self): return 'NOT USED' def __str__(self): return 'AQuery' cq = ComposedQuery('coreA') cq.setCoreQuery(core='coreA', query='Q0') cq.addFilterQuery(core='coreA', query='Q1') cq.addFilterQuery(core='coreA', query='Q2') cq.relationalFilter = '{"type": "MadeUpJoinQuery"}' cq.addFacet(core='coreA', facet='F0') cq.addFacet(core='coreA', facet='F1') cq.setCoreQuery(core='coreB', query='Q3') cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) cq.addUnite(dict(core='coreA', query=AQuery()), dict(core='coreB', query='anotherQuery')) cq.start = 0 cq.sortKeys = [dict(sortBy='field', sortDescending=True)] cq.storedFields = ['stored_field'] self.assertEquals( { 'type': 'ComposedQuery', 'query': { "cores": ["coreB", "coreA"], "drilldownQueries": {}, "facets": { "coreA": ["F0", "F1"] }, "filterQueries": { "coreA": ["Q1", "Q2"] }, "matches": { "coreA->coreB": [{ "core": "coreA", "uniqueKey": "keyA" }, { "core": "coreB", "key": "keyB" }] }, "otherCoreFacetFilters": {}, "queries": { "coreA": "Q0", "coreB": "Q3" }, "rankQueries": {}, 'relationalFilter': '{"type": "MadeUpJoinQuery"}', "resultsFrom": "coreA", "sortKeys": [{ "sortBy": "field", "sortDescending": True }], "start": 0, "storedFields": ['stored_field'], "unites": [{ "A": ["coreA", "AQuery"], "B": ["coreB", "anotherQuery"] }] } }, cq.infoDict())
def testAtMostOneMultiCoreOr(self): composedQuery = ComposedQuery('coreA') composedQuery.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) composedQuery.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreC', key='keyC')) composedQuery.addUnite(dict(core='coreA', query='qA'), dict(core='coreB', query='qB')) self.assertRaises(ValueError, lambda: composedQuery.addUnite(dict(core='coreA', query='qA'), dict('coreC', query='qC')))
def NOT_YET_SUPPORTED_testJoinQueryOnOptionalKeyUniteResultsWithoutKey(self): q = ComposedQuery('coreA') q.addMatch(dict(core='coreA', uniqueKey=KEY_PREFIX+'C'), dict(core='coreB', key=KEY_PREFIX+'B')) q.addUnite(dict(core='coreA', query=luceneQueryFromCql('U=true')), dict(core='coreB', query=luceneQueryFromCql('N=true'))) result = returnValueFromGenerator(self.dna.any.executeComposedQuery(q)) self.assertEquals(set(['A-U', 'A-QU', 'A-MU', 'A-MQU', 'A-M']), self.hitIds(result.hits))