ewi = new ExprWalkerInfo(); .getFinalCandidates().entrySet()) { if (aliases == null || e.getKey() == null || aliases.contains(e.getKey())) { if (!extractPushdownPreds.getNonFinalCandidates().isEmpty()) { hasUnpushedPredicates = true; ewi.merge(extractPushdownPreds); logExpr(nd, extractPushdownPreds);
if (joinPreds == null || !joinPreds.hasAnyCandidates()) { return; Map<String, List<ExprNodeDesc>> oldFilters = joinPreds.getFinalCandidates(); Map<String, List<ExprNodeDesc>> newFilters = new HashMap<String, List<ExprNodeDesc>>(); rsPreds.addPushDowns(targetAlias, entry.getValue()); rsPreds.addFinalCandidate(targetAlias, replaced);
ExprWalkerInfo ctx = (ExprWalkerInfo) procCtx; ExprNodeColumnDesc colref = (ExprNodeColumnDesc) nd; RowSchema toRS = ctx.getOp().getSchema(); Operator<? extends OperatorDesc> op = ctx.getOp(); ColumnInfo ci = toRS.getColumnInfo(colref.getColumn()); String tabAlias = null; colExprInfo = ctx.addOrGetExprInfo(colref); colExprInfo.isCandidate = false; return false; colExprInfo = ctx.addOrGetExprInfo(colref); colExprInfo.convertedExpr = exp; ExprInfo expInfo = ctx.addExprInfo(exp); expInfo.isCandidate = isCandidate; if (tabAlias != null) { return false; colExprInfo = ctx.addOrGetExprInfo(colref); if (tabAlias != null) { colExprInfo.alias = tabAlias;
protected static Object createFilter(Operator op, ExprWalkerInfo pushDownPreds, OpWalkerInfo owi) throws SemanticException { if (pushDownPreds != null && pushDownPreds.hasAnyCandidates()) { return createFilter(op, pushDownPreds.getFinalCandidates(), owi); } return null; }
/** * Merges the specified pushdown predicates with the current class. * * @param ewi * ExpressionWalkerInfo */ public void merge(ExprWalkerInfo ewi) { if (ewi == null) { return; } for (Entry<String, List<ExprNodeDesc>> e : ewi.getFinalCandidates() .entrySet()) { List<ExprNodeDesc> predList = pushdownPreds.get(e.getKey()); if (predList != null) { predList.addAll(e.getValue()); } else { pushdownPreds.put(e.getKey(), e.getValue()); } } for (Entry<String, List<ExprNodeDesc>> e : ewi.getNonFinalCandidates() .entrySet()) { List<ExprNodeDesc> predList = nonFinalPreds.get(e.getKey()); if (predList != null) { predList.addAll(e.getValue()); } else { nonFinalPreds.put(e.getKey(), e.getValue()); } } newToOldExprMap.putAll(ewi.getNewToOldExprMap()); }
ctx.setIsCandidate(expr, false); ctx.setDeterministic(false); return false; for (int i = 0; i < nd.getChildren().size(); i++) { ExprNodeDesc ch = (ExprNodeDesc) nd.getChildren().get(i); ExprNodeDesc newCh = ctx.getConvertedNode(ch); if (newCh != null) { expr.getChildren().set(i, newCh); ch = newCh; String chAlias = ctx.getAlias(ch); isCandidate = isCandidate && ctx.isCandidate(ch); ctx.addAlias(expr, alias); ctx.setIsCandidate(expr, isCandidate); return isCandidate;
protected ExprWalkerInfo mergeChildrenPred(Node nd, OpWalkerInfo owi, Set<String> excludedAliases, boolean ignoreAliases) throws SemanticException { if (nd.getChildren() == null) { return null; } Operator<? extends OperatorDesc> op = (Operator<? extends OperatorDesc>)nd; ExprWalkerInfo ewi = new ExprWalkerInfo(); for (Operator<? extends OperatorDesc> child : op.getChildOperators()) { ExprWalkerInfo childPreds = owi.getPrunedPreds(child); if (childPreds == null) { continue; } for (Entry<String, List<ExprNodeDesc>> e : childPreds .getFinalCandidates().entrySet()) { if (ignoreAliases || excludedAliases == null || !excludedAliases.contains(e.getKey()) || e.getKey() == null) { ewi.addPushDowns(e.getKey(), e.getValue()); logExpr(nd, ewi); } } } return ewi; } }
assert ctx.getNewToOldExprMap().containsKey(expr); for (int i = 0; i < expr.getChildren().size(); i++) { ctx.getNewToOldExprMap().put( expr.getChildren().get(i), ctx.getNewToOldExprMap().get(expr).getChildren().get(i)); extractFinalCandidates(expr.getChildren().get(i), ctx, conf); ExprInfo exprInfo = ctx.getExprInfo(expr); if (exprInfo != null && exprInfo.isCandidate) { String alias = exprInfo.alias; if ((alias == null) && (exprInfo.convertedExpr != null)) { ExprInfo convertedExprInfo = ctx.getExprInfo(exprInfo.convertedExpr); if (convertedExprInfo != null) { alias = convertedExprInfo.alias; ctx.addFinalCandidate(alias, exprInfo.convertedExpr != null ? exprInfo.convertedExpr : expr); return; } else if (!FunctionRegistry.isOpAnd(expr) && HiveConf.getBoolVar(conf, HiveConf.ConfVars.HIVEPPDREMOVEDUPLICATEFILTERS)) { ctx.addNonFinalCandidate(exprInfo != null ? exprInfo.alias : null, expr);
for (Entry<String, List<ExprNodeDesc>> entry : prunePreds.getFinalCandidates().entrySet()) { String key = entry.getKey(); List<ExprNodeDesc> value = entry.getValue(); prunePreds.getFinalCandidates().get(alias)) { exprInfo = prunePreds.addOrGetExprInfo(expr); exprInfo.alias = alias; } else { exprInfo = prunePreds.getExprInfo(expr); prunePreds.addNonFinalCandidate(exprInfo != null ? exprInfo.alias : null, expr); prunePreds.getFinalCandidates().remove(alias);
ExprWalkerInfo ctx = (ExprWalkerInfo) procCtx; ExprNodeColumnDesc colref = (ExprNodeColumnDesc) nd; RowResolver toRR = ctx.getToRR(); Operator<? extends Serializable> op = ctx.getOp(); String[] colAlias = toRR.reverseLookup(colref.getColumn()); ctx.setIsCandidate(colref, false); return false; ctx.addConvertedNode(colref, exp); ctx.setIsCandidate(exp, true); ctx.addAlias(exp, colAlias[0]); } else { if (colAlias == null) { assert false; ctx.addAlias(colref, colAlias[0]); ctx.setIsCandidate(colref, true); return true;
assert ctx.getNewToOldExprMap().containsKey(expr); for (int i = 0; i < expr.getChildren().size(); i++) { ctx.getNewToOldExprMap().put( (ExprNodeDesc) expr.getChildren().get(i), ctx.getNewToOldExprMap().get(expr).getChildren().get(i)); extractFinalCandidates((ExprNodeDesc) expr.getChildren().get(i), ctx, conf); if (ctx.isCandidate(expr)) { ctx.addFinalCandidate(expr); return; } else if (!FunctionRegistry.isOpAnd(expr) && HiveConf.getBoolVar(conf, HiveConf.ConfVars.HIVEPPDREMOVEDUPLICATEFILTERS)) { ctx.addNonFinalCandidate(expr);
ewi = new ExprWalkerInfo(); .getFinalCandidates().entrySet()) { if (ignoreAliases || aliases == null || aliases.contains(e.getKey()) || e.getKey() == null) { ewi.merge(extractPushdownPreds); logExpr(nd, extractPushdownPreds);
throws SemanticException { ExprWalkerInfo exprContext = new ExprWalkerInfo(op); ExprNodeDesc clone = node.clone(); clonedPreds.add(clone); exprContext.getNewToOldExprMap().put(clone, node);
/** * @param nd * @param ewi */ protected void logExpr(Node nd, ExprWalkerInfo ewi) { if (!LOG.isDebugEnabled()) { return; } for (Entry<String, List<ExprNodeDesc>> e : ewi.getFinalCandidates().entrySet()) { StringBuilder sb = new StringBuilder("Pushdown predicates of ").append(nd.getName()) .append(" for alias ").append(e.getKey()).append(": "); boolean isFirst = true; for (ExprNodeDesc n : e.getValue()) { if (!isFirst) { sb.append("; "); } isFirst = false; sb.append(n.getExprString()); } LOG.debug(sb.toString()); } }
ExprInfo exprInfo = ctx.addOrGetExprInfo(expr); exprInfo.isCandidate = false; ctx.setDeterministic(false); return false; for (int i = 0; i < nd.getChildren().size(); i++) { ExprNodeDesc ch = (ExprNodeDesc) nd.getChildren().get(i); ExprInfo chExprInfo = ctx.getExprInfo(ch); ExprNodeDesc newCh = chExprInfo != null ? chExprInfo.convertedExpr : null; if (newCh != null) { expr.getChildren().set(i, newCh); ch = newCh; chExprInfo = ctx.getExprInfo(ch); ExprInfo exprInfo = ctx.addOrGetExprInfo(expr); if (alias != null) { exprInfo.alias = alias;
for (Entry<String, List<ExprNodeDesc>> entry : prunePreds.getFinalCandidates().entrySet()) { String key = entry.getKey(); List<ExprNodeDesc> value = entry.getValue(); prunePreds.getFinalCandidates().get(alias)) { prunePreds.addAlias(expr, alias); prunePreds.addNonFinalCandidate(expr); prunePreds.getFinalCandidates().remove(alias);
if (!ewi.isDeterministic()) { Map<String, List<ExprNodeDesc>> residual = ewi.getResidualPredicates(true); createFilter(op, residual, owi);
/** * Adds the specified expr as the top-most pushdown expr (ie all its children * can be pushed). * * @param expr */ public void addFinalCandidate(ExprNodeDesc expr) { addFinalCandidate(getAlias(expr), expr); }
if (!ewi.isDeterministic()) { HiveConf.ConfVars.HIVEPPDREMOVEDUPLICATEFILTERS)) { if (ewi.getNonFinalCandidates().values().isEmpty()) { owi.addCandidateFilterOp((FilterOperator)op);
/** * Walks through the top AND nodes and determine which of them are final * candidates. */ private static void extractFinalCandidates(ExprNodeDesc expr, ExprWalkerInfo ctx) { if (ctx.isCandidate(expr)) { ctx.addFinalCandidate(expr); return; } if (FunctionRegistry.isOpAnd(expr)) { // If the operator is AND, we need to determine if any of the children are // final candidates. for (Node ch : expr.getChildren()) { extractFinalCandidates((ExprNodeDesc) ch, ctx); } } }