private void replaceItemByGrams(Item item, Item grams, int indexInParent) { if (!(grams instanceof CompositeItem) || !(item.getParent() instanceof PhraseItem)) { // usually, simply replace item.getParent().setItem(indexInParent, grams); } else { // but if the parent is a phrase, we cannot add the AND to it, so add each gram to the phrase PhraseItem phraseParent = (PhraseItem)item.getParent(); phraseParent.removeItem(indexInParent); int addedTerms = 0; for (Iterator<Item> i = ((CompositeItem)grams).getItemIterator(); i.hasNext(); ) { phraseParent.addItem(indexInParent+(addedTerms++),i.next()); } } }
private static CompositeItem extractAndNotRecursively(CompositeItem parent) { for (int i = 0; i < parent.getItemCount(); i++) { Item child = parent.getItem(i); Item possibleNewChild = optimizeAndNot(child); if (child != possibleNewChild) { parent.setItem(i, possibleNewChild); } } if (parent instanceof AndItem) { return extractAndNot((AndItem) parent); } return parent; }
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); } }
private static Item collapseSingleComposites(Item item) { if (!(item instanceof CompositeItem)) { return item; } CompositeItem parent = (CompositeItem)item; int numChildren = parent.getItemCount(); for (int i = 0; i < numChildren; ++i) { Item oldChild = parent.getItem(i); Item newChild = collapseSingleComposites(oldChild); if (oldChild != newChild) { parent.setItem(i, newChild); } } return ((numChildren == 1) && !(parent instanceof NonReducibleCompositeItem)) ? parent.getItem(0) : item; }
private static Item rewriteSddocname(Item item) { if (item instanceof CompositeItem) { CompositeItem parent = (CompositeItem)item; for (int i = 0, len = parent.getItemCount(); i < len; ++i) { Item oldChild = parent.getItem(i); Item newChild = rewriteSddocname(oldChild); if (oldChild != newChild) { parent.setItem(i, newChild); } } } else if (item instanceof SimpleIndexedItem) { SimpleIndexedItem oldItem = (SimpleIndexedItem)item; if (Hit.SDDOCNAME_FIELD.equals(oldItem.getIndexName())) { SubstringItem newItem = new SubstringItem(oldItem.getIndexedString()); newItem.setIndexName("[documentmetastore]"); return newItem; } } return item; }
public void replace() { PhraseItem phrase=new PhraseItem(); TermItem firstWord=(TermItem)owner.setItem(startIndex,phrase); replace(firstWord,0); phrase.setIndexName(firstWord.getIndexName()); phrase.addItem(firstWord); for (int i=1; i<length; i++) { TermItem followingWord=(TermItem)owner.removeItem(startIndex+1); replace(followingWord,i); phrase.addItem(followingWord); } }
private void addItem(CompositeItem parent,int index,Item item,TermType desiredParentType) { if (parent instanceof NotItem) { if (index==0 && parent.getItem(0)==null) { // Case 1: The current positive is null and we are adding a positive parent.setItem(0,item); } else if (index<=1 && !(parent.getItem(0) instanceof CompositeItem)) { // Case 2: The positive must become a composite CompositeItem positiveComposite=(CompositeItem)desiredParentType.createItemClass(); positiveComposite.addItem(parent.getItem(0)); positiveComposite.addItem(index,item); parent.setItem(0,positiveComposite); } else if (parent.getItem(0)!=null && parent.getItem(0) instanceof CompositeItem // Case 3: Add to the positive composite && index<=((CompositeItem)parent.getItem(0)).getItemCount()) { ((CompositeItem)parent.getItem(0)).addItem(index,item); } else { // Case 4: Add negative parent.addItem(index,item); } } else if (parent.getItemCount()>0 && parent instanceof QueryTree) { CompositeItem composite=(CompositeItem)desiredParentType.createItemClass(); composite.addItem(parent.getItem(0)); composite.addItem(index,item); parent.setItem(0,composite); } else { parent.addItem(index,item); } }
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)); }