@Override public void printTuple(IFrameTupleAccessor tAccess, int tIdx) throws HyracksDataException { for (int i = 0; i < fields.length; i++) { int fldStart = tAccess.getTupleStartOffset(tIdx) + tAccess.getFieldSlotsLength() + tAccess.getFieldStartOffset(tIdx, fields[i]); int fldLen = tAccess.getFieldLength(tIdx, fields[i]); ps.write(tAccess.getBuffer().array(), fldStart, fldLen); } } };
public void join(ByteBuffer buffer, IFrameWriter writer) throws HyracksDataException { accessorProbe.reset(buffer); int tupleCount0 = accessorProbe.getTupleCount(); for (int i = 0; i < tupleCount0; ++i) { join(i, writer); } }
/** * Debugging method * * @param fta * @param tid * @param bbis * @param dis * @param sb */ protected static void prettyPrintTag(IFrameTupleAccessor fta, int tid, ByteBufferInputStream bbis, DataInputStream dis, StringBuilder sb) { sb.append(" tid" + tid + ":(" + fta.getTupleStartOffset(tid) + ", " + fta.getTupleEndOffset(tid) + ")["); for (int j = 0; j < fta.getFieldCount(); ++j) { sb.append(" "); if (j > 0) { sb.append("|"); } sb.append("f" + j + ":(" + fta.getFieldStartOffset(tid, j) + ", " + fta.getFieldEndOffset(tid, j) + ") "); sb.append("{"); sb.append(Byte.toString(fta.getBuffer().array()[fta.getTupleStartOffset(tid) + fta.getFieldSlotsLength() + fta.getFieldStartOffset(tid, j)])); sb.append("}"); } sb.append("\n"); }
@Override public int getFieldStart(int fIdx) { return fta.getTupleStartOffset(tIndex) + fta.getFieldSlotsLength() + fta.getFieldStartOffset(tIndex, fieldPermutation[fIdx]); }
@Override public boolean appendConcat(IFrameTupleAccessor accessor0, int tIndex0, IFrameTupleAccessor accessor1, int tIndex1) throws HyracksDataException { int startOffset0 = accessor0.getTupleStartOffset(tIndex0); int endOffset0 = accessor0.getTupleEndOffset(tIndex0); int length0 = endOffset0 - startOffset0; int startOffset1 = accessor1.getTupleStartOffset(tIndex1); int endOffset1 = accessor1.getTupleEndOffset(tIndex1); int length1 = endOffset1 - startOffset1; ByteBuffer src0 = accessor0.getBuffer(); ByteBuffer src1 = accessor1.getBuffer(); int slotsLen0 = accessor0.getFieldSlotsLength(); int slotsLen1 = accessor1.getFieldSlotsLength(); int dataLen0 = length0 - slotsLen0; int dataLen1 = length1 - slotsLen1;
public static String getStringFromBuffer(ByteBuffer buffer, IFrameTupleAccessor fta) throws HyracksDataException { String resultRecords = ""; ByteBufferInputStream bbis = new ByteBufferInputStream(); try { fta.reset(buffer); for (int tIndex = 0; tIndex < fta.getTupleCount(); tIndex++) { int start = fta.getTupleStartOffset(tIndex); int length = fta.getTupleEndOffset(tIndex) - start; bbis.setByteBuffer(buffer, start); byte[] recordBytes = new byte[length]; bbis.read(recordBytes, 0, length); resultRecords += new String(recordBytes, 0, length); } } finally { try { bbis.close(); } catch (IOException e) { throw new HyracksDataException(e); } } return resultRecords; } }
@Override public boolean insertTuple(int partition, IFrameTupleAccessor tupleAccessor, int tupleId, TuplePointer pointer) throws HyracksDataException { return insertTuple(partition, tupleAccessor.getBuffer().array(), null, tupleAccessor.getTupleStartOffset(tupleId), tupleAccessor.getTupleLength(tupleId), pointer); }
public static boolean sameGroup(IFrameTupleAccessor a1, int t1Idx, IFrameTupleAccessor a2, int t2Idx, int[] groupFields, IBinaryComparator[] comparators) throws HyracksDataException { for (int i = 0; i < comparators.length; ++i) { int fIdx = groupFields[i]; int s1 = a1.getAbsoluteFieldStartOffset(t1Idx, fIdx); int l1 = a1.getFieldLength(t1Idx, fIdx); int s2 = a2.getAbsoluteFieldStartOffset(t2Idx, fIdx); int l2 = a2.getFieldLength(t2Idx, fIdx); if (comparators[i].compare(a1.getBuffer().array(), s1, l1, a2.getBuffer().array(), s2, l2) != 0) { return false; } } return true; }
@Override public byte[] getFieldData(int fIdx) { return fta.getBuffer().array(); }
@Override public void next() throws HyracksDataException { // Case 1: fetching a tuple from an inverted list cursor if (isSingleInvertedList) { singleInvListCursor.next(); } else { // Case 2: fetching a tuple from the output frame of a final search result searchResultTuple.reset(searchResultFta.getBuffer().array(), searchResultFta.getTupleStartOffset(searchResultTupleIndex)); searchResultTupleIndex++; } }
@Override public boolean append(IFrameTupleAccessor tupleAccessor, int tIndex) throws HyracksDataException { int tStartOffset = tupleAccessor.getTupleStartOffset(tIndex); int tEndOffset = tupleAccessor.getTupleEndOffset(tIndex); return append(tupleAccessor, tStartOffset, tEndOffset); }
@Override void resetInnerAccessor(TuplePointer tuplePointer) { bufferAccessor.reset(bufferFrames.get(tuplePointer.getFrameIndex())); } }
private boolean hasMoreElement() throws HyracksDataException { // Case #1: single inverted list cursor if (isSingleInvertedList) { return singleInvListCursor.hasNext(); } // Case #2: ouput buffer from a final search result return searchResultTupleIndex < searchResultFta.getTupleCount(); }
/** * @param writer * @param appender * @param accessor * @param tid * @param fid * @return the number of bytes that have been flushed, 0 if not get flushed. * @throws HyracksDataException */ public static int appendFieldToWriter(IFrameWriter writer, IFrameFieldAppender appender, IFrameTupleAccessor accessor, int tid, int fid) throws HyracksDataException { int flushedBytes = 0; if (!appender.appendField(accessor, tid, fid)) { flushedBytes = appender.getBuffer().capacity(); appender.write(writer, true); if (!appender.appendField(accessor, tid, fid)) { int fStartOffset = accessor.getFieldStartOffset(tid, fid); int fLen = accessor.getFieldEndOffset(tid, fid) - fStartOffset; throw HyracksDataException.create(ErrorCode.TUPLE_CANNOT_FIT_INTO_EMPTY_FRAME, fLen); } } return flushedBytes; } }
@Override public int getTupleStartOffset(int tupleIndex) { checkTupleIndex(tupleIndex); return getInnerAccessor().getTupleStartOffset(tupleIndex); }
@Override public int getStartOffset() { return fta.getFieldStartOffset(tupleIndex, fieldIndex); }
@Override public int getLength() { return fta.getFieldLength(tupleIndex, fieldIndex); } }
@Override public int getFieldSlotsLength() { return getInnerAccessor().getFieldSlotsLength(); }
@Override public int getTupleEndOffset(int tupleIndex) { checkTupleIndex(tupleIndex); return getInnerAccessor().getTupleEndOffset(tupleIndex); }