@Override public void addItem(int index, Item item) { if (getItemCount()==0 && index==0) super.addItem(index,item); else throw new RuntimeException("Programming error: Cannot add multiple roots, have '" + getRoot() + "'"); }
/** Resets the item iterator to point to the last item: */ public void resetToLast() { // PGA if (flattenedItems!=null) previousQuerySize=flattenedItems.size(); traceIndentation=""; flattenedItems=new java.util.ArrayList<>(); flatten(query.getModel().getQueryTree().getRoot(),0,flattenedItems); currentIndex = flattenedItems.size()-1; }
@NonNull private Item fetchUserQuery() { Preconditions.checkState(!queryParser, "Tried inserting user query into itself."); Preconditions.checkState(userQuery != null, "User query must be set before trying to build complete query " + "tree including user query."); return userQuery.getModel().getQueryTree().getRoot(); }
/** Resets the item iterator to point to the first item */ public void reset() { if (flattenedItems!=null) previousQuerySize=flattenedItems.size(); currentIndex=0; traceIndentation=""; flattenedItems=new java.util.ArrayList<>(); flatten(query.getModel().getQueryTree().getRoot(),0,flattenedItems); }
protected void matchAutomata(Query query,int traceLevel) { List<PhraseMatcher.Phrase> matches=getPhraseMatcher().matchPhrases(query.getModel().getQueryTree().getRoot()); if (matches==null || matches.size()==0) return; for (Iterator<PhraseMatcher.Phrase> i=matches.iterator(); i.hasNext(); ) { PhraseMatcher.Phrase phrase= i.next(); if (traceLevel>=3) query.trace("Semantic searcher automata matched " + phrase,false,1); annotatePhrase(phrase,query,traceLevel); } }
public static String serialize(Query query) { StringBuilder out = new StringBuilder(); serialize(query.getModel().getQueryTree().getRoot(), out); for (GroupingRequest request : query.getSelect().getGrouping()) { out.append(" | "); serialize(request, out); } return out.toString(); }
private Optional<ErrorMessage> validate(Query query, IndexFacts.Session indexFacts) { ValidatePredicateVisitor visitor = new ValidatePredicateVisitor(indexFacts); ToolBox.visit(visitor, query.getModel().getQueryTree().getRoot()); return visitor.errorMessage; }
private void checkQuery(Query query) { doubleEncodedUtf8(query); checkPhrases(query.getModel().getQueryTree().getRoot()); // add new heuristics here }
private Item replaceTerms(Query q, IndexFacts.Session indexFacts) { Language language = q.getModel().getParsingLanguage(); if (language == Language.UNKNOWN) { return q.getModel().getQueryTree().getRoot(); } StemContext context = new StemContext(); context.isCJK = language.isCjk(); context.language = language; context.indexFacts = indexFacts; context.reverseConnectivity = createReverseConnectivities(q.getModel().getQueryTree().getRoot()); return scan(q.getModel().getQueryTree().getRoot(), context); }
private void prepareRankFeaturesFromModel(Ranking ranking) { Item root = getQueryTree().getRoot(); if (root != null) { List<Item> tagged = setUniqueIDs(root); addLabels(tagged, ranking); addConnectivityRankProperties(tagged, ranking); addSignificances(tagged, ranking); } }
private Result handleError(RuleBase ruleBase,Query query,String error) { String message="Evaluation of query '" + query.getModel().getQueryTree() + "' over '" + ruleBase + "' caused the invalid query '" + query.getModel().getQueryTree().getRoot() + "': " + error; getLogger().warning(message); return new Result(query,ErrorMessage.createInvalidQueryTransformation(message)); }
private void addAndItem(QueryTree q, String term) { Item root = q.getRoot(); CompositeItem compositeRoot; if (root instanceof AndItem) { compositeRoot = (CompositeItem) root; } else { compositeRoot = new AndItem(); compositeRoot.addItem(root); q.setRoot(compositeRoot); } compositeRoot.addItem(new WordItem(term)); }
/** * Replaces and {@link SimpleIndexedItem} searching in the {@link Hit#SDDOCNAME_FIELD} with an item * appropriate for the search node. */ public static void rewriteSddocname(Query query) { Item oldRoot = query.getModel().getQueryTree().getRoot(); Item newRoot = rewriteSddocname(oldRoot); if (oldRoot != newRoot) { query.getModel().getQueryTree().setRoot(newRoot); } }
/** * Collapses all single-child {@link CompositeItem}s into their parent item. */ public static void collapseSingleComposites(Query query) { Item oldRoot = query.getModel().getQueryTree().getRoot(); Item newRoot = collapseSingleComposites(oldRoot); if (oldRoot != newRoot) { query.getModel().getQueryTree().setRoot(newRoot); } }
/** * Optimize multiple NotItems under and or by collapsing them in to one and leaving * the positive ones behind in its place and moving itself with the original and as its positive item * and the union of all the negative items of all the original NotItems as its negative items. */ public static void optimizeAndNot(Query query) { Item root = query.getModel().getQueryTree().getRoot(); Item possibleNewRoot = optimizeAndNot(root); if (root != possibleNewRoot) { query.getModel().getQueryTree().setRoot(possibleNewRoot); } }
/** Carries out the production of this rule */ public void produce(RuleEvaluation e) { removeNonreferencedMatches(e); if (e.getTraceLevel()>=5) { e.trace(5,"Removed terms to get '" + e.getEvaluation().getQuery().getModel().getQueryTree().getRoot() + "', will add terms"); } super.produce(e); }
/** Adds an item to the query being evaluated in a way consistent with the query type */ // TODO: Add this functionality to Query? public void addItem(Item item, TermType termType) { Item root= query.getModel().getQueryTree().getRoot(); if (root==null) query.getModel().getQueryTree().setRoot(item); else query.getModel().getQueryTree().setRoot(combineItems(root,item,termType)); }
@Override public Result search(Query query, Execution execution) { Language language = query.getModel().getParsingLanguage(); if ( ! language.isCjk()) return execution.search(query); QueryTree tree = query.getModel().getQueryTree(); tree.setRoot(transform(tree.getRoot())); query.trace("Rewriting for CJK behavior for implicit phrases", true, 2); return execution.search(query); }
@Override public Result search(Query query, Execution execution) { IndexFacts indexFacts = execution.context().getIndexFacts(); if ( ! indexFacts.hasNGramIndices()) return execution.search(query); // shortcut IndexFacts.Session session = indexFacts.newSession(query); boolean rewritten = rewriteToNGramMatching(query.getModel().getQueryTree().getRoot(), 0, session, query); if (rewritten) query.trace("Rewritten to n-gram matching",true,2); Result result = execution.search(query); recombineNGrams(result.hits().deepIterator(), session); return result; }