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)); }
@Override public Object clone() { try { Model clone = (Model)super.clone(); if (queryTree != null) clone.queryTree = this.queryTree.clone(); if (sources != null) clone.sources = new LinkedHashSet<>(this.sources); if (restrict != null) clone.restrict = new LinkedHashSet<>(this.restrict); return clone; } catch (CloneNotSupportedException e) { throw new RuntimeException("Someone inserted a noncloneable superclass", e); } }
/** Returns the query root. This is null if this is a null query. */ public Item getRoot() { if (getItemCount() == 0) return null; return getItem(0); }
/** Returns true if this represents the null query */ public boolean isEmpty() { return getRoot() instanceof NullItem || getItemCount() == 0; }
/** 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); } }
public QueryTree(Item root) { setRoot(root); }
public final void setRoot(Item root) { if (root == this) throw new IllegalArgumentException("Cannot make a root point at itself"); if (root == null) throw new IllegalArgumentException("Root must not be null, use NullItem instead."); if (root instanceof QueryTree) throw new IllegalArgumentException("Do not use a new QueryTree instance as a root."); if (this.getItemCount() == 0) // initializing super.addItem(root); else setItem(0,root); // replacing }
/** * Canonicalize this query * * @return null if the query is valid, an error message if it is invalid */ public static String canonicalize(QueryTree query) { ListIterator<Item> rootItemIterator = query.getItemIterator(); CanonicalizationResult result = recursivelyCanonicalize(rootItemIterator.next(), rootItemIterator); if (query.isEmpty() && ! result.isError()) result = CanonicalizationResult.error("No query"); return result.error().orElse(null); // preserve old API, unfortunately }
@Override public QueryTree parse(Parsable query) { Item root = parse(query.getQuery(), null, null, null, null, null); if (root == null) { root = new NullItem(); } return new QueryTree(root); }
/** Returns a deep copy of this */ @Override public QueryTree clone() { QueryTree clone = (QueryTree) super.clone(); fixClonedConnectivityReferences(clone); return clone; }
/** * 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); }
@Override public void addItem(Item item) { if (getItemCount()==0) super.addItem(item); else throw new RuntimeException("Programming error: Cannot add multiple roots"); }
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 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); } }
@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() + "'"); }
@NonNull private QueryTree buildTree(OperatorNode<?> filterPart) { Preconditions.checkArgument(filterPart.getArguments().length == 2, "Expected 2 arguments to filter, got %s.", filterPart.getArguments().length); populateYqlSources(filterPart.<OperatorNode<?>> getArgument(0)); OperatorNode<ExpressionOperator> filterExpression = filterPart.getArgument(1); Item root = convertExpression(filterExpression); connectItems(); userQuery = null; return new QueryTree(root); }