@Override public ExpandedQuery rewrite(ExpandedQuery query) { QuerqyQuery<?> userQuery = query.getUserQuery(); if (userQuery != null && userQuery instanceof Query) { visit((Query) userQuery); } return query; }
if (requestAdapter.isMatchAllQuery(queryString)) { parsedInput = new ExpandedQuery(new MatchAllQuery()); parserDebugInfo = parser.getClass().getName(); parsedInput = new ExpandedQuery(parser.parse(queryString)); additiveBoosts = requestAdapter.getAdditiveBoosts(parsedInput.getUserQuery()); multiplicativeBoosts = requestAdapter.getMultiplicativeBoosts(parsedInput.getUserQuery()); } else { additiveBoosts = multiplicativeBoosts = null; Query mainQuery = transformUserQuery(rewrittenQuery.getUserQuery(), builder); final List<Query> filterQueries = transformFilterQueries(rewrittenQuery.getFilterQueries()); final List<Query> querqyBoostQueries = needsScores ? getQuerqyBoostQueries(rewrittenQuery)
protected List<Query> getQuerqyBoostQueries(final ExpandedQuery expandedQuery) throws SyntaxException { final List<Query> result = transformBoostQueries(expandedQuery.getBoostUpQueries(), requestAdapter.getPositiveQuerqyBoostWeight().orElse(DEFAULT_POSITIVE_QUERQY_BOOST_WEIGHT)); final List<Query> down = transformBoostQueries(expandedQuery.getBoostDownQueries(), -requestAdapter.getNegativeQuerqyBoostWeight().map(Math::abs).orElse(DEFAULT_NEGATIVE_QUERQY_BOOST_WEIGHT)); if (down != null) { if (result == null) { return down; } else { result.addAll(down); } } return result != null ? result : Collections.emptyList(); }
@Override public void apply(final PositionSequence<Term> sequence, final TermMatches termMatches, final int startPosition, final int endPosition, final ExpandedQuery expandedQuery, final Map<String, Object> context) { // TODO: we might not need to clone here, if we already cloned all queries in the constructor final QuerqyQuery<?> q = (hasPlaceHolder) ? new CloneAndReplacePlaceHolderRewriter(termMatches).cloneAndReplace(query) : query.clone(null, true); final BoostQuery bq = new BoostQuery(q, boost); if (direction == BoostDirection.DOWN) { expandedQuery.addBoostDownQuery(bq); } else { expandedQuery.addBoostUpQuery(bq); } }
@Test public void testThatShinglingDoesNotTriggerExceptionOnSingleTerm() throws Exception { Query query = new Query(); addTerm(query, "t1"); ExpandedQuery expandedQuery = new ExpandedQuery(query); ShingleRewriter rewriter = new ShingleRewriter(); rewriter.rewrite(expandedQuery); assertThat((Query) expandedQuery.getUserQuery(), bq( dmq( term("t1") ) ) ); }
@Test public void testThatUpQueriesAreOfTypeQuery() throws Exception { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); BoostInstruction boostInstruction = new BoostInstruction(makeQuery("a b").getUserQuery(), BoostDirection.UP, 0.5f); builder.addRule(new Input(Arrays.asList(mkTerm("x")), false, false), new Instructions(Arrays.asList((Instruction) boostInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x"); Collection<BoostQuery> upQueries = rewriter.rewrite(query, EMPTY_CONTEXT).getBoostUpQueries(); for (BoostQuery bq : upQueries) { Assert.assertTrue(bq.getQuery() instanceof Query); } }
@Test public void testThatDownQueriesAreOfTypeQuery() throws Exception { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); BoostInstruction boostInstruction = new BoostInstruction(makeQuery("a b$1").getUserQuery(), BoostDirection.DOWN, 0.2f); builder.addRule((Input) LineParser.parseInput("x k*"), new Instructions(Collections.singletonList((Instruction) boostInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x klm y"); Collection<BoostQuery> downQueries = rewriter.rewrite(query, EMPTY_CONTEXT).getBoostDownQueries(); for (BoostQuery bq : downQueries) { Assert.assertTrue(bq.getQuery() instanceof Query); } }
@Test public void testThatFilterQueriesAreMarkedAsGenerated() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); FilterInstruction filterInstruction = new FilterInstruction(makeQuery("a").getUserQuery()); builder.addRule(new Input(Arrays.asList(mkTerm("x")), false, false), new Instructions(Arrays.asList((Instruction) filterInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x"); Collection<QuerqyQuery<?>> filterQueries = rewriter.rewrite(query, EMPTY_CONTEXT).getFilterQueries(); QuerqyQuery<?> qq = filterQueries.iterator().next(); assertTrue(qq instanceof BooleanQuery); assertThat((BooleanQuery) qq, bq( dmq(must(), term("a", true)) ) ); }
protected ExpandedQuery makeQuery(String input) { return new ExpandedQuery(new WhiteSpaceQuerqyParser().parse(input)); }
public ExpandedQuery(QuerqyQuery<?> userQuery) { setUserQuery(userQuery); }
@Override public void apply(final PositionSequence<Term> sequence, final TermMatches termMatches, final int startPosition, final int endPosition, final ExpandedQuery expandedQuery, final Map<String, Object> context) { // TODO: we might not need to clone here, if we already cloned all queries in the constructor expandedQuery.addFilterQuery(filterQuery.clone(null, true)); }
@Test public void testShinglingForTwoTokensWithOnFieldNameNullDontShingle() { Query query = new Query(); addTerm(query, "f1", "cde"); addTerm(query, "ajk"); ExpandedQuery expandedQuery = new ExpandedQuery(query); ShingleRewriter rewriter = new ShingleRewriter(); rewriter.rewrite(expandedQuery); assertThat((Query) expandedQuery.getUserQuery(), bq(dmq(term("f1", "cde")), dmq(term("ajk")))); }
@Test public void testThatBoostQueriesAreMarkedAsGenerated() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); BoostInstruction boostInstruction = new BoostInstruction(makeQuery("a").getUserQuery(), BoostDirection.UP, 0.5f); builder.addRule(new Input(Arrays.asList(mkTerm("x")), false, false), new Instructions(Arrays.asList((Instruction) boostInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x"); Collection<BoostQuery> upQueries = rewriter.rewrite(query, EMPTY_CONTEXT).getBoostUpQueries(); assertThat(upQueries, contains( boostQ( bq( dmq(must(), term("a", true)) ), 0.5f ))); }
@Test public void testThatPlaceHolderGetsReplaced() throws Exception { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); BoostInstruction boostInstruction = new BoostInstruction(makeQuery("a b$1").getUserQuery(), BoostDirection.DOWN, 0.2f); builder.addRule((Input) LineParser.parseInput("x k*"), new Instructions(Collections.singletonList((Instruction) boostInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x klm y"); Collection<BoostQuery> downQueries = rewriter.rewrite(query, EMPTY_CONTEXT).getBoostDownQueries(); assertThat(downQueries, contains( boostQ( bq( dmq(must(), term("a", true)), dmq(must(), term("blm", true)) ), 0.2f ))); }
@Test public void testThatBoostQueriesWithMustClauseUseMM100ByDefault() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); FilterInstruction filterInstruction = new FilterInstruction(makeQuery("a b").getUserQuery()); builder.addRule(new Input(Arrays.asList(mkTerm("x")), false, false), new Instructions(Arrays.asList((Instruction) filterInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x"); Collection<QuerqyQuery<?>> filterQueries = rewriter.rewrite(query, EMPTY_CONTEXT).getFilterQueries(); QuerqyQuery<?> qq = filterQueries.iterator().next(); assertTrue(qq instanceof BooleanQuery); assertThat((BooleanQuery) qq, bq( dmq(must(), term("a", true)), dmq(must(), term("b", true)) ) ); }
@Test public void testShinglingForTwoTokensWithDifferentFieldsDontShingle() { Query query = new Query(); addTerm(query, "f1", "cde"); addTerm(query, "f2", "ajk"); ExpandedQuery expandedQuery = new ExpandedQuery(query); ShingleRewriter rewriter = new ShingleRewriter(); rewriter.rewrite(expandedQuery); assertThat((Query) expandedQuery.getUserQuery(), bq(dmq(term("cde")), dmq(term("ajk")))); }
@Override public ExpandedQuery rewrite(ExpandedQuery query, Map<String, Object> context) { QuerqyQuery<?> userQuery = query.getUserQuery(); if (userQuery instanceof Query) { this.expandedQuery = query; this.context = context; sequencesStack.add(new PositionSequence<Term>()); super.visit((BooleanQuery) query.getUserQuery()); applySequence(sequencesStack.removeLast(), true); } return query; }
@Test public void testThatBoostQueriesWithMustClauseUseMM100ByDefault() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); BoostInstruction boostInstruction = new BoostInstruction(makeQuery("a +b").getUserQuery(), BoostDirection.UP, 0.5f); builder.addRule(new Input(Arrays.asList(mkTerm("x")), false, false), new Instructions(Arrays.asList((Instruction) boostInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x"); Collection<BoostQuery> upQueries = rewriter.rewrite(query, EMPTY_CONTEXT).getBoostUpQueries(); assertThat(upQueries, contains( boostQ( bq( dmq(must(), term("a", true)), dmq(must(), term("b", true)) ), 0.5f ))); }
@Test public void testThatPlaceHolderGetsReplacedAsASeperateToken() throws Exception { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); BoostInstruction boostInstruction = new BoostInstruction(makeQuery("a $1").getUserQuery(), BoostDirection.DOWN, 0.3f); builder.addRule((Input) LineParser.parseInput("x k*"), new Instructions(Collections.singletonList((Instruction) boostInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x klm y"); Collection<BoostQuery> downQueries = rewriter.rewrite(query, EMPTY_CONTEXT).getBoostDownQueries(); assertThat(downQueries, contains( boostQ( bq( dmq(must(), term("a", true)), dmq(must(), term("lm", true)) ), 0.3f ))); }
@Test public void testPurelyNegativeFilterQuery() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(true); FilterInstruction filterInstruction = new FilterInstruction(makeQuery("-ab").getUserQuery()); builder.addRule(new Input(Collections.singletonList(mkTerm("x")), false, false), new Instructions(Collections.singletonList((Instruction) filterInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x"); Collection<QuerqyQuery<?>> filterQueries = rewriter.rewrite(query, EMPTY_CONTEXT).getFilterQueries(); assertNotNull(filterQueries); assertEquals(1, filterQueries.size()); QuerqyQuery<?> qq = filterQueries.iterator().next(); assertTrue(qq instanceof BooleanQuery); assertThat((BooleanQuery) qq, bq( should(), dmq( mustNot(), term("ab", true) ) ) ); }