public void visitScan(SQLBuilderContext ctx, ScanNode scan, Stack<LogicalNode> stack) { StringBuilder selectClause = new StringBuilder("SELECT "); if (scan.getTargets().length > 0) { selectClause.append(generateTargetList(scan.getTargets())); } else { selectClause.append("1"); } selectClause.append(" "); ctx.sb.append("FROM ").append(scan.getTableName()).append(" "); if (scan.hasAlias()) { ctx.sb.append("AS ").append(scan.getAlias()).append(" "); } if (scan.hasQual()) { ctx.sb.append("WHERE " + sqlExprGen.generate(scan.getQual())); } }
public void visitScan(SQLBuilderContext ctx, ScanNode scan, Stack<LogicalNode> stack) { StringBuilder selectClause = new StringBuilder("SELECT "); if (scan.getTargets().size() > 0) { selectClause.append(generateTargetList(scan.getTargets())); } else { selectClause.append("1"); } selectClause.append(" "); ctx.sb.append("FROM ").append(scan.getTableName()).append(" "); if (scan.hasAlias()) { ctx.sb.append("AS ").append(scan.getAlias()).append(" "); } if (scan.hasQual()) { ctx.sb.append("WHERE " + sqlExprGen.generate(scan.getQual())); } }
protected void initializeProjector(Schema actualInSchema){ List<Target> realTargets; if (plan.getTargets() == null) { realTargets = PlannerUtil.schemaToTargets(outSchema); } else { realTargets = plan.getTargets(); } //if all column is selected and there is no have expression, projection can be skipped if (realTargets.size() == inSchema.size()) { for (int i = 0; i < inSchema.size(); i++) { if (realTargets.get(i).getEvalTree() instanceof FieldEval) { FieldEval f = realTargets.get(i).getEvalTree(); if(!f.getColumnRef().equals(inSchema.getColumn(i))) { needProjection = true; break; } } else { needProjection = true; break; } } } else { needProjection = true; } if(needProjection) { projector = new Projector(context, actualInSchema, outSchema, plan.getTargets()); } }
public SystemPhysicalExec(TaskAttemptContext context, ScanNode scanNode) { super(context, scanNode.getInSchema(), scanNode.getOutSchema()); this.scanNode = scanNode; if (this.scanNode.hasQual()) { this.qual = this.scanNode.getQual(); this.qual.bind(null, inSchema); } cachedData = new ArrayList<>(); currentRow = 0; isClosed = false; projector = new Projector(context, inSchema, outSchema, scanNode.getTargets()); }
protected void initializeProjector(Schema actualInSchema){ Target[] realTargets; if (plan.getTargets() == null) { realTargets = PlannerUtil.schemaToTargets(outSchema); } else { realTargets = plan.getTargets(); } //if all column is selected and there is no have expression, projection can be skipped if (realTargets.length == inSchema.size()) { for (int i = 0; i < inSchema.size(); i++) { if (realTargets[i].getEvalTree() instanceof FieldEval) { FieldEval f = realTargets[i].getEvalTree(); if(!f.getColumnRef().equals(inSchema.getColumn(i))) { needProjection = true; break; } } else { needProjection = true; break; } } } else { needProjection = true; } if(needProjection) { projector = new Projector(context, actualInSchema, outSchema, plan.getTargets()); } }
public LogicalNode visitScan(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, Stack<LogicalNode> stack) throws TajoException { Context newContext = new Context(context); Target [] targets; if (node.hasTargets()) { targets = node.getTargets(); } else { targets = PlannerUtil.schemaToTargets(node.getLogicalSchema()); } LinkedHashSet<Target> projectedTargets = Sets.newLinkedHashSet(); for (Iterator<Target> it = getFilteredTarget(targets, newContext.requiredSet); it.hasNext();) { Target target = it.next(); newContext.addExpr(target); } for (Iterator<Target> it = context.targetListMgr.getFilteredTargets(newContext.requiredSet); it.hasNext();) { Target target = it.next(); if (LogicalPlanner.checkIfBeEvaluatedAtRelation(block, target.getEvalTree(), node)) { projectedTargets.add(target); newContext.targetListMgr.markAsEvaluated(target); } } node.setTargets(projectedTargets.toArray(new Target[projectedTargets.size()])); LogicalPlanner.verifyProjectedFields(block, node); return node; }
public Schema getProjectSchema() { Schema projected; // in the case where projected column or expression are given // the target can be an empty list. if (plan.hasTargets()) { projected = new Schema(); Set<Column> columnSet = new HashSet<Column>(); if (plan.hasQual()) { columnSet.addAll(EvalTreeUtil.findUniqueColumns(qual)); } for (Target t : plan.getTargets()) { columnSet.addAll(EvalTreeUtil.findUniqueColumns(t.getEvalTree())); } for (Column column : inSchema.getAllColumns()) { if (columnSet.contains(column)) { projected.addColumn(column); } } } else { // no any projected columns, meaning that all columns should be projected. // TODO - this implicit rule makes code readability bad. So, we should remove it later projected = outSchema; } return projected; }
public LogicalNode visitScan(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, Stack<LogicalNode> stack) throws TajoException { Context newContext = new Context(context); List<Target> targets; if (node.hasTargets()) { targets = node.getTargets(); } else { targets = PlannerUtil.schemaToTargets(node.getLogicalSchema()); } LinkedHashSet<Target> projectedTargets = Sets.newLinkedHashSet(); for (Iterator<Target> it = getFilteredTarget(targets, newContext.requiredSet); it.hasNext();) { Target target = it.next(); newContext.addExpr(target); } for (Iterator<Target> it = context.targetListMgr.getFilteredTargets(newContext.requiredSet); it.hasNext();) { Target target = it.next(); if (LogicalPlanner.checkIfBeEvaluatedAtRelation(block, target.getEvalTree(), node)) { projectedTargets.add(target); newContext.targetListMgr.markAsEvaluated(target); } } node.setTargets(new ArrayList<>(projectedTargets)); LogicalPlanner.verifyProjectedFields(block, node); return node; }
@Override public LogicalNode visitScan(PlanShapeFixerContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, Stack<LogicalNode> stack) throws TajoException { super.visitScan(context, plan, block, node, stack); context.childNumbers.push(1); if (node.hasTargets()) { node.setTargets(sortTargets(node.getTargets())); } if (node.hasQual()) { node.setQual(sortQual(node.getQual())); } return null; }
@Override public LogicalNode visitScan(PlanShapeFixerContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, Stack<LogicalNode> stack) throws TajoException { super.visitScan(context, plan, block, node, stack); context.childNumbers.push(1); if (node.hasTargets()) { node.setTargets(sortTargets(node.getTargets())); } if (node.hasQual()) { node.setQual(sortQual(node.getQual())); } return null; }
public SystemPhysicalExec(TaskAttemptContext context, ScanNode scanNode) { super(context, scanNode.getInSchema(), scanNode.getOutSchema()); this.scanNode = scanNode; if (this.scanNode.hasQual()) { this.qual = this.scanNode.getQual(); this.qual.bind(null, inSchema); } cachedData = TUtil.newList(); currentRow = 0; isClosed = false; projector = new Projector(context, inSchema, outSchema, scanNode.getTargets()); }
@Override public LogicalNode visitScan(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, Stack<LogicalNode> stack) throws TajoException { if (node.hasTargets()) { for (Target target : node.getTargets()) { ExprsVerifier.verify(context.state, node, target.getEvalTree()); } } if (node.hasQual()) { ExprsVerifier.verify(context.state, node, node.getQual()); } verifyProjectableOutputSchema(context, node); return node; }
@Override public LogicalNode visitScan(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, Stack<LogicalNode> stack) throws TajoException { if (node.hasTargets()) { for (Target target : node.getTargets()) { ExprsVerifier.verify(context.state, node, target.getEvalTree()); } } if (node.hasQual()) { ExprsVerifier.verify(context.state, node, node.getQual()); } verifyProjectableOutputSchema(context, node); return node; }
public IndexScanNode(int pid, ScanNode scanNode , Schema keySchema , SimplePredicate[] predicates, URI indexPath) { this(pid); init(scanNode.getTableDesc()); setQual(scanNode.getQual()); setInSchema(scanNode.getInSchema()); setTargets(scanNode.getTargets()); this.set(keySchema, predicates, indexPath); }
public IndexScanNode(int pid, ScanNode scanNode , Schema keySchema , SimplePredicate[] predicates, URI indexPath) { this(pid); init(scanNode.getTableDesc()); setQual(scanNode.getQual()); setInSchema(scanNode.getInSchema()); setTargets(scanNode.getTargets()); this.set(keySchema, predicates, indexPath); }
public PlanProto.ScanNode.Builder buildScanNode(ScanNode scan) { PlanProto.ScanNode.Builder scanBuilder = PlanProto.ScanNode.newBuilder(); scanBuilder.setTable(scan.getTableDesc().getProto()); if (scan.hasAlias()) { scanBuilder.setAlias(scan.getAlias()); } if (scan.hasTargets()) { scanBuilder.setExistTargets(true); scanBuilder.addAllTargets(ProtoUtil.<PlanProto.Target>toProtoObjects(scan.getTargets().toArray(new ProtoObject[scan.getTargets().size()]))); } else { scanBuilder.setExistTargets(false); } if (scan.hasQual()) { scanBuilder.setQual(EvalNodeSerializer.serialize(scan.getQual())); } scanBuilder.setBroadcast(scan.isBroadcastTable()); scanBuilder.setNameResolveBase(scan.isNameResolveBase()); return scanBuilder; }
@Override public void init() throws IOException { // Why we should check nullity? See https://issues.apache.org/jira/browse/TAJO-1422 if (fragments == null) { scanIt = new EmptyScanIterator(); } else { Schema projectedFields = getProjectSchema( plan.getInSchema(), plan.getOutSchema(), Optional.ofNullable(plan.getTargets()), Optional.ofNullable(plan.getQual()) ); initScanner(projectedFields); // See Scanner.isProjectable() method. Depending on the result of isProjectable(), // the width of retrieved tuple is changed. // // If projectable, the retrieved tuple will contain only projected fields. // Otherwise, the retrieved tuple will contain projected fields and NullDatum // for non-projected fields. Schema actualInSchema = scanner.isProjectable() ? projectedFields : inSchema; initializeProjector(actualInSchema); if (plan.hasQual()) { qual.bind(context.getEvalContext(), actualInSchema); } initScanIterator(); } super.init(); }
private void initSeqScanExec() throws IOException, TajoException { Tablespace tablespace = TablespaceManager.get(tableDesc.getUri()); List<Fragment> fragments = Lists.newArrayList( SplitUtil.getSplits(tablespace, scanNode, scanNode.getTableDesc(), true)); if (!fragments.isEmpty()) { FragmentProto[] fragmentProtos = FragmentConvertor.toFragmentProtoArray(tajoConf, fragments.toArray(new Fragment[fragments.size()])); this.taskContext = new TaskAttemptContext( new QueryContext(tajoConf), null, new TaskAttemptId(new TaskId(new ExecutionBlockId(queryId, 1), 0), 0), fragmentProtos, null); if (scanNode.hasTargets()) { QueryExecutor.startScriptExecutors(taskContext.getQueryContext(), taskContext.getEvalContext(), scanNode.getTargets()); } this.scanExec = new PartitionMergeScanExec(taskContext, scanNode, fragmentProtos); this.scanExec.init(); } else { close(); } }
public PlanProto.ScanNode.Builder buildScanNode(ScanNode scan) { PlanProto.ScanNode.Builder scanBuilder = PlanProto.ScanNode.newBuilder(); scanBuilder.setTable(scan.getTableDesc().getProto()); if (scan.hasAlias()) { scanBuilder.setAlias(scan.getAlias()); } if (scan.hasTargets()) { scanBuilder.setExistTargets(true); scanBuilder.addAllTargets(ProtoUtil.<PlanProto.Target>toProtoObjects(scan.getTargets())); } else { scanBuilder.setExistTargets(false); } if (scan.hasQual()) { scanBuilder.setQual(EvalNodeSerializer.serialize(scan.getQual())); } scanBuilder.setBroadcast(scan.isBroadcastTable()); scanBuilder.setNameResolveBase(scan.isNameResolveBase()); return scanBuilder; }
targets = scanNode.getTargets(); Collections.sort(targets, new Comparator<Target>() { @Override