@SuppressWarnings({ "rawtypes" }) @Override protected Object extractField(Object target) { List<String> fieldNames = getFieldNames(); for (int i = 0; i < fieldNames.size(); i++) { if (target instanceof SinkCall) { target = ((SinkCall) target).getOutgoingEntry().getObject(fieldNames.get(i)); if (target == null) { return NOT_FOUND; } } else { return NOT_FOUND; } } return target; }
public static Map<Comparable, Object> asComparableMap( Fields fields, TupleEntry arguments ) { Map<Comparable, Object> result = new HashMap<>(); for( Comparable comparable : fields ) result.put( comparable, arguments.getObject( comparable ) ); return result; }
public static Map<String, Object> asMap( Fields fields, TupleEntry arguments ) { Map<String, Object> result = new HashMap<>(); for( Comparable comparable : fields ) result.put( comparable.toString(), arguments.getObject( comparable ) ); return result; }
@Override public boolean isRemove(FlowProcess flowProcess, FilterCall filterCall) { Integer partition = ((IntWritable)filterCall.getArguments().getObject(0)).get(); return partition != partitionToKeep; } }
@Override public Boolean invoke( TupleEntry tupleEntry ) { return predicate.evaluate( tupleEntry.getObject( pos ) ); } }
@Override public void sink(FlowProcess<JobConf> flowProcess, SinkCall<Void, OutputCollector> sinkCall) throws IOException { TupleEntry tupleEntry = sinkCall.getOutgoingEntry(); byte[] key = (byte[]) tupleEntry.getObject(0); byte[] val = (byte[]) tupleEntry.getObject(1); sinkCall.getOutput().collect(new BytesWritable(key), new BytesWritable(val)); } }
@Override public void sink(FlowProcess<JobConf> jobConfFlowProcess, SinkCall<Void, OutputCollector> sinkCall) throws IOException { TupleEntry tupleEntry = sinkCall.getOutgoingEntry(); IntWritable partition = new IntWritable(tupleEntry.getInteger(partitionFieldName)); BytesWritable key = (BytesWritable) tupleEntry.getObject(keyFieldName); BytesWritable value = (BytesWritable) tupleEntry.getObject(valueFieldName); KeyAndPartitionWritable keyAndPartitionWritable = new KeyAndPartitionWritable(key, partition); ValueWritable valueWritable = new ValueWritable(value); sinkCall.getOutput().collect(keyAndPartitionWritable, valueWritable); } }
public void operate(FlowProcess process, FunctionCall call) { Object node1 = call.getArguments().getObject(0); Object node2 = call.getArguments().getObject(1); if(!node1.equals(node2)) { call.getOutputCollector().add( new Tuple(node1, node2)); call.getOutputCollector().add( new Tuple(node2, node1)); } } }
@SuppressWarnings("unchecked") @Override public void sink(FlowProcess<? extends JobConf> fp, SinkCall<Object[], OutputCollector> sc) throws IOException { TupleEntry tuple = sc.getOutgoingEntry(); if (tuple.size() != 1) { throw new RuntimeException("ParquetValueScheme expects tuples with an arity of exactly 1, but found " + tuple.getFields()); } T value = (T) tuple.getObject(0); OutputCollector output = sc.getOutput(); output.collect(null, value); }
@SuppressWarnings("unchecked") @Override public void sink(FlowProcess<? extends JobConf> fp, SinkCall<Object[], OutputCollector> sc) throws IOException { TupleEntry tuple = sc.getOutgoingEntry(); if (tuple.size() != 1) { throw new RuntimeException("ParquetValueScheme expects tuples with an arity of exactly 1, but found " + tuple.getFields()); } T value = (T) tuple.getObject(0); OutputCollector output = sc.getOutput(); output.collect(null, value); }
@SuppressWarnings("unchecked") @Override public void sink(FlowProcess<JobConf> fp, SinkCall<Object[], OutputCollector> sc) throws IOException { TupleEntry tuple = sc.getOutgoingEntry(); if (tuple.size() != 1) { throw new RuntimeException("ParquetValueScheme expects tuples with an arity of exactly 1, but found " + tuple.getFields()); } T value = (T) tuple.getObject(0); OutputCollector output = sc.getOutput(); output.collect(null, value); }
@Override public void aggregate( FlowProcess flowProcess, AggregatorCall<Pair<Double[], Tuple>> aggregatorCall ) { TupleEntry arguments = aggregatorCall.getArguments(); if( arguments.getObject( 0 ) == null ) return; Double[] sum = aggregatorCall.getContext().getLhs(); double value = sum[ 0 ] == null ? 0 : sum[ 0 ]; sum[ 0 ] = value + arguments.getDouble( 0 ); }
@Override public Tuple aggregate( FlowProcess flowProcess, TupleEntry args, Tuple context ) { if( context == null ) return args.getTupleCopy(); else if( args.getObject( 0 ) == null ) return context; context.set( 0, context.getDouble( 0 ) + args.getDouble( 0 ) ); return context; }
protected Node getArgument( OperationCall<?> operationCall ) { TupleEntry arguments = ( (FunctionCall<Object>) operationCall ).getArguments(); Node object = (Node) arguments.getObject( arguments.size() - 1, getCoercibleType() ); return deepCopy( object ); } }
private Object evaluate( ExpressionFunction function, TupleEntry tupleEntry ) { TupleListCollector tuples = invokeFunction( function, tupleEntry, function.getFieldDeclaration() ); return tuples.entryIterator().next().getObject( 0 ); }
private Object evaluate( ExpressionFunction function, TupleEntry tupleEntry ) { TupleListCollector tuples = invokeFunction( function, tupleEntry, function.getFieldDeclaration() ); return tuples.entryIterator().next().getObject( 0 ); }
@Override public Tuple aggregate( FlowProcess flowProcess, TupleEntry args, Tuple context ) { if( context == null ) context = Tuple.size( 2 ); if( include == Include.NO_NULLS && args.getObject( 0 ) == null ) return context; context.set( 0, context.getDouble( 0 ) + args.getDouble( 0 ) ); context.set( 1, context.getLong( 1 ) + 1 ); return context; }
@Override public void operate(FlowProcess flow, FunctionCall call) { byte[] bytes = Bytes.getBytes((BytesWritable)call.getArguments().getObject(0)); approxCounter.offer(bytes); function.hash(bytes, hashResult); for (int i = 0; i < hashResult.length; i++) { Tuple tuple = new Tuple(hashResult[i] / splitSize, hashResult[i] % splitSize, i); call.getOutputCollector().add(tuple); } }
@Override public void doAssert( FlowProcess flowProcess, ValueAssertionCall<Matcher> assertionCall ) { TupleEntry input = assertionCall.getArguments(); int pos = matchEachElementPos( assertionCall.getContext(), input ); if( pos != -1 ) BaseAssertion.throwFail( message, input.getFields().get( pos ), input.getObject( pos ), patternString, input.getTuple().print() ); } }
private void assertHeaders( Tap output, Flow flow ) throws IOException { TupleEntryIterator iterator = flow.openTapForRead( getPlatform().getTextFile( new Fields( "line" ), output.getIdentifier() ) ); assertEquals( iterator.next().getObject( 0 ), "first,second,third,fourth,fifth" ); iterator.close(); }