@Override public int hashCode() { return getClass().hashCode() + QueryHelper.combineHash(encoding,filter,language,getQueryTree(),sources,restrict,defaultIndex,type,searchPath); }
/** * Encodes this query onto the given buffer * * @param buffer The buffer to encode the query to * @return the number of encoded items */ public int encode(ByteBuffer buffer) { return model.getQueryTree().encode(buffer); }
/** 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; }
/** Returns a string describing this query */ @Override public String toString() { String queryTree; // getQueryTree isn't exception safe try { queryTree = model.getQueryTree().toString(); } catch (Exception e) { queryTree = "[Could not parse user input: " + model.getQueryString() + "]"; } return "query '" + queryTree + "'"; }
@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); }
/** 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)); }
/** * 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); } }
/** * 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); } }
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)); }
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); } }
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); } }
/** 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); }
@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) { if (execution.context().getIndexFacts() == null) return execution.search(query); // this is a test query boolean optimized = recursiveOptimize(query.getModel().getQueryTree(), execution.context().getIndexFacts().newSession(query)); if (optimized) query.trace("Optimized query ranges", true, 2); return execution.search(query); }
@Override public Result search(Query query, Execution execution) { IndexFacts.Session indexFacts = execution.context().getIndexFacts().newSession(query); traverse(query.getModel().getQueryTree(), indexFacts); traverseHighlight(query.getPresentation().getHighlight(), indexFacts); query.trace("Lowercasing", 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; }