Java SinkCall.getOutgoingEntry方法代码示例

import cascading.scheme.SinkCall; //导入方法依赖的package包/类
static Tuple coerceToString(SinkCall<?, ?> sinkCall) {
    TupleEntry entry = sinkCall.getOutgoingEntry();
    Fields fields = entry.getFields();
    Tuple tuple = entry.getTuple();

    if (fields.hasTypes()) {
        Type types[] = new Type[fields.size()];
        for (int index = 0; index < fields.size(); index++) {
            Type type = fields.getType(index);
            if (type instanceof CoercibleType<?>) {
                types[index] = String.class;
            }
            else {
                types[index] = type;
            }
        }

        tuple = entry.getCoercedTuple(types);
    }
    return tuple;
}
 

import cascading.scheme.SinkCall; //导入方法依赖的package包/类
@Override
public void sink(FlowProcess<JobConf> process, SinkCall<Object[], OutputCollector> sinkCall)
    throws IOException {
  TupleEntry tuple = sinkCall.getOutgoingEntry();

  Object obj = tuple.getObject(0);
  String key;
  //a hack since byte[] isn't natively handled by hadoop
  if (getStructure() instanceof DefaultPailStructure) {
    key = getCategory(obj);
  } else {
    key = Utils.join(getStructure().getTarget(obj), "/") + getCategory(obj);
  }
  if (bw == null) { bw = new BytesWritable(); }
  if (keyW == null) { keyW = new Text(); }
  serialize(obj, bw);
  keyW.set(key);
  sinkCall.getOutput().collect(keyW, bw);
}
 

import cascading.scheme.SinkCall; //导入方法依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public void sink(FlowProcess<JobConf> flowProcess, SinkCall<Object[], OutputCollector> sinkCall) throws IOException {
  ListWritable<Text> record = (ListWritable<Text>) sinkCall.getContext()[1];
  record.clear();

  TupleEntry entry = sinkCall.getOutgoingEntry();
  Tuple tuple = entry.getTuple();

  Fields fields = getSinkFields();
  for (int i = 0; i < fields.size(); i++) {
    int index = indices != null ? indices.get(fields.get(i).toString()) : i;
    if (record.size() < index) {
      for (int j = record.size(); j < index; j++) {
        record.add(null);
      }
    }

    Object value = tuple.getObject(i);
    if (value != null) {
      record.add(index, new Text(value.toString()));
    } else {
      record.add(index, null);
    }
  }

  sinkCall.getOutput().collect(null, record);
}
 

import cascading.scheme.SinkCall; //导入方法依赖的package包/类
/**
 * Copies the values from the outgoing {@link TupleEntry} to the {@link Corc}.
 */
@SuppressWarnings("unchecked")
@Override
public void sink(FlowProcess<? extends Configuration> flowProcess, SinkCall<Corc, OutputCollector> sinkCall)
    throws IOException {
  Corc corc = sinkCall.getContext();
  TupleEntry tupleEntry = sinkCall.getOutgoingEntry();
  for (Comparable<?> fieldName : tupleEntry.getFields()) {
    corc.set(fieldName.toString(), tupleEntry.getObject(fieldName));
  }
  sinkCall.getOutput().collect(null, corc);
}
 

import cascading.scheme.SinkCall; //导入方法依赖的package包/类
@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);
}
 

import cascading.scheme.SinkCall; //导入方法依赖的package包/类
@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);
}
 

import cascading.scheme.SinkCall; //导入方法依赖的package包/类
@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));
}
 

import cascading.scheme.SinkCall; //导入方法依赖的package包/类
@Override
public void sink( FlowProcess<JobConf> flowProcess, SinkCall<Object[], OutputCollector> sinkCall ) throws IOException {
    // it's ok to use NULL here so the collector does not write anything
    TupleEntry tupleEntry = sinkCall.getOutgoingEntry();
    OutputCollector outputCollector = sinkCall.getOutput();
    if( updateBy != null )
    {
        Tuple allValues = tupleEntry.selectTuple( updateValueFields );
        Tuple updateValues = tupleEntry.selectTuple( updateByFields );

        allValues = cleanTuple( allValues );

        TupleRecord key = new TupleRecord( allValues );

        if( updateValues.equals( updateIfTuple ) )
            outputCollector.collect( key, null );
        else
            outputCollector.collect( key, key );

        return;
    }

    Tuple result = tupleEntry.selectTuple( getSinkFields() );

    result = cleanTuple( result );

    outputCollector.collect( new TupleRecord( result ), null );
}
 

import cascading.scheme.SinkCall; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public void sink(FlowProcess<JobConf> flowProcess, SinkCall<Object[], OutputCollector> sinkCall) throws IOException {
	TupleEntry tupleEntry = sinkCall.getOutgoingEntry();
	OutputCollector outputCollector = sinkCall.getOutput();
	Tuple key = tupleEntry.selectTuple(RowKeyField);
	Object okey = key.getObject(0);
	ImmutableBytesWritable keyBytes = getBytes(okey);
	Put put = new Put(keyBytes.get());
	Fields outFields = tupleEntry.getFields().subtract(RowKeyField);
	if (null != outFields) {
		TupleEntry values = tupleEntry.selectEntry(outFields);
		for (int n = 0; n < values.getFields().size(); n++) {
			Object o = values.get(n);
			ImmutableBytesWritable valueBytes = getBytes(o);
			Comparable field = outFields.get(n);
			ColumnName cn = parseColumn((String) field);
			if (null == cn.family) {
				if (n >= familyNames.length)
					cn.family = familyNames[familyNames.length - 1];
				else
					cn.family = familyNames[n];
			}
			if (null != o || writeNulls)
				put.add(Bytes.toBytes(cn.family), Bytes.toBytes(cn.name), valueBytes.get());
		}
	}
	outputCollector.collect(null, put);
}
 

import cascading.scheme.SinkCall; //导入方法依赖的package包/类
@Override
public void sink(FlowProcess<JobConf> flowProcess, SinkCall<Object[], OutputCollector> sinkCall)
    throws IOException {
  TupleEntry tupleEntry = sinkCall.getOutgoingEntry();
  OutputCollector outputCollector = sinkCall.getOutput();
  Tuple key = tupleEntry.selectTuple(keyField);
  ImmutableBytesWritable keyBytes = (ImmutableBytesWritable) key.getObject(0);

  if (useSalt) {
    keyBytes = HBaseSalter.addSaltPrefix(keyBytes);
  }

  Put put;
  if (this.timeStamp == 0L) {
    put = new Put(keyBytes.get());
  } else {
    put = new Put(keyBytes.get(), this.timeStamp);
  }
  
  for (int i = 0; i < valueFields.length; i++) {
    Fields fieldSelector = valueFields[i];
    TupleEntry values = tupleEntry.selectEntry(fieldSelector);

    for (int j = 0; j < values.getFields().size(); j++) {
      Fields fields = values.getFields();
      Tuple tuple = values.getTuple();

      ImmutableBytesWritable valueBytes = (ImmutableBytesWritable) tuple.getObject(j);
      if (valueBytes != null)
          put.add(Bytes.toBytes(familyNames[i]), Bytes.toBytes((String) fields.get(j)), valueBytes.get());
    }
  }

  outputCollector.collect(null, put);
}
 

import cascading.scheme.SinkCall; //导入方法依赖的package包/类
/**
 * Sink method to take an outgoing tuple and write it to Avro. In this scheme the incoming avro is passed through.
 *
 * @param flowProcess The cascading FlowProcess object. Should be passed in by cascading automatically.
 * @param sinkCall    The cascading SinkCall object. Should be passed in by cascading automatically.
 * @throws java.io.IOException
 */
@Override
public void sink(FlowProcess<JobConf> flowProcess, SinkCall<Object[], OutputCollector> sinkCall) throws IOException {
  TupleEntry tupleEntry = sinkCall.getOutgoingEntry();
  //noinspection unchecked
  sinkCall.getOutput().collect(null, tupleEntry.getObject(Fields.FIRST));
}