@Override public Set<Term> getGenerableTerms() { return (filterQuery instanceof Query) ? TermsCollector.collectGenerableTerms((Query) filterQuery) : QueryRewriter.EMPTY_GENERABLE_TERMS; }
public static Set<Term> collectGenerableTerms(final Query query) { final TermsCollector collector = new TermsCollector(); collector.visit(query); return collector.getResult(); }
@Override public int hashCode() { final int prime = 47; int result = prime + ((type == null) ? 0 : type.hashCode()); return result; }
@Test public void testSingeInputSingleInstruction() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); String s1 = "test"; Input input = new Input(inputTerms(null, s1), false, false); Instructions instructions = instructions("instruction1"); builder.addRule(input, instructions); RulesCollection rulesCollection = builder.build(); PositionSequence<InputSequenceElement> sequence = new PositionSequence<>(); sequence.nextPosition(); sequence.addElement(new Term(null, s1)); List<Action> actions = rulesCollection.getRewriteActions(sequence); assertThat(actions, contains(new Action(Arrays.asList(instructions), termMatches(s1), 0, 1))); }
public void testThatMainQueryIsNotMarkedAsGenerated() { 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"); QuerqyQuery<?> mainQuery = rewriter.rewrite(query, EMPTY_CONTEXT).getUserQuery(); assertFalse(mainQuery.isGenerated()); }
@Test public void testThatMainQueryIsNotMarkedAsGenerated() { 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"); QuerqyQuery<?> mainQuery = rewriter.rewrite(query, EMPTY_CONTEXT).getUserQuery(); assertFalse(mainQuery.isGenerated()); }
TermMatches termMatches(String... values) { TermMatches result = new TermMatches(); for (String value : values) { result.add(new TermMatch(new Term(null, value))); } return result; }
@Override public Set<Term> getGenerableTerms() { // REVISIT: return Iterator? Limit number of results? final Set<Term> result = new HashSet<Term>(); for (final Instruction instruction: rules.getInstructions()) { result.addAll(instruction.getGenerableTerms()); } return result; }
Instructions instructions(String... names) { List<Instruction> instructions = new LinkedList<>(); for (String name : names) { instructions.add(new SimpleInstruction(name)); } return new Instructions(instructions); }
@Override public Node visit(final Term term) { final ComparableCharSequence value = term.getValue(); if (value instanceof querqy.rewrite.commonrules.model.Term) { querqy.rewrite.commonrules.model.Term termValue = (querqy.rewrite.commonrules.model.Term) value; final ComparableCharSequence newValue = termValue.fillPlaceholders(termMatches); return new Term((DisjunctionMaxQuery) getNewParent(), term.getField(), newValue, true); } else { return term.clone((DisjunctionMaxQuery) getNewParent(), true); } }
public TermMatches(final Collection<? extends TermMatch> c) { super(); for (final TermMatch match: c) { add(match); } }
public List<ComparableCharSequence> getInputSequences(boolean lowerCaseValues) { if (inputTerms.size() == 1) { return inputTerms.get(0).getCharSequences(lowerCaseValues); } LinkedList<List<ComparableCharSequence>> slots = new LinkedList<>(); for (Term inputTerm : inputTerms) { slots.add(inputTerm.getCharSequences(lowerCaseValues)); } List<ComparableCharSequence> seqs = new LinkedList<>(); collectTails(new LinkedList<ComparableCharSequence>(), slots, seqs); return seqs; }
@Override public Term findFirstMatch(final Collection<? extends Term> haystack) { for (Term h : haystack) { if (isPrefixOf(h)) { return h; } } return null; } }
public boolean rewritePlaceHolders(final Query query) { visit(query); return hasPlaceHolder; }
@Override public RulesCollection build() { return new TrieMapRulesCollection(map, ignoreCase); }
@Test public void testSingleInputTwoInstructionsFromSameRule() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); String s1 = "test"; Input input = new Input(inputTerms(null, s1), false, false); Instructions instructions = instructions("instruction1", "instruction2"); builder.addRule(input, instructions); RulesCollection rulesCollection = builder.build(); PositionSequence<InputSequenceElement> sequence = new PositionSequence<>(); sequence.nextPosition(); sequence.addElement(new Term(null, s1)); List<Action> actions = rulesCollection.getRewriteActions(sequence); assertThat(actions, contains(new Action(Arrays.asList(instructions), termMatches(s1), 0, 1))); }
@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); } }
public TermMatches(final TermMatch match) { super(); add(match); }
@Override public Set<Term> getGenerableTerms() { return (query instanceof Query) ? TermsCollector.collectGenerableTerms((Query) query) : QueryRewriter.EMPTY_GENERABLE_TERMS; }