@Override public Object visit(ASTEQNode node, Object data) { // if this node represents a field/value that has poor selectability, then push it down if (hasLowSelectability(node)) { return ASTDelayedPredicate.create(node); } return node; }
@Override public Object visit(ASTReference node, Object data) { // if a delayed predicate, then change it to a regular reference if (ASTDelayedPredicate.instanceOf(node)) { JexlNode source = ASTDelayedPredicate.getDelayedPredicateSource(node); JexlNodes.swap(node.jjtGetParent(), node, source); return source; } else if (!ExecutableDeterminationVisitor.isExecutable(node, config, indexedFields, indexOnlyFields, nonEventFields, false, null, helper)) { super.visit(node, data); } return node; }
/** * @param node * @return */ public static ASTDelayedPredicate create(JexlNode node) { JexlNode parent = node.jjtGetParent(); ASTDelayedPredicate expr = new ASTDelayedPredicate(node); if (parent != null) { JexlNodes.replaceChild(parent, node, expr); } return expr; }
@Override public Object visit(ASTReference node, Object o) { // Recurse only if not delayed or evaluation only if (!ASTDelayedPredicate.instanceOf(node) && !ASTEvaluationOnly.instanceOf(node)) { super.visit(node, o); } else if (ASTDelayedPredicate.instanceOf(node)) { JexlNode subNode = ASTDelayedPredicate.getQueryPropertySource(node, ASTDelayedPredicate.class); if (subNode instanceof ASTEQNode) { delayedEqNodes.add(subNode); } if (isQueryFullySatisfied == true) { log.warn("Determined that isQueryFullySatisfied should be false, but it was not preset to false in the SatisfactionVisitor"); } log.warn("Will not process ASTDelayedPredicate."); } return null; }
@Override public Object visit(ASTReference node, Object o) { // Recurse only if not delayed if (!ASTDelayedPredicate.instanceOf(node)) { super.visit(node, o); } else { isQueryFullySatisfied = false; } return null; }
@Test public void instanceOfTest() throws Exception { String baseQuery = "(GEO >= '0202' && GEO <= '020d') && (WKT_BYTE_LENGTH >= '+AE0' && WKT_BYTE_LENGTH < '+bE8')"; JexlNode baseQueryNode = JexlASTHelper.parseJexlQuery(baseQuery); JexlNode delayedNode = ASTDelayedPredicate.create(baseQueryNode); Assert.assertTrue(ASTDelayedPredicate.instanceOf(delayedNode)); JexlNode sourceNode = ASTDelayedPredicate.getDelayedPredicateSource(delayedNode); Assert.assertEquals(baseQuery, JexlStringBuildingVisitor.buildQuery(sourceNode)); String delayedQueryString = JexlStringBuildingVisitor.buildQuery(delayedNode); JexlNode reconstructedDelayedNode = JexlASTHelper.parseJexlQuery(delayedQueryString); Assert.assertTrue(ASTDelayedPredicate.instanceOf(reconstructedDelayedNode)); sourceNode = ASTDelayedPredicate.getDelayedPredicateSource(delayedNode); Assert.assertEquals(baseQuery, JexlStringBuildingVisitor.buildQuery(sourceNode)); } }
for (JexlNode markedParent : markedParents) { if (ExceededValueThresholdMarkerJexlNode.instanceOf(markedParent) || ExceededOrThresholdMarkerJexlNode.instanceOf(markedParent) || ASTDelayedPredicate.instanceOf(markedParent) || IndexHoleMarkerJexlNode.instanceOf(markedParent) || ASTEvaluationOnly.instanceOf(node)) return node; return ASTDelayedPredicate.create(node); // wrap in a delayed predicate to avoid using in RangeStream
@Override public Object visit(ASTReference node, Object data) { // if a delayed predicate, then leave it alone if (ASTDelayedPredicate.instanceOf(node)) { return node; } else if (!ExecutableDeterminationVisitor.isExecutable(node, config, indexedFields, indexOnlyFields, nonEventFields, false, null, helper)) { super.visit(node, data); } return node; }
public static JexlNode getSourceNode(JexlNode delayedNode) { if (ASTDelayedPredicate.instanceOf(delayedNode)) { return ASTDelayedPredicate.getQueryPropertySource(delayedNode, ASTDelayedPredicate.class); } else if (ExceededValueThresholdMarkerJexlNode.instanceOf(delayedNode)) { return ExceededValueThresholdMarkerJexlNode.getExceededValueThresholdSource(delayedNode); } else if (ExceededTermThresholdMarkerJexlNode.instanceOf(delayedNode)) { return ExceededTermThresholdMarkerJexlNode.getExceededTermThresholdSource(delayedNode); } else if (IndexHoleMarkerJexlNode.instanceOf(delayedNode)) { return IndexHoleMarkerJexlNode.getIndexHoleSource(delayedNode); } else { return delayedNode; } }
protected boolean isDelayed(JexlNode testNode) { if (ASTDelayedPredicate.instanceOf(testNode)) { return true; // We do not consider the index hole marker delayed as that is only a hole in the global index, not the field index // } else if (IndexHoleMarkerJexlNode.instanceOf(testNode)) { // return true; } else if (ExceededValueThresholdMarkerJexlNode.instanceOf(testNode)) { return true; } else if (ExceededTermThresholdMarkerJexlNode.instanceOf(testNode)) { return true; } else { return false; } }
@Override public Object visit(ASTERNode node, Object data) { /** * Only perform this action is we have an AND as a parent and the cost of our node is INFINITE. our getCost method will only return INFINITE if we have * a trailing and leading wildcard */ if (isParent(node, ASTAndNode.class) && getCost(node) == Cost.INFINITE) { return ASTDelayedPredicate.create(node); } return super.visit(node, data); }
@Override public Object visit(ASTAndNode node, Object data) { Set<JexlNode> markedParents = (data != null && data instanceof Set) ? (Set) data : null; // check to see if this is a delayed node already if (ExceededValueThresholdMarkerJexlNode.instanceOf(node) || ExceededOrThresholdMarkerJexlNode.instanceOf(node) || ASTDelayedPredicate.instanceOf(node) || IndexHoleMarkerJexlNode.instanceOf(node) || ASTEvaluationOnly.instanceOf(node)) { markedParents = new HashSet<>(); markedParents.add(node); } return super.visit(node, markedParents); }
+ JexlStringBuildingVisitor.buildQuery(currNode) + " " + date + " " + info.uids.size()); info.applyNode(ASTDelayedPredicate.create((ASTEQNode) JexlNodeFactory.buildEQNode(fieldName, literal)));
protected boolean isDelayed(JexlNode testNode) { if (ASTDelayedPredicate.instanceOf(testNode)) { return true; } else if (IndexHoleMarkerJexlNode.instanceOf(testNode)) { return true; } else if (ExceededValueThresholdMarkerJexlNode.instanceOf(testNode)) { return true; } else if (ExceededTermThresholdMarkerJexlNode.instanceOf(testNode)) { return true; } else { return false; } }
child = ASTDelayedPredicate.create(tupleIter.next().first());
protected boolean isDelayed(JexlNode testNode) { if (ASTDelayedPredicate.instanceOf(testNode)) { return true; } else if (IndexHoleMarkerJexlNode.instanceOf(testNode)) { return true; } else if (ExceededValueThresholdMarkerJexlNode.instanceOf(testNode)) { return true; } else if (ExceededTermThresholdMarkerJexlNode.instanceOf(testNode)) { return true; } else { return false; } }
/** * @param delayedPredicates * @return */ protected JexlNode reverseDepth(JexlNode parentNode, List<JexlNode> delayedPredicates) { JexlNode returnNode = ASTDelayedPredicate.create(parentNode); JexlNode newAnd = new ASTAndNode(ParserTreeConstants.JJTANDNODE); int i = 0; for (JexlNode delayedNode : delayedPredicates) { newAnd.jjtAddChild(delayedNode.jjtGetChild(0), i); i++; } newAnd.jjtSetParent(returnNode); returnNode.jjtAddChild(newAnd, 0); return returnNode; }
protected boolean isDelayedPredicate(JexlNode currNode) { if (ASTDelayedPredicate.instanceOf(currNode) || ExceededOrThresholdMarkerJexlNode.instanceOf(currNode) || ExceededValueThresholdMarkerJexlNode.instanceOf(currNode) || ExceededTermThresholdMarkerJexlNode.instanceOf(currNode) || IndexHoleMarkerJexlNode.instanceOf(currNode)) return true; else return false; } }
@Override public Object visit(ASTAndNode node, Object data) { // if we have a non-executable and node, then we may be able to resolve this by pushing down the partial children if (!ExecutableDeterminationVisitor.isExecutable(node, config, indexedFields, indexOnlyFields, nonEventFields, false, null, helper)) { // first attempt to fix this by visiting the underlying nodes super.visit(node, data); // if still not executable, then we may be able to resolve this by pushing down the partial children if (!ExecutableDeterminationVisitor.isExecutable(node, config, indexedFields, indexOnlyFields, nonEventFields, false, null, helper)) { // push down any partial states for (int i = 0; i < node.jjtGetNumChildren(); i++) { JexlNode child = node.jjtGetChild(i); ExecutableDeterminationVisitor.STATE state = ExecutableDeterminationVisitor.getState(child, config, indexedFields, indexOnlyFields, nonEventFields, false, null, helper); if (state == ExecutableDeterminationVisitor.STATE.PARTIAL) { ASTDelayedPredicate.create(child); } } } } return node; }
@Override public Object visit(ASTReference node, Object data) { // delayed predicates are not run against the index (if acknowledging them) if (!(acknowledgeDelayedPredicates && ASTDelayedPredicate.instanceOf(node))) { if (!IndexHoleMarkerJexlNode.instanceOf(node)) { if (ExceededOrThresholdMarkerJexlNode.instanceOf(node) || ExceededValueThresholdMarkerJexlNode.instanceOf(node)) { ivarators++; indexedFieldCount++; } else { data = super.visit(node, data); } } } return data; }