How to use

setRoot

method

in

com.yahoo.search.query.QueryTree

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);
  }
}

  qTree.setRoot(phrase);
} else {
  OrItem newRoot = new OrItem();
  newRoot.addItem(oldRoot);
  newRoot.addItem(phrase);
  qTree.setRoot(newRoot);

@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));
}