@Override protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException { // If the current node is a group query node, check the query type and assign it to its children if (node instanceof GroupQueryNode) { GroupQueryNode groupQueryNode = (GroupQueryNode) node; String queryType = null; if (node instanceof NodeGroupQueryNode) { queryType = NODE_QUERYTYPE; } else if (node instanceof SpanGroupQueryNode) { queryType = SPAN_QUERYTYPE; } else { throw new QueryNodeException(new MessageImpl("Invalid GroupQueryNode received", node.toQueryString(new EscapeQuerySyntaxImpl()))); } // transfer the query type to its child groupQueryNode.getChild().setTag(QUERYTYPE_TAG, queryType); } // in any other cases, if the node is not a leaf node, transfer the query type to its children else if (!node.isLeaf()) { if (node.getTag(QUERYTYPE_TAG) != null) { for (final QueryNode child : node.getChildren()) { child.setTag(QUERYTYPE_TAG, node.getTag(QUERYTYPE_TAG)); } } } return node; }
@Override public String toString() { String s = "<datatype name=\"" + datatype + "\">\n"; for (final QueryNode child: this.getChildren()) { s += child.toString() + "\n"; } return s + "</datatype>"; }
protected void fillChildrenBufferAndApplyModifiery(QueryNode parent) { for (QueryNode node : parent.getChildren()) { if (node.containsTag(TAG_REMOVE)) { fillChildrenBufferAndApplyModifiery(node); } else if (node.containsTag(TAG_MODIFIER)) { childrenBuffer.add(applyModifier(node, (Modifier) node.getTag(TAG_MODIFIER))); } else { childrenBuffer.add(node); } } }
protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException { if (node.containsTag(TAG_BOOLEAN_ROOT)) { this.childrenBuffer.clear(); fillChildrenBufferAndApplyModifiery(node); node.set(childrenBuffer); } return node; }
/** * Sets the given datatype on each descendant of the {@link DatatypeQueryNode} */ private void setDatatype(final QueryNode node, final String datatype) { final Query query = (Query) node.getTag(QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID); if (query instanceof NodePrimitiveQuery) { ((NodePrimitiveQuery) query).setDatatype(datatype); } if (node.isLeaf()) { return; } for (final QueryNode child : node.getChildren()) { this.setDatatype(child, datatype); } }
@Override public QueryNode process(QueryNode queryTree) throws QueryNodeException { queryTree = super.process(queryTree); if (!queryTree.isLeaf()) { List<QueryNode> children = queryTree.getChildren(); if (children == null || children.size() == 0) { return new MatchNoDocsQueryNode(); } } return queryTree; }
throws QueryNodeException { if (node instanceof FieldQueryNode && !(node.getParent() instanceof RangeQueryNode)) { final FieldQueryNode fieldNode = (FieldQueryNode) node; final Analyzer analyzer = dts.get(node.getTag(DatatypeQueryNode.DATATYPE_TAGID)); node.setTag(DatatypeQueryNode.DATATYPE_TAGID, datatype);
protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException { QueryNode parent = node.getParent(); if (node instanceof BooleanQueryNode) { if (parent instanceof BooleanQueryNode) { node.setTag(TAG_REMOVE, Boolean.TRUE); // no precedence } else { node.setTag(TAG_BOOLEAN_ROOT, Boolean.TRUE); } } else if (parent instanceof BooleanQueryNode) { if ((parent instanceof AndQueryNode) || (usingAnd && isDefaultBooleanQueryNode(parent))) { tagModifierButDoNotOverride(node, ModifierQueryNode.Modifier.MOD_REQ); } } return node; }
@Override public Query build(QueryNode queryNode) throws QueryNodeException { GroupQueryNode groupNode = (GroupQueryNode) queryNode; return (Query) (groupNode).getChild().getTag( QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID); }
@Override protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException { if (node instanceof AndQueryNode) { this.childrenBuffer.clear(); List<QueryNode> children = node.getChildren(); for (QueryNode child : children) { this.childrenBuffer.add(applyModifier(child, ModifierQueryNode.Modifier.MOD_REQ)); } node.set(this.childrenBuffer); } else if (this.usingAnd && node instanceof BooleanQueryNode && !(node instanceof OrQueryNode)) { this.childrenBuffer.clear(); List<QueryNode> children = node.getChildren(); for (QueryNode child : children) { this.childrenBuffer.add(applyModifier(child, ModifierQueryNode.Modifier.MOD_REQ)); } node.set(this.childrenBuffer); } return node; }
dt.getChild().setTag(DatatypeQueryNode.DATATYPE_TAGID, datatype); final TwigQueryNode twig = (TwigQueryNode) node; if (twig.getTag(DatatypeQueryNode.DATATYPE_TAGID) == null) { twig.getChild().setTag(DatatypeQueryNode.DATATYPE_TAGID, this.getDefaultDatatype(conf)); twig.getChild().setTag(DatatypeQueryNode.DATATYPE_TAGID, this.getDatatype(conf, node)); twig.getRoot().setTag(DatatypeQueryNode.DATATYPE_TAGID, JSONDatatype.JSON_FIELD); else if (!node.isLeaf()) { for (final QueryNode child : node.getChildren()) { child.setTag(DatatypeQueryNode.DATATYPE_TAGID, this.getDatatype(conf, node));
&& !(node instanceof FuzzyQueryNode) && !(node instanceof RegexpQueryNode) && !(node.getParent() instanceof RangeQueryNode)) { if (currentQuery != null) { if (this.defaultOperator == Operator.OR) { q.add(currentQuery); } else { q.add(new ModifierQueryNode(currentQuery, Modifier.MOD_REQ)); q.add(currentQuery); } else { q.add(new ModifierQueryNode(currentQuery, Modifier.MOD_REQ));
@Override public CharSequence toQueryString(EscapeQuerySyntax escapeSyntaxParser) { if (getChildren() == null || getChildren().size() == 0) return ""; StringBuilder sb = new StringBuilder(); String filler = ""; for (QueryNode child : getChildren()) { sb.append(filler).append(child.toQueryString(escapeSyntaxParser)); filler = ","; } return "[TP[" + sb.toString() + "]]"; }
case NONE: List<QueryNode> children = new ArrayList<>(); children.add(q1.cloneTree()); children.add(q2.cloneTree()); result = new AndQueryNode(children); return result; case Q1: result = q1.cloneTree(); result.add(q2.cloneTree()); return result; case Q2: result = q2.cloneTree(); result.add(q1.cloneTree()); return result; case BOTH: result = q1.cloneTree(); result.add(q2.cloneTree().getChildren()); return result;
protected void tagModifierButDoNotOverride(QueryNode node, Modifier mod) { if (node instanceof ModifierQueryNode) { ModifierQueryNode modNode = (ModifierQueryNode) node; if (modNode.getModifier() == Modifier.MOD_NONE) { node.setTag(TAG_MODIFIER, mod); } } else { node.setTag(TAG_MODIFIER, ModifierQueryNode.Modifier.MOD_REQ); } }
private void processNode(QueryNode node, QueryBuilder builder) throws QueryNodeException { if (builder == null) { throw new QueryNodeException(new MessageImpl( QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR, node .toQueryString(new EscapeQuerySyntaxImpl()), node.getClass() .getName())); } Object obj = builder.build(node); if (obj != null) { node.setTag(QUERY_TREE_BUILDER_TAGID, obj); } }
public Query build(final QueryNode queryNode) throws QueryNodeException { final DatatypeQueryNode dtNode = (DatatypeQueryNode) queryNode; final QueryNode child = dtNode.getChild(); assert queryNode.getChildren().size() == 1; final Query query = (Query) child.getTag(QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID); this.setDatatype(child, dtNode.getDatatype()); return query; }
protected void processChildren(QueryNode queryTree) throws QueryNodeException { List<QueryNode> children = queryTree.getChildren(); if (children != null && children.size() > 0) { for (QueryNode child : children) { child = processIteration(child); } } }
/** * Process the child and descendant queries */ protected final void processChildren(final List<QueryNode> children, final TwigQuery query) { for (final QueryNode child : children) { final Object obj = child.getTag(QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID); final NodeQuery nodeQuery = (NodeQuery) obj; // Append child queries if (child instanceof ChildQueryNode) { query.addChild(nodeQuery, this.getModifierValue(child)); } // Append descendant queries else if (child instanceof DescendantQueryNode) { // A descendant node must always have a level constraint if (!child.containsTag(LevelPropertyParser.LEVEL_PROPERTY)) { throw new IllegalArgumentException("Invalid DescendantQueryNode received: no level constraint defined"); } // set level constraint final int nodeLevel = (Integer) child.getTag(LevelPropertyParser.LEVEL_PROPERTY); // add descendant query query.addDescendant(nodeLevel, nodeQuery, this.getModifierValue(child)); } else { throw new IllegalArgumentException("Invalid QueryNode received: " + child.getClass().getSimpleName()); } } }