outBags[i] = new InternalCachedBag(relationCnt);
createNewBags = false;
}
// Get the tuple from predecessor.
Result baseInp = processInput();
Tuple rearranged;
switch (baseInp.returnStatus) {
case POStatus.STATUS_OK:
rearranged = applyLRon((Tuple)baseInp.result, 0);
break;
case POStatus.STATUS_EOP:
if(!this.parentPlan.endOfAllInput)
return baseInp;
if(lastTime)
return baseInp;
// We got all the records from mapper but have not yet generated
// all the outputs that we need to, so we continue filling
// and draining the heap from side loaders.
while(!heap.isEmpty()){
Tuple topOfHeap = heap.peek();
if(needToBreak(topOfHeap, prevTopOfHeap))
break;
workingOnNewKey = false;
topOfHeap = heap.poll();
byte relIdx = (Byte)topOfHeap.get(0);
prevTopOfHeap = topOfHeap;
outBags[relIdx].add((Tuple)topOfHeap.get(2));
if(relIdx == 0) // We got all the mapper has to offer.
continue;
Tuple nxtTuple = sideLoaders.get(relIdx-1).getNext();
if(nxtTuple == null)
continue;
Tuple rearrangedTup = applyLRon(nxtTuple, relIdx);
Object key = rearrangedTup.get(1);
if(null == firstKeyOfNextSplit || null == key || firstKeyOfNextSplit.compareTo(key) > 0){
heap.offer(rearrangedTup);
}
}
// This is the last output we will produce, if heap is empty
// or we got ahead of the first key of the next split.
if(heap.isEmpty() || (firstKeyOfNextSplit != null && firstKeyOfNextSplit.compareTo(heap.peek().get(1)) <= 0))
lastTime = true;
return getOutputTuple();
default: // In case of errors, we return the tuple as it is.
return baseInp;
}
// Every time we read something valid from mapper, we add it to heap.
heap.offer(rearranged);
if(firstTime){
setup(rearranged);
firstTime = false;
// Heap is initialized with first record from all the relations.
}
// Algorithm is as following:
/* while (there are records in heap) {
peek at top record from heap
if we see a key change from previous run, break to return output.
else,
pull tuple from top of heap and place it in bag based on which input it came from
pull record from input that last record from top of heap came from
if (key pulled < first key in next split) insert into heap
}
output final record
*/
while(!heap.isEmpty()){
Tuple topOfHeap = heap.peek();
if(needToBreak(topOfHeap, prevTopOfHeap))
break;
workingOnNewKey = false;
topOfHeap = heap.poll();
byte relIdx = (Byte)topOfHeap.get(0);
prevTopOfHeap = topOfHeap;
outBags[relIdx].add((Tuple)topOfHeap.get(2));
// Pull tuple from the corresponding loader.
if(relIdx == 0){
Tuple tuple = heap.peek();
/* At this point, its possible to return the output tuple.
* So, lets check if we can do so.
* Remember, that for tuples having equal keys, tuple from
* leftmost relation is considered largest. So, if the tuple
* we just peeked from heap is of leftmost relation and has
* a different key then the tuple we polled last, then we can be
* assured that we have seen all the tuples belonging to this
* key and thus we can generate output tuple.
* Else, just pull the next tuple from the left relation by
* returning EOP.
*/
// First check if there is a tuple at top of heap and is from
// left relation.
if( (null != tuple) && (Byte)tuple.get(0) == 0){
// Is key null for both tuples.
if(prevTopOfHeap.get(1) == null && tuple.get(1) == null){
return new Result(POStatus.STATUS_EOP,null);
}
// Does key change from non-null to null or from one
// non-null to another non-null.
if((prevTopOfHeap.get(1) == null && tuple.get(1) != null) || !tuple.get(1).equals(prevTopOfHeap.get(1))){
return getOutputTuple();
}
}
// Either top of heap is from different relation or it is
// from left relation but having the same key.
return new Result(POStatus.STATUS_EOP,null);
}
Tuple nxtTuple = sideLoaders.get(relIdx-1).getNext();
if(nxtTuple == null) // EOF for this relation
continue;