@Override public boolean hasNext() { if(joinedTuples != null && joinedTuples.hasNext()) { return true; } else { do { if(input.hasNext()) { closure.reset(input.next()); joinedTuples = joiner.getIterator(closure); } else { return false; } } while(!joinedTuples.hasNext()); return true; } }
private void verifyCoGrouper() { if( isJoin() && joiner instanceof BufferJoin ) throw new IllegalArgumentException( "invalid joiner, may not use BufferJoiner in a HashJoin" ); if( joiner == null ) { joiner = new InnerJoin(); return; } if( joiner.numJoins() == -1 ) return; int joins = Math.max( numSelfJoins, keyFieldsMap.size() - 1 ); // joining two streams is one join if( joins != joiner.numJoins() ) throw new IllegalArgumentException( "invalid joiner, only accepts " + joiner.numJoins() + " joins, there are: " + joins ); }
private void performJoinWith( Tuple keyTuple ) { // never replace the first array, pos == 0 for( int i = 1; i < keyValues.length; i++ ) { // if key does not exist, #get will create an empty array list, // and store the key, which is not a copy if( keyValues[ i ].containsKey( keyTuple ) ) collections[ i ] = keyValues[ i ].get( keyTuple ); else collections[ i ] = Collections.EMPTY_LIST; } closure.reset( collections ); keyEntry.setTuple( keyTuple ); tupleEntryIterator.reset( splice.getJoiner().getIterator( closure ) ); next.receive( this, 0, grouping ); }
@Override public void receive(Duct previous, Tuple2<Tuple, Tuple[]> t) { closure.reset(t); entryIterator.reset(joiner.getIterator(closure)); while(entryIterator.hasNext()) { next.receive(this, entryIterator.next()); } }
private void push( Collection<Tuple>[] collections, Tuple keysTuple ) { closure.reset( collections ); keyEntry.setTuple( closure.getGroupTuple( keysTuple ) ); // create Closure type here tupleEntryIterator.reset( splice.getJoiner().getIterator( closure ) ); next.receive( this, 0, grouping ); } }
public void accept( Tuple key, Iterator<Tuple>[] values ) { key = unwrapGrouping( key ); closure.reset( key, values ); // Buffer is using JoinerClosure directly if( !isBufferJoin ) tupleEntryIterator.reset( splice.getJoiner().getIterator( closure ) ); else tupleEntryIterator.reset( values ); keyEntry.setTuple( closure.getGroupTuple( key ) ); next.receive( this, 0, grouping ); }
@SuppressWarnings("unchecked") @Override public void run(Object input) { KeyPeekingIterator keyPeekingIt; try { keyPeekingIt = new KeyPeekingIterator((Iterator<Tuple>)input, keyBuilder[0]); } catch(ClassCastException cce) { throw new RuntimeException("GroupByInGate requires Iterator<Tuple>.", cce); } closure.reset(keyPeekingIt); // Buffer is using JoinerClosure directly if( !isBufferJoin ) { tupleEntryIterator.reset(splice.getJoiner().getIterator(closure)); } else { tupleEntryIterator.reset(keyPeekingIt); } Tuple groupTuple = keyPeekingIt.peekNextKey(); keyEntry.setTuple( groupTuple ); next.receive( this, grouping ); }
@SuppressWarnings("unchecked") @Override public void run(Object input) { KeyPeekingIterator iterator; try { iterator = new KeyPeekingIterator((Iterator<Tuple3<Tuple, Integer, Tuple>>)input); } catch(ClassCastException cce) { throw new RuntimeException("CoGroupBufferInGate requires Iterator<Tuple3<Tuple, Integer, Tuple>", cce); } Tuple key = iterator.peekNextKey(); closure.reset(iterator); // Buffer is using JoinerClosure directly if( !isBufferJoin ) { tupleEntryIterator.reset(splice.getJoiner().getIterator(closure)); } keyEntry.setTuple( this.closure.getGroupTuple(key) ); next.receive( this, grouping ); }
public void accept( Tuple key, Iterator<Tuple>[] values ) { key = unwrapGrouping( key ); closure.reset( key, values ); // Buffer is using JoinerClosure directly if( !isBufferJoin ) tupleEntryIterator.reset( splice.getJoiner().getIterator( closure ) ); else tupleEntryIterator.reset( values ); keyEntry.setTuple( closure.getGroupTuple( key ) ); next.receive( this, 0, grouping ); }