@Override public String apply(@Nullable Target t) { StringBuilder sb = new StringBuilder(sqlExprGen.generate(t.getEvalTree())); if (t.hasAlias()) { sb.append(" AS ").append(t.getAlias()); } return sb.toString(); } });
public void markAsEvaluated(Target target) { int refId = nameToIdBiMap.get(target.getCanonicalName()); EvalNode evalNode = target.getEvalTree(); if (!idToNamesMap.containsKey(refId)) { throw new RuntimeException("No such eval: " + evalNode); } evaluationStateMap.put(refId, true); }
/** * It checks if an alias name included in the target of this node is for aggregation function. * If so, it returns TRUE. Otherwise, it returns FALSE. */ public boolean isAggregationColumn(String simpleName) { for (Target t : targets) { if (simpleName.equals(t.getNamedColumn().getSimpleName()) || simpleName.equals(t.getAlias())) { return true; } } return false; } }
Target target = node.getTargets().get(targetIdx); EvalNode evalNode = node.getAggFunctions().get(evalIdx); aggEvalNames[evalIdx] = newContext.addExpr(new Target(evalNode, target.getCanonicalName())); Column c = target.getNamedColumn(); if (!groupingColumns.contains(c)) { groupingColumns.add(c); targets.add(new Target(new FieldEval(target.getNamedColumn()))); if (target.getEvalTree().getType() == EvalType.FIELD) { Column c = ((FieldEval)target.getEvalTree()).getColumnRef(); if (!groupingColumns.contains(c)) { groupingColumns.add(c); throw new TajoInternalError("Cannot evaluate this expression in grouping keys: " + target.getEvalTree()); Target target = context.targetListMgr.getTarget(referenceName); if (LogicalPlanner.checkIfBeEvaluatedAtGroupBy(target.getEvalTree(), node)) { aggEvals.add(target.getEvalTree()); context.targetListMgr.markAsEvaluated(target);
Target target = context.targetListMgr.getTarget(sortKey); if (context.targetListMgr.isEvaluated(sortKey)) { Column c = target.getNamedColumn(); SortSpec sortSpec = new SortSpec(c, node.getSortKeys()[i].isAscending(), node.getSortKeys()[i].isNullsFirst()); if (!sortSpecs.contains(sortSpec)) { if (target.getEvalTree().getType() == EvalType.FIELD) { Column c = ((FieldEval)target.getEvalTree()).getColumnRef(); SortSpec sortSpec = new SortSpec(c, node.getSortKeys()[i].isAscending(), node.getSortKeys()[i].isNullsFirst()); if (!sortSpecs.contains(sortSpec)) {
public String addExpr(Target target) throws DuplicateColumnException { String reference = targetListMgr.add(target); addNecessaryReferences(target.getEvalTree()); return reference; }
Target target = plan.getTargets().get(i); if (target.getEvalTree().equals(targetExpr)) { if (!target.hasAlias()) { target.setAlias(target.getEvalTree().getName()); target.setExpr(constExpr); EvalTreeUtil.replace(target.getEvalTree(), targetExpr, constExpr);
Target target = context.targetListMgr.getTarget(referenceName); if (target.getEvalTree().getType() == EvalType.CONST) { finalTargets.add(target); } else if (context.targetListMgr.isEvaluated(referenceName)) { if (context.targetListMgr.isNativeAlias(referenceName)) { String realRefName = context.targetListMgr.getRealReferenceName(referenceName); finalTargets.add(new Target(new FieldEval(realRefName, target.getDataType()), referenceName)); } else { finalTargets.add(new Target(new FieldEval(target.getNamedColumn()))); } else if (LogicalPlanner.checkIfBeEvaluatedAtThis(target.getEvalTree(), node)) { finalTargets.add(target); context.targetListMgr.markAsEvaluated(target);
@Test public final void testInsertInto6() throws TajoException { QueryContext qc = createQueryContext(); Expr expr = sqlAnalyzer.parse(insertStatements[6]); LogicalPlan plan = planner.createPlan(qc, expr); assertEquals(1, plan.getQueryBlocks().size()); InsertNode insertNode = getInsertNode(plan); ProjectionNode subquery = insertNode.getChild(); List<Target> targets = subquery.getTargets(); // targets MUST be manager, NULL as empid, deptname assertEquals(targets.get(0).getNamedColumn().getQualifiedName(), "default.dept.manager"); assertEquals(targets.get(1).getAlias(), "empid"); assertEquals(targets.get(1).getEvalTree().getType(), EvalType.CONST); assertEquals(targets.get(2).getNamedColumn().getQualifiedName(), "default.dept.deptname"); }
throw new TajoInternalError("Join condition must be evaluated in the proper Join Node: " + joinQualReference); } else { node.setJoinQual(target.getEvalTree()); newContext.targetListMgr.markAsEvaluated(target); Target fieldReference = new Target(new FieldEval(target.getNamedColumn())); if (LogicalPlanner.checkIfBeEvaluatedAtJoin(block, fieldReference.getEvalTree(), node, stack.peek().getType() != NodeType.JOIN)) { projectedTargets.add(fieldReference); } else if (LogicalPlanner.checkIfBeEvaluatedAtJoin(block, target.getEvalTree(), node, stack.peek().getType() != NodeType.JOIN)) { projectedTargets.add(target);
Set<Column> columns = EvalTreeUtil.findUniqueColumns(eachTarget.getEvalTree()); if (copy.getInSchema().containsAll(columns)) { leftMostSubQueryNode = copy; int[] targetMappings = new int[targets.size()]; for (int i = 0; i < targets.size(); i++) { if (targets.get(i).getEvalTree().getType() != EvalType.FIELD) { throw new TajoInternalError("Target of a UnionNode's subquery should be FieldEval."); int index = leftMostSubQueryNode.getInSchema().getColumnId(targets.get(i).getNamedColumn().getQualifiedName()); if (index < 0) { Set<Column> columns = EvalTreeUtil.findUniqueColumns(targets.get(i).getEvalTree()); Column column = columns.iterator().next(); index = leftMostSubQueryNode.getInSchema().getColumnId(column.getQualifiedName()); Column inColumn = eachNode.getInSchema().getColumn(targetMappings[i]); Target t = eachNodeTargets.get(i); t.setAlias(t.getNamedColumn().getQualifiedName()); EvalNode evalNode = eachNodeTargets.get(i).getEvalTree(); if (evalNode.getType() != EvalType.FIELD) { throw new TajoInternalError("Target of a UnionNode's subquery should be FieldEval.");
public static List<Target> convertTargets(OverridableConf context, EvalContext evalContext, List<PlanProto.Target> targetsProto) { List<Target> targets = new ArrayList<>(); for (PlanProto.Target targetProto : targetsProto) { EvalNode evalNode = EvalNodeDeserializer.deserialize(context, evalContext, targetProto.getExpr()); if (targetProto.hasAlias()) { targets.add(new Target(evalNode, targetProto.getAlias())); } else { targets.add(new Target((FieldEval) evalNode)); } } return targets; }
@Override public int compare(Target o1, Target o2) { return o1.getCanonicalName().compareTo(o2.getCanonicalName()); } });
private static SortSpec[] annotateSortSpecs(QueryBlock block, String [] referNames, Sort.SortSpec[] rawSortSpecs) { int sortKeyNum = rawSortSpecs.length; Column column; List<SortSpec> annotatedSortSpecs = Lists.newArrayList(); for (int i = 0; i < sortKeyNum; i++) { String refName = referNames[i]; if (block.isConstReference(refName)) { continue; } else if (block.namedExprsMgr.isEvaluated(refName)) { column = block.namedExprsMgr.getTarget(refName).getNamedColumn(); } else { throw new IllegalStateException("Unexpected State: " + StringUtils.join(rawSortSpecs)); } annotatedSortSpecs.add(new SortSpec(column, rawSortSpecs[i].isAscending(), rawSortSpecs[i].isNullsFirst())); } return annotatedSortSpecs.toArray(new SortSpec[annotatedSortSpecs.size()]); }
public String toString() { StringBuilder sb = new StringBuilder(expr.toString()); if(hasAlias()) { sb.append(" as ").append(alias); } return sb.toString(); }
public Target(final EvalNode eval, final String alias) { this.expr = eval; // force lower case String normalized = alias; // If an expr is a column reference and its alias is equivalent to column name, ignore a given alias. if (eval instanceof FieldEval && eval.getName().equals(normalized)) { column = ((FieldEval) eval).getColumnRef(); } else { column = new Column(normalized, eval.getValueType()); setAlias(alias); } }
LinkedHashSet<String> nonFunctionColumns = Sets.newLinkedHashSet(); for (int i = 0; i < nonFunctionColumnNum; i++) { FieldEval fieldEval = (new FieldEval(node.getTargets().get(i).getNamedColumn())); nonFunctionColumns.add(newContext.addExpr(fieldEval)); Target target = node.getTargets().get(targetIdx); WindowFunctionEval winFunc = node.getWindowFunctions()[evalIdx]; aggEvalNames[evalIdx] = newContext.addExpr(new Target(winFunc, target.getCanonicalName())); targets.add(new Target(new FieldEval(target.getNamedColumn()))); } else { if (target.getEvalTree().getType() == EvalType.FIELD) { targets.add(target); Target target = context.targetListMgr.getTarget(referenceName); if (LogicalPlanner.checkIfBeEvaluatedAtWindowAgg(target.getEvalTree(), node)) { aggEvals[i++] = target.getEvalTree(); context.targetListMgr.markAsEvaluated(target); targets.add(new Target(new FieldEval(target.getNamedColumn())));
Target target = context.targetListMgr.getTarget(sortKey); if (context.targetListMgr.isEvaluated(sortKey)) { Column c = target.getNamedColumn(); SortSpec sortSpec = new SortSpec(c, node.getSortKeys()[i].isAscending(), node.getSortKeys()[i].isNullsFirst()); if (!sortSpecs.contains(sortSpec)) { if (target.getEvalTree().getType() == EvalType.FIELD) { Column c = ((FieldEval)target.getEvalTree()).getColumnRef(); SortSpec sortSpec = new SortSpec(c, node.getSortKeys()[i].isAscending(), node.getSortKeys()[i].isNullsFirst()); if (!sortSpecs.contains(sortSpec)) {
public String addExpr(Target target) throws DuplicateColumnException { String reference = targetListMgr.add(target); addNecessaryReferences(target.getEvalTree()); return reference; }
Target target = plan.getTargets()[i]; if (target.getEvalTree().equals(targetExpr)) { if (!target.hasAlias()) { target.setAlias(target.getEvalTree().getName()); target.setExpr(constExpr); EvalTreeUtil.replace(target.getEvalTree(), targetExpr, constExpr);