How to use

Target

in

org.apache.tajo.plan

 @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);