@Override public Object addToArray(Object array, List<Object> value) { return TupleFactory.getInstance().newTupleNoCopy(value); }
@Override public Object addToArray(Object array, List<Object> value) { return TupleFactory.getInstance().newTupleNoCopy(value); }
@Override public Tuple getNext() throws IOException { if (!returned) { returned = true; String dataString = getUDFProperties().getProperty(DATA_PROP); LinkedList<String> tups = Lists.newLinkedList(); int offset = 0; for (int i = 0; i < dataString.length(); i++) { if (dataString.charAt(i) == token) { tups.add(dataString.substring(offset, i)); offset = i+1; } } tups.add(dataString.substring(offset, dataString.length())); return TupleFactory.getInstance().newTupleNoCopy(tups); } else { return null; } }
@Override public void write(DataOutput out) throws IOException { Tuple t = mTupleFactory.newTupleNoCopy(getAll()); t.write(out); }
private Object extractKeysFromIdxTuple(Tuple idxTuple) throws ExecException{ int idxTupSize = idxTuple.size(); if(idxTupSize == 3) return idxTuple.get(0); int numColsInKey = (idxTupSize - 2); List<Object> list = new ArrayList<Object>(numColsInKey); for(int i=0; i < numColsInKey; i++) list.add(idxTuple.get(i)); return mTupleFactory.newTupleNoCopy(list); }
@Override public Tuple getNext() throws IOException { try { if (!reader.nextKeyValue()) { return null; } if (readKey) { if (readValue) { return tupleFactory.newTupleNoCopy(Lists.newArrayList(getCurrentKeyObject(), getCurrentValueObject())); } else { return tupleFactory.newTupleNoCopy(Lists.newArrayList(getCurrentKeyObject())); } } else if (readValue) { return tupleFactory.newTupleNoCopy(Lists.newArrayList(getCurrentValueObject())); } else { throw new IllegalStateException("Cowardly refusing to read zero fields per record"); } } catch (EOFException e) { if (!config.genericArguments.hasOption(Config.SKIP_EOF_ERRORS_PARAM)) { throw e; } LOG.warn("EOFException encountered while reading input", e); incrCounter(Error.EOFException, 1L); } catch (InterruptedException e) { throw new ExecException("Error while reading input", 6018, PigException.REMOTE_ENVIRONMENT, e); } return null; }
@Override public Tuple getNext() throws IOException { tuple = new ArrayList<Object>(11); for (int i = 0; i < 11; i++) { tuple.add(null); } try { if (!in.nextKeyValue()) { return null; } setTuple(in.getCurrentValue()); return tupleFactory.newTupleNoCopy(tuple); } catch (InterruptedException e) { int errCode = 6018; String errMsg = "Error while reading input"; throw new ExecException(errMsg, errCode, PigException.REMOTE_ENVIRONMENT, e); } }
/** * Transform bytes from a byte array up to the specified length to a <code>Tuple</code> * * @param buf the byte array * @param length number of bytes to consume from the byte array * @param fieldDel the field delimiter * @return tuple constructed from the bytes */ public static Tuple bytesToTuple(byte[] buf, int offset, int length, byte fieldDel) { int start = offset; ArrayList<Object> protoTuple = new ArrayList<Object>(); for (int i = offset; i < length; i++) { if (buf[i] == fieldDel) { readField(protoTuple, buf, start, i); start = i + 1; } } // pick up the last field if (start <= length) { readField(protoTuple, buf, start, length); } return TupleFactory.getInstance().newTupleNoCopy(protoTuple); }
private Tuple getRangeTuple(Tuple tuple) throws ExecException { int lastColIdx = tuple.size() - 1; Tuple outTuple; if(isRangeInvalid(lastColIdx)){ //invalid range - return empty tuple outTuple = mTupleFactory.newTuple(); } else { ArrayList<Object> objList = new ArrayList<Object>(lastColIdx - startCol + 1); for(int i = startCol; i <= lastColIdx ; i++){ addColumn(objList, tuple, i); } outTuple = mTupleFactory.newTupleNoCopy(objList); } return outTuple; }
private Tuple deserializeTuple(FieldSchema fs, byte[] buf, int startIndex, int endIndex) throws IOException { Schema tupleSchema = fs.schema; ArrayList<Object> protoTuple = new ArrayList<Object>(tupleSchema.size()); int depth = 0; int fieldNum = 0; int fieldStart = startIndex; for (int index = startIndex; index <= endIndex; index++) { depth = DELIMS.updateDepth(buf, depth, index); if (StreamingDelimiters.isDelimiter(DELIMS.getFieldDelim(), buf, index, depth, endIndex)) { protoTuple.add(deserialize(tupleSchema.getField(fieldNum), buf, fieldStart, index - 1)); fieldStart = index + 3; fieldNum++; } } return tupleFactory.newTupleNoCopy(protoTuple); }
addTupleValue(mProtoTuple, buf, start, len); Tuple t = mTupleFactory.newTupleNoCopy(mProtoTuple);
res.result = noTupleCopy ? next : mTupleFactory.newTupleNoCopy(next.getAll()); res.returnStatus = POStatus.STATUS_OK; if (inputRecordCounter != null) {
addColumn(objList, inpValue, col); ret = mTupleFactory.newTupleNoCopy(objList);
addColumn(objList, tuple, col); outBag = new SingleTupleBag( mTupleFactory.newTupleNoCopy(objList) ); }else { Tuple tmpTuple = getRangeTuple(tuple); addColumn(objList, tuple, col); outBag.add( mTupleFactory.newTupleNoCopy(objList) ); }else{ Tuple outTuple = getRangeTuple(tuple);
@Override public Boolean exec(Tuple input) throws IOException { if (filter == null) { init(input); } byte[] b; if (bloomFile == null) { // The first one is the bloom filter. Skip that if (input.size() == 2) { b = DataType.toBytes(input.get(1)); } else { List<Object> inputList = input.getAll(); Tuple tuple = mTupleFactory.newTupleNoCopy(inputList.subList(1, inputList.size())); b = DataType.toBytes(tuple, DataType.TUPLE); } } else { if (input.size() == 1) { b = DataType.toBytes(input.get(0)); } else { b = DataType.toBytes(input, DataType.TUPLE); } } Key k = new Key(b); return filter.membershipTest(k); }
tup = mTupleFactory.newTupleNoCopy(list);
tupleFactory = TupleFactory.getInstance(); for (Tuple t : lRelation) { lTuples[leftSize++] = tupleFactory.newTupleNoCopy(t.getAll()); int rGeomColumn = -1; while (ri.hasNext()) { rTuples[rSize++] = tupleFactory.newTupleNoCopy(ri.next().getAll()); if (rSize == batchSize || !ri.hasNext()) {
root.attachInput(tf.newTupleNoCopy(inpTuple.getAll()));