public static void setYearMonth(byte[] bytes, int start, int value) { IntegerPointable.setInteger(bytes, start + YEAR_MONTH_OFFSET, value); }
public void setInteger(int value) { setInteger(bytes, start, value); }
public static void setFloat(byte[] bytes, int start, float value) { int bits = Float.floatToIntBits(value); IntegerPointable.setInteger(bytes, start, bits); }
public void endNamespaceChunk() { byte[] bytes = mvs.getByteArray(); IntegerPointable.setInteger(bytes, nsChunkStart, nsCount); }
public int preIncrement() { int v = getInteger(); ++v; setInteger(v); return v; }
public int postIncrement() { int v = getInteger(); int ov = v++; setInteger(v); return ov; }
public void write(ArrayBackedValueStorage abvs) throws IOException { DataOutput out = abvs.getDataOutput(); int sizeOffset = abvs.getLength(); out.writeInt(0); int entryCount = stringEndOffsets.getSize(); out.writeInt(entryCount); int[] entryOffsets = stringEndOffsets.getArray(); for (int i = 0; i < entryCount; ++i) { out.writeInt(entryOffsets[i]); } if (hashSlotIndexes.isEmpty()) { int[] sortedOffsets = sortedSlotIndexes.getArray(); for (int i = 0; i < entryCount; ++i) { out.writeInt(sortedOffsets[i]); } } else { for (Entry<String, Integer> me : hashSlotIndexes.entrySet()) { out.writeInt((Integer) me.getValue()); } } out.write(dataBuffer.getByteArray(), 0, dataBuffer.size()); IntegerPointable.setInteger(abvs.getByteArray(), sizeOffset, abvs.getLength() - sizeOffset); }
@Override public void doNext() throws HyracksDataException { // Do nothing. Count is performed just once! IntegerPointable.setInteger(countBuf, 0, count); tupleBuilder.addField(countBuf, 0, 4); countTuple.reset(tupleBuilder.getFieldEndOffsets(), tupleBuilder.getByteArray()); }
public static void setTime(byte[] bytes, int start, long hour, long minute, long second, long timezoneHour, long timezoneMinute) { BytePointable.setByte(bytes, start + HOUR_OFFSET, (byte) hour); BytePointable.setByte(bytes, start + MINUTE_OFFSET, (byte) minute); IntegerPointable.setInteger(bytes, start + MILLISECOND_OFFSET, (byte) second); BytePointable.setByte(bytes, start + TIMEZONE_HOUR_OFFSET, (byte) timezoneHour); BytePointable.setByte(bytes, start + TIMEZONE_MINUTE_OFFSET, (byte) timezoneMinute); }
@Override public IScalarEvaluator createScalarEvaluator(IHyracksTaskContext ctx) throws HyracksDataException { // Format: |TypeTag | PayloadLength | Payload | // TypeTag: 1 byte // PayloadLength: 1 byte // Payload: 12 bytes: |partition-id (4 bytes) | local-id (8 bytes) | byte[] uidBytes = new byte[BINARY_LENGTH]; // Writes the type tag. uidBytes[0] = ATypeTag.SERIALIZED_BINARY_TYPE_TAG; // Writes the payload size. uidBytes[1] = BINARY_LENGTH - PAYLOAD_START; // Writes the 4 byte partition id. IntegerPointable.setInteger(uidBytes, PAYLOAD_START, ctx.getTaskAttemptId().getTaskId().getPartition()); return new IScalarEvaluator() { @Override public void evaluate(IFrameTupleReference tuple, IPointable result) throws HyracksDataException { // Increments the Unique ID value. for (int i = BINARY_LENGTH - 1; i >= PAYLOAD_START; i--) { if (++uidBytes[i] != 0) { break; } } result.set(uidBytes, 0, BINARY_LENGTH); } }; } };
private boolean processUnorderedList(List<IVisitablePointable> itemsLeft, List<IVisitablePointable> itemTagTypesLeft, List<IVisitablePointable> itemsRight, List<IVisitablePointable> itemTagTypesRight) throws HyracksDataException { hashMap.clear(); // Build phase: Add items into hash map, starting with first list. for (int i = 0; i < itemsLeft.size(); i++) { IVisitablePointable item = itemsLeft.get(i); byte[] buf = item.getByteArray(); int off = item.getStartOffset(); int len = item.getLength(); keyEntry.set(buf, off, len); IntegerPointable.setInteger(valEntry.getBuf(), 0, i); hashMap.put(keyEntry, valEntry); } return probeHashMap(itemsLeft, itemTagTypesLeft, itemsRight, itemTagTypesRight); }
public static void setDateTime(byte[] bytes, int start, long year, long month, long day, long hour, long minute, long milliSecond, long timezoneHour, long timezoneMinute) { ShortPointable.setShort(bytes, start + YEAR_OFFSET, (short) year); BytePointable.setByte(bytes, start + MONTH_OFFSET, (byte) month); BytePointable.setByte(bytes, start + DAY_OFFSET, (byte) day); BytePointable.setByte(bytes, start + HOUR_OFFSET, (byte) hour); BytePointable.setByte(bytes, start + MINUTE_OFFSET, (byte) minute); IntegerPointable.setInteger(bytes, start + MILLISECOND_OFFSET, (int) milliSecond); BytePointable.setByte(bytes, start + TIMEZONE_HOUR_OFFSET, (byte) timezoneHour); BytePointable.setByte(bytes, start + TIMEZONE_MINUTE_OFFSET, (byte) timezoneMinute); }
protected void buildHashMap(AbstractAsterixListIterator buildIter) throws HyracksDataException { // Build phase: Add items into hash map, starting with first list. // Value in map is a pair of integers. Set first integer to 1. IntegerPointable.setInteger(valEntry.getBuf(), 0, 1); while (buildIter.hasNext()) { byte[] buf = buildIter.getData(); int off = buildIter.getPos(); int len = buildIter.getItemLen(); keyEntry.set(buf, off, len); BinaryEntry entry = hashMap.put(keyEntry, valEntry); if (entry != null) { // Increment value. int firstValInt = IntegerPointable.getInteger(entry.getBuf(), entry.getOffset()); IntegerPointable.setInteger(entry.getBuf(), entry.getOffset(), firstValInt + 1); } buildIter.next(); } }
private void buildTuple(ArrayTupleBuilder builder, ITupleReference diskTuple, int cursorIndex, IValueReference tupleFlag) throws HyracksDataException { builder.reset(); cursorIndexPointable.setInteger(cursorIndex); builder.addField(cursorIndexPointable); builder.addField(tupleFlag); for (int i = 0; i < diskTuple.getFieldCount(); i++) { builder.addField(diskTuple.getFieldData(i), diskTuple.getFieldStart(i), diskTuple.getFieldLength(i)); } }
public boolean accessRecord(IVisitablePointable recPointableLeft, IVisitablePointable recPointableRight, DeepEqualityVisitor visitor) throws HyracksDataException { if (recPointableLeft.equals(recPointableRight)) { return true; } this.visitor = visitor; hashMap.clear(); ARecordVisitablePointable recLeft = (ARecordVisitablePointable) recPointableLeft; List<IVisitablePointable> fieldNamesLeft = recLeft.getFieldNames(); ARecordVisitablePointable recRight = (ARecordVisitablePointable) recPointableRight; List<IVisitablePointable> fieldNamesRight = recRight.getFieldNames(); int sizeLeft = fieldNamesLeft.size(); int sizeRight = fieldNamesRight.size(); if (sizeLeft != sizeRight) { return false; } // Build phase: Add items into hash map, starting with first record. for (int i = 0; i < sizeLeft; i++) { IVisitablePointable fieldName = fieldNamesLeft.get(i); keyEntry.set(fieldName.getByteArray(), fieldName.getStartOffset(), fieldName.getLength()); IntegerPointable.setInteger(valEntry.getBuf(), 0, i); hashMap.put(keyEntry, valEntry); } return compareValues(recLeft.getFieldTypeTags(), recLeft.getFieldValues(), fieldNamesRight, recRight.getFieldTypeTags(), recRight.getFieldValues()); }
IntegerPointable.setInteger(entry.getBuf(), entry.getOffset() + 4, secondValInt); } else {
@Override public byte[] getByteArray() { if (binaryFilter.getLength() == 0) { int binarySize = 2; if (min.getLength() > 0) { binarySize += Integer.BYTES + min.getLength(); } if (max.getLength() > 0) { binarySize += Integer.BYTES + max.getLength(); } binaryFilter.setSize(binarySize); byte[] buf = binaryFilter.getByteArray(); BooleanPointable.setBoolean(buf, MIN_SET_INDICATOR_OFFSET, min.getLength() > 0); BooleanPointable.setBoolean(buf, MAX_SET_INDICATOR_OFFSET, max.getLength() > 0); int offset = 2; if (min.getLength() > 0) { IntegerPointable.setInteger(buf, offset, min.getLength()); offset += Integer.BYTES; System.arraycopy(min.getByteArray(), 0, buf, offset, min.getLength()); offset += min.getLength(); } if (max.getLength() > 0) { IntegerPointable.setInteger(buf, offset, max.getLength()); offset += Integer.BYTES; System.arraycopy(max.getByteArray(), 0, buf, offset, max.getLength()); } } return binaryFilter.getByteArray(); }
protected int probeHashMap(AbstractAsterixListIterator probeIter, int buildListSize, int probeListSize) throws HyracksDataException { // Probe phase: Probe items from second list, and compute intersection size. int intersectionSize = 0; while (probeIter.hasNext()) { byte[] buf = probeIter.getData(); int off = probeIter.getPos(); int len = probeIter.getItemLen(); keyEntry.set(buf, off, len); BinaryEntry entry = hashMap.get(keyEntry); if (entry != null) { // Increment second value. int firstValInt = IntegerPointable.getInteger(entry.getBuf(), entry.getOffset()); // Irrelevant for the intersection size. if (firstValInt == 0) { continue; } int secondValInt = IntegerPointable.getInteger(entry.getBuf(), entry.getOffset() + 4); // Subtract old min value. intersectionSize -= (firstValInt < secondValInt) ? firstValInt : secondValInt; secondValInt++; // Add new min value. intersectionSize += (firstValInt < secondValInt) ? firstValInt : secondValInt; IntegerPointable.setInteger(entry.getBuf(), entry.getOffset() + 4, secondValInt); } probeIter.next(); } return intersectionSize; }