/** Create SortInfo, including sort tuple, to sort entire input row on sortExprs. */
private SortInfo createSortInfo(
PlanNode input, List<Expr> sortExprs, List<Boolean> isAsc, List<Boolean> nullsFirst) {
// create tuple for sort output = the entire materialized input in a single tuple
TupleDescriptor sortTupleDesc = analyzer_.getDescTbl().createTupleDescriptor("sort-tuple");
ExprSubstitutionMap sortSmap = new ExprSubstitutionMap();
List<Expr> sortSlotExprs = Lists.newArrayList();
sortTupleDesc.setIsMaterialized(true);
for (TupleId tid : input.getTupleIds()) {
TupleDescriptor tupleDesc = analyzer_.getTupleDesc(tid);
for (SlotDescriptor inputSlotDesc : tupleDesc.getSlots()) {
if (!inputSlotDesc.isMaterialized()) continue;
SlotDescriptor sortSlotDesc = analyzer_.copySlotDescriptor(inputSlotDesc, sortTupleDesc);
// all output slots need to be materialized
sortSlotDesc.setIsMaterialized(true);
sortSmap.put(new SlotRef(inputSlotDesc), new SlotRef(sortSlotDesc));
sortSlotExprs.add(new SlotRef(inputSlotDesc));
}
}
SortInfo sortInfo =
new SortInfo(Expr.substituteList(sortExprs, sortSmap, analyzer_, false), isAsc, nullsFirst);
LOG.trace("sortinfo exprs: " + Expr.debugString(sortInfo.getOrderingExprs()));
sortInfo.setMaterializedTupleInfo(sortTupleDesc, sortSlotExprs);
return sortInfo;
}
/**
* Creates the physical output and intermediate tuples as well as the logical to physical smap
* for this window group. Computes the mem layout for the tuple descriptors.
*/
public void init(Analyzer analyzer, String tupleName) {
Preconditions.checkState(physicalOutputTuple == null);
Preconditions.checkState(physicalIntermediateTuple == null);
Preconditions.checkState(analyticFnCalls.size() == analyticExprs.size());
// If needed, create the intermediate tuple first to maintain
// intermediateTupleId < outputTupleId for debugging purposes and consistency with
// tuple creation for aggregations.
boolean requiresIntermediateTuple =
AggregateInfoBase.requiresIntermediateTuple(analyticFnCalls);
if (requiresIntermediateTuple) {
physicalIntermediateTuple =
analyzer.getDescTbl().createTupleDescriptor(tupleName + "intermed");
physicalOutputTuple = analyzer.getDescTbl().createTupleDescriptor(tupleName + "out");
} else {
physicalOutputTuple = analyzer.getDescTbl().createTupleDescriptor(tupleName + "out");
physicalIntermediateTuple = physicalOutputTuple;
}
Preconditions.checkState(analyticExprs.size() == logicalIntermediateSlots.size());
Preconditions.checkState(analyticExprs.size() == logicalOutputSlots.size());
for (int i = 0; i < analyticExprs.size(); ++i) {
SlotDescriptor logicalOutputSlot = logicalOutputSlots.get(i);
SlotDescriptor physicalOutputSlot =
analyzer.copySlotDescriptor(logicalOutputSlot, physicalOutputTuple);
physicalOutputSlot.setIsMaterialized(true);
if (requiresIntermediateTuple) {
SlotDescriptor logicalIntermediateSlot = logicalIntermediateSlots.get(i);
SlotDescriptor physicalIntermediateSlot =
analyzer.copySlotDescriptor(logicalIntermediateSlot, physicalIntermediateTuple);
physicalIntermediateSlot.setIsMaterialized(true);
}
logicalToPhysicalSmap.put(new SlotRef(logicalOutputSlot), new SlotRef(physicalOutputSlot));
}
physicalOutputTuple.computeMemLayout();
if (requiresIntermediateTuple) physicalIntermediateTuple.computeMemLayout();
}