static void setObject(TupleEntry entry, Comparable<?> field, Object object) { entry.setObject(field, object); }
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; } }
private TupleEntry getEntry( Comparable lhs, Comparable rhs ) { Fields fields = new Fields( "a", "b" ); Tuple parameters = new Tuple( lhs, rhs ); return new TupleEntry( fields, parameters ); }
private TupleEntry getEntry( String[] names, Class[] types, Object... values ) { Fields fields = new Fields( names ).applyTypes( types ); Tuple parameters = new Tuple( values ); return new TupleEntry( fields, parameters ); }
@Override public void convert(Object from, BytesArray to) { // expect a tuple holding one field - chararray or bytearray Assert.isTrue(from instanceof SinkCall, String.format("Unexpected object type, expecting [%s], given [%s]", SinkCall.class, from.getClass())); // handle common cases SinkCall sinkCall = (SinkCall) from; Tuple rawTuple = sinkCall.getOutgoingEntry().getTuple(); if (rawTuple == null || rawTuple.isEmpty()) { to.bytes("{}"); return; } Assert.isTrue(rawTuple.size() == 1, "When using JSON input, only one field is expected"); // postpone the coercion Tuple tuple = CascadingUtils.coerceToString(sinkCall); super.convert(tuple.getObject(0), to); } }
static List<String> asStrings(Fields fields) { if (fields == null || !fields.isDefined()) { // use auto-generated name return Collections.emptyList(); } int size = fields.size(); List<String> names = new ArrayList<String>(size); for (int fieldIndex = 0; fieldIndex < size; fieldIndex++) { names.add(fields.get(fieldIndex).toString()); } return names; }
private String print( TupleEntry tupleEntry ) { if( tupleEntry == null || tupleEntry.getFields() == null ) return "[uninitialized]"; else if( tupleEntry.getTuple() == null ) return "fields: " + tupleEntry.getFields().printVerbose(); else return "fields: " + tupleEntry.getFields().printVerbose() + " tuple: " + tupleEntry.getTuple().print(); } }
@SuppressWarnings("unchecked") @Override public Result write(SinkCall<Object[], ?> sinkCall, Generator generator) { Tuple tuple = CascadingUtils.coerceToString(sinkCall); // consider names (in case of aliases these are already applied) List<String> names = (List<String>) sinkCall.getContext()[SINK_CTX_ALIASES]; generator.writeBeginObject(); for (int i = 0; i < tuple.size(); i++) { String name = (i < names.size() ? names.get(i) : "tuple" + i); // filter out fields if (shouldKeep(generator.getParentPath(), name)) { generator.writeFieldName(name); Object object = tuple.getObject(i); Result result = jdkWriter.write(object, generator); if (!result.isSuccesful()) { if (object instanceof Writable) { return writableWriter.write((Writable) object, generator); } return Result.FAILED(object); } } } generator.writeEndObject(); return Result.SUCCESFUL(); }
static Tuple coerceToString(SinkCall<?, ?> sinkCall) { return sinkCall.getOutgoingEntry().getTuple(); } }
@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; }
/** * Method set sets the value in the given field or position. * <p> * No coercion is performed if there is an associated coercible type. * * @param fieldName field name or position to set * @param value of type Comparable */ public void setRaw( Comparable fieldName, Object value ) { tuple.set( fields.getPos( asFieldName( fieldName ) ), value ); }
@Override public TupleEntryCollector openForWrite(FlowProcess<Properties> flowProcess, Object output) throws IOException { return new TupleEntrySchemeCollector<Properties, Object>(flowProcess, getScheme(), output); }
input = queryBuilder.build(client, new ScrollReader(ScrollReaderConfigBuilder.builder(new JdkValueReader(), mapping, settings))); return new TupleEntrySchemeIterator<Properties, ScrollQuery>(flowProcess, getScheme(), input, getIdentifier());
@Override public String toString(Object field) { if (field instanceof SinkCall) { return ((SinkCall) field).getOutgoingEntry().toString(); } return field.toString(); } }
private TupleEntry getEntry( Comparable lhs, Comparable rhs ) { Fields fields = new Fields( "a", "b" ); Tuple parameters = new Tuple( lhs, rhs ); return new TupleEntry( fields, parameters ); }
private TupleEntry getEntry( Comparable f, Comparable s, Comparable t ) { Fields fields = new Fields( "a", "b", "c" ); Tuple parameters = new Tuple( f, s, t ); return new TupleEntry( fields, parameters ); } }
private TupleEntry getEntry( Comparable f, Comparable s, Comparable t ) { Fields fields = new Fields( "a", "b", "c" ); Tuple parameters = new Tuple( f, s, t ); return new TupleEntry( fields, parameters ); } }