public QueryTree(Item root) { setRoot(root); }
static public void andQueryItemWithRoot(QueryTree tree, Item item) { if (tree.isEmpty()) { tree.setRoot(item); } else { Item oldRoot = tree.getRoot(); if (oldRoot.getClass() == AndItem.class) { ((AndItem) oldRoot).addItem(item); } else { AndItem newRoot = new AndItem(); newRoot.addItem(oldRoot); newRoot.addItem(item); tree.setRoot(newRoot); } } }
private Query normalizeBody(Query query, IndexFacts.Session indexFacts) { Item root = query.getModel().getQueryTree().getRoot(); Language language = query.getModel().getParsingLanguage(); if (root instanceof BlockItem) { List<Item> rootItems = new ArrayList<>(1); rootItems.add(root); ListIterator<Item> i = rootItems.listIterator(); i.next(); normalizeBlocks(language, indexFacts, (BlockItem) root, i); if ( ! rootItems.isEmpty()) // give up normalizing if the root was removed query.getModel().getQueryTree().setRoot(rootItems.get(0)); } else if (root instanceof CompositeItem) { query.getModel().getQueryTree().setRoot(normalizeComposite(language, indexFacts, (CompositeItem) root)); } return query; }
/** 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)); }
private void insertMutableInTree(CompositeItem mutable, CompositeItem original, CompositeItem parent) { if (parent == null) { query.getModel().getQueryTree().setRoot(mutable); } else { int parentsIndex = parent.getItemIndex(original); parent.setItem(parentsIndex, mutable); } }
/** Modifies this query to become the current query AND the given item */ // TODO: Make sure this is complete, unit test and make it public private void and(Item item) { if (isEmpty()) { setRoot(item); } else if (getRoot() instanceof NotItem && item instanceof NotItem) { throw new IllegalArgumentException("Can't AND two NOTs"); // TODO: Complete } else if (getRoot() instanceof NotItem){ NotItem notItem = (NotItem)getRoot(); notItem.addPositiveItem(item); } else if (item instanceof NotItem){ NotItem notItem = (NotItem)item; notItem.addPositiveItem(getRoot()); setRoot(notItem); } else { AndItem andItem = new AndItem(); andItem.addItem(getRoot()); andItem.addItem(item); setRoot(andItem); } }
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)); }
/** * Optimizes the given query tree based on its {@link Model#getRestrict()} parameter, if any. */ public static void optimizeByRestrict(Query query) { if (query.getModel().getRestrict().size() != 1) { return; } Item root = query.getModel().getQueryTree().getRoot(); if (optimizeByRestrict(root, query.getModel().getRestrict().iterator().next()) == Recall.RECALLS_NOTHING) { query.getModel().getQueryTree().setRoot(new NullItem()); } }
/** * 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); } }
/** * 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); } }
/** * Adds a RankItem at the root of a query, but only if there is * at least one rank term in the specified RankItem. * If the root is already a RankItem, just append the new rank terms. * * @param rankTerms the new rank item to add. * @param query the query to add to */ private void addTopLevelRankTerms(RankItem rankTerms, Query query) { Item root = query.getModel().getQueryTree().getRoot(); if (root instanceof RankItem) { for (Iterator<Item> i = rankTerms.getItemIterator(); i.hasNext(); ) { ((RankItem)root).addItem(i.next()); } } else { rankTerms.addItem(0, root); query.getModel().getQueryTree().setRoot(rankTerms); } }
private Hit retrieveUserProfile(String userId, Execution execution) { Query query = new Query(); query.getModel().setRestrict("user"); query.getModel().getQueryTree().setRoot(new WordItem(userId, "user_id")); query.setHits(1); SearchChain vespaChain = execution.searchChainRegistry().getComponent("vespa"); Result result = new Execution(vespaChain, execution.context()).search(query); execution.fill(result); // This is needed to get the actual summary data Iterator<Hit> hiterator = result.hits().deepIterator(); return hiterator.hasNext() ? hiterator.next() : null; }
@Override public Result search(Query query, Execution execution) { QueryTree tree = query.getModel().getQueryTree(); Item root = tree.getRoot(); if (root != null) { Item newRoot = root.clone(); newRoot = simplifyPhrases(newRoot); // Sets new root instead of transforming the query tree // to make code nicer if the root is a single term phrase if (!root.equals(newRoot)) { tree.setRoot(newRoot); query.trace("Collapsing single term phrases to single terms", true, 2); } } return execution.search(query); }
@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); }
/** * Inserts an item to the query being evaluated in a way consistent with the query type * * @param item the item to insert * @param parent the parent of this item, or null to set the root * @param index the index at which to insert this into the parent * @param desiredParentType the desired type of the composite which contains item when this returns */ public void insertItem(Item item, CompositeItem parent, int index, TermType desiredParentType) { if (parent==null) { // TODO: Accommodate for termtype in this case too query.getModel().getQueryTree().setRoot(item); return; } if (parent.getItemCount()>0 && parent instanceof QueryTree && parent.getItem(0) instanceof CompositeItem) { // combine with the existing root instead parent=(CompositeItem)parent.getItem(0); if (index==1) { // that means adding it after the existing root index=parent.getItemCount(); } } if (( desiredParentType==TermType.DEFAULT || desiredParentType.hasItemClass(parent.getClass()) ) && equalIndexNameIfParentIsPhrase(item,parent)) { addItem(parent,index,item,desiredParentType); } else { insertIncompatibleItem(item,parent,query,desiredParentType); } }
@Override public Result search(Query query, Execution execution) { if (query.properties().getBoolean(DISABLE)) return execution.search(query); IndexFacts.Session indexFacts = execution.context().getIndexFacts().newSession(query); Item newRoot = replaceTerms(query, indexFacts); query.getModel().getQueryTree().setRoot(newRoot); query.trace(getFunctionName(), true, 2); Highlight highlight = query.getPresentation().getHighlight(); if (highlight != null) { Set<String> highlightFields = highlight.getHighlightItems().keySet(); for (String field : highlightFields) { StemMode stemMode = indexFacts.getIndex(field).getStemMode(); if (stemMode != StemMode.NONE) { StemContext context = new StemContext(); context.language = Language.ENGLISH; context.indexFacts = indexFacts; Item newHighlight = scan(highlight.getHighlightItems().get(field), context); highlight.getHighlightItems().put(field, (AndItem)newHighlight); } } } return execution.search(query); }
private void insertIncompatibleItem(Item item,CompositeItem parent,Query query,TermType desiredParentType) { // Create new parent CompositeItem newParent; if (desiredParentType==TermType.DEFAULT) newParent=new AndItem(); else newParent=(CompositeItem)desiredParentType.createItemClass(); // Save previous parent parent CompositeItem parentsParent=parent.getParent(); // Add items to new parent newParent.addItem(parent); newParent.addItem(item); // Insert new parent as root or child of old parents parent if (parentsParent==null) { query.getModel().getQueryTree().setRoot(newParent); } else { int parentIndex=0; if (parentsParent!=null) { parentIndex=parentsParent.getItemIndex(parent); } parentsParent.setItem(parentIndex,newParent); } }
@Override public Result search(Query query, Execution execution) { String recall = query.properties().getString(recallName); if (recall == null) return execution.search(query); AnyParser parser = new AnyParser(ParserEnvironment.fromExecutionContext(execution.context())); QueryTree root = parser.parse(Parsable.fromQueryModel(query.getModel()).setQuery("foo").setFilter(recall)); String err; if (root.getRoot() instanceof NullItem) { err = "Failed to parse recall parameter."; } else if (!(root.getRoot() instanceof CompositeItem)) { err = "Expected CompositeItem root node, got " + root.getClass().getSimpleName() + "."; } else if (hasRankItem(root.getRoot())) { query.getModel().getQueryTree().setRoot(root.getRoot()); err = "Recall contains at least one rank item."; } else { WordItem placeholder = findOrigWordItem(root.getRoot(), "foo"); if (placeholder == null) { err = "Could not find placeholder workQuery root."; } else { updateFilterTerms(root); CompositeItem parent = placeholder.getParent(); parent.setItem(parent.getItemIndex(placeholder), query.getModel().getQueryTree().getRoot()); query.getModel().getQueryTree().setRoot(root.getRoot()); query.trace("ANDed recall tree with root workQuery node.", true, 3); return execution.search(query); } } return new Result(query, ErrorMessage.createInvalidQueryParameter(err)); }