@Override public float getFloat(ByteBuffer buf, int position) { return delegate.getFloat(buf, position); }
@Override public float getFloat(ByteBuffer buf, int position) { return delegate.getFloat(buf, position); }
/** * Returns the double representation of the given aggregate byte array * * Converts the given byte buffer representation into the intermediate aggregate value. * * <b>Implementations must not change the position, limit or mark of the given buffer</b> * * Implementations are only required to support this method if they are aggregations which * have an {@link AggregatorFactory#getTypeName()} of "double". * If unimplemented, throwing an {@link UnsupportedOperationException} is common and recommended. * * The default implementation casts {@link BufferAggregator#getFloat(ByteBuffer, int)} to double. * This default method is added to enable smooth backward compatibility, please re-implement it if your aggregators * work with numeric double columns. * * @param buf byte buffer storing the byte array representation of the aggregate * @param position offset within the byte buffer at which the aggregate value is stored * @return the double representation of the aggregate */ default double getDouble(ByteBuffer buf, int position) { return (double) getFloat(buf, position); }
@Override public float getFloat(ByteBuffer buf, int position) { if (buf.get(position) == NullHandling.IS_NULL_BYTE) { throw new IllegalStateException("Cannot return float for Null Value"); } return delegate.getFloat(buf, position + Byte.BYTES); }
@Override public float getMetricFloatValue(int rowOffset, int aggOffset) { BufferAggregator agg = getAggs()[aggOffset]; int[] indexAndOffset = indexAndOffsets.get(rowOffset); ByteBuffer bb = aggBuffers.get(indexAndOffset[0]).get(); return agg.getFloat(bb, indexAndOffset[1] + aggOffsetInBuffer[aggOffset]); }
@Test public void testDoubleMaxBufferAggregator() { BufferAggregator agg = doubleMaxAggFactory.factorizeBuffered(colSelectorFactory); ByteBuffer buffer = ByteBuffer.wrap(new byte[Double.BYTES + Byte.BYTES]); agg.init(buffer, 0); aggregate(selector, agg, buffer, 0); aggregate(selector, agg, buffer, 0); aggregate(selector, agg, buffer, 0); aggregate(selector, agg, buffer, 0); Assert.assertEquals(values[2], ((Double) agg.get(buffer, 0)).doubleValue(), 0.0001); Assert.assertEquals((long) values[2], agg.getLong(buffer, 0)); Assert.assertEquals(values[2], agg.getFloat(buffer, 0), 0.0001); }
@Test public void testDoubleMinBufferAggregator() { BufferAggregator agg = doubleMinAggFactory.factorizeBuffered(colSelectorFactory); ByteBuffer buffer = ByteBuffer.wrap(new byte[Double.BYTES + Byte.BYTES]); agg.init(buffer, 0); aggregate(selector, agg, buffer, 0); aggregate(selector, agg, buffer, 0); aggregate(selector, agg, buffer, 0); aggregate(selector, agg, buffer, 0); Assert.assertEquals(values[2], ((Double) agg.get(buffer, 0)).doubleValue(), 0.0001); Assert.assertEquals((long) values[2], agg.getLong(buffer, 0)); Assert.assertEquals(values[2], agg.getFloat(buffer, 0), 0.0001); }
@Test public void testLongMinBufferAggregator() { BufferAggregator agg = longMinAggFactory.factorizeBuffered(colSelectorFactory); ByteBuffer buffer = ByteBuffer.wrap(new byte[Long.BYTES + Byte.BYTES]); agg.init(buffer, 0); aggregate(selector, agg, buffer, 0); aggregate(selector, agg, buffer, 0); aggregate(selector, agg, buffer, 0); aggregate(selector, agg, buffer, 0); Assert.assertEquals(values[2], ((Long) agg.get(buffer, 0)).longValue()); Assert.assertEquals(values[2], agg.getLong(buffer, 0)); Assert.assertEquals((float) values[2], agg.getFloat(buffer, 0), 0.0001); }
@Test public void testLongMaxBufferAggregator() { BufferAggregator agg = longMaxAggFactory.factorizeBuffered(colSelectorFactory); ByteBuffer buffer = ByteBuffer.wrap(new byte[Long.BYTES + Byte.BYTES]); agg.init(buffer, 0); aggregate(selector, agg, buffer, 0); aggregate(selector, agg, buffer, 0); aggregate(selector, agg, buffer, 0); aggregate(selector, agg, buffer, 0); Assert.assertEquals(values[2], ((Long) agg.get(buffer, 0)).longValue()); Assert.assertEquals(values[2], agg.getLong(buffer, 0)); Assert.assertEquals((float) values[2], agg.getFloat(buffer, 0), 0.0001); }
@Test public void testLongFirstBufferAggregator() { BufferAggregator agg = longFirstAggFactory.factorizeBuffered( colSelectorFactory); ByteBuffer buffer = ByteBuffer.wrap(new byte[longFirstAggFactory.getMaxIntermediateSizeWithNulls()]); agg.init(buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); Pair<Long, Long> result = (Pair<Long, Long>) agg.get(buffer, 0); Assert.assertEquals(times[3], result.lhs.longValue()); Assert.assertEquals(longValues[3], result.rhs.longValue()); Assert.assertEquals(longValues[3], agg.getLong(buffer, 0)); Assert.assertEquals(longValues[3], agg.getFloat(buffer, 0), 0.0001); }
@Test public void testLongLastBufferAggregator() { BufferAggregator agg = longLastAggFactory.factorizeBuffered( colSelectorFactory); ByteBuffer buffer = ByteBuffer.wrap(new byte[longLastAggFactory.getMaxIntermediateSizeWithNulls()]); agg.init(buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); Pair<Long, Long> result = (Pair<Long, Long>) agg.get(buffer, 0); Assert.assertEquals(times[2], result.lhs.longValue()); Assert.assertEquals(longValues[2], result.rhs.longValue()); Assert.assertEquals(longValues[2], agg.getLong(buffer, 0)); Assert.assertEquals(longValues[2], agg.getFloat(buffer, 0), 1); }
@Test public void testDoubleFirstBufferAggregator() { BufferAggregator agg = floatFirstAggregatorFactory.factorizeBuffered( colSelectorFactory); ByteBuffer buffer = ByteBuffer.wrap(new byte[floatFirstAggregatorFactory.getMaxIntermediateSizeWithNulls()]); agg.init(buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); Pair<Long, Float> result = (Pair<Long, Float>) agg.get(buffer, 0); Assert.assertEquals(times[1], result.lhs.longValue()); Assert.assertEquals(floats[1], result.rhs, 0.0001); Assert.assertEquals((long) floats[1], agg.getLong(buffer, 0)); Assert.assertEquals(floats[1], agg.getFloat(buffer, 0), 0.0001); }
@Test public void testDoubleLastBufferAggregator() { BufferAggregator agg = floatLastAggregatorFactory.factorizeBuffered( colSelectorFactory); ByteBuffer buffer = ByteBuffer.wrap(new byte[floatLastAggregatorFactory.getMaxIntermediateSizeWithNulls()]); agg.init(buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); Pair<Long, Float> result = (Pair<Long, Float>) agg.get(buffer, 0); Assert.assertEquals(times[0], result.lhs.longValue()); Assert.assertEquals(floats[0], result.rhs, 0.0001); Assert.assertEquals((long) floats[0], agg.getLong(buffer, 0)); Assert.assertEquals(floats[0], agg.getFloat(buffer, 0), 0.0001); }
@Test public void testLongFirstCombiningBufferAggregator() { BufferAggregator agg = combiningAggFactory.factorizeBuffered( colSelectorFactory); ByteBuffer buffer = ByteBuffer.wrap(new byte[longFirstAggFactory.getMaxIntermediateSizeWithNulls()]); agg.init(buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); Pair<Long, Long> result = (Pair<Long, Long>) agg.get(buffer, 0); Pair<Long, Long> expected = (Pair<Long, Long>) pairs[0]; Assert.assertEquals(expected.lhs, result.lhs); Assert.assertEquals(expected.rhs, result.rhs); Assert.assertEquals(expected.rhs.longValue(), agg.getLong(buffer, 0)); Assert.assertEquals(expected.rhs, agg.getFloat(buffer, 0), 0.0001); }
@Test public void testLongLastCombiningBufferAggregator() { BufferAggregator agg = combiningAggFactory.factorizeBuffered( colSelectorFactory); ByteBuffer buffer = ByteBuffer.wrap(new byte[longLastAggFactory.getMaxIntermediateSizeWithNulls()]); agg.init(buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); Pair<Long, Long> result = (Pair<Long, Long>) agg.get(buffer, 0); Pair<Long, Long> expected = (Pair<Long, Long>) pairs[2]; Assert.assertEquals(expected.lhs, result.lhs); Assert.assertEquals(expected.rhs, result.rhs); Assert.assertEquals(expected.rhs.longValue(), agg.getLong(buffer, 0)); Assert.assertEquals(expected.rhs, agg.getFloat(buffer, 0), 1); }
@Test public void testDoubleFirstCombiningBufferAggregator() { BufferAggregator agg = combiningAggFactory.factorizeBuffered( colSelectorFactory); ByteBuffer buffer = ByteBuffer.wrap(new byte[floatFirstAggregatorFactory.getMaxIntermediateSizeWithNulls()]); agg.init(buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); Pair<Long, Float> result = (Pair<Long, Float>) agg.get(buffer, 0); Pair<Long, Float> expected = (Pair<Long, Float>) pairs[2]; Assert.assertEquals(expected.lhs, result.lhs); Assert.assertEquals(expected.rhs, result.rhs, 0.0001); Assert.assertEquals(expected.rhs.longValue(), agg.getLong(buffer, 0)); Assert.assertEquals(expected.rhs, agg.getFloat(buffer, 0), 0.0001); }
@Test public void testDoubleLastCombiningBufferAggregator() { BufferAggregator agg = combiningAggFactory.factorizeBuffered( colSelectorFactory); ByteBuffer buffer = ByteBuffer.wrap(new byte[floatLastAggregatorFactory.getMaxIntermediateSizeWithNulls()]); agg.init(buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); aggregate(agg, buffer, 0); Pair<Long, Float> result = (Pair<Long, Float>) agg.get(buffer, 0); Pair<Long, Float> expected = (Pair<Long, Float>) pairs[2]; Assert.assertEquals(expected.lhs, result.lhs); Assert.assertEquals(expected.rhs, result.rhs, 0.0001); Assert.assertEquals(expected.rhs.longValue(), agg.getLong(buffer, 0)); Assert.assertEquals(expected.rhs, agg.getFloat(buffer, 0), 0.0001); }
@Override public float getFloat(ByteBuffer buf, int position) { return delegate.getFloat(buf, position); }
@Override public float getFloat(ByteBuffer buf, int position) { return delegate.getFloat(buf, position); }
@Override public float getFloat(ByteBuffer buf, int position) { if (buf.get(position) == NullHandling.IS_NULL_BYTE) { throw new IllegalStateException("Cannot return float for Null Value"); } return delegate.getFloat(buf, position + Byte.BYTES); }