@Deprecated /** * @deprecated Use @link{fromReusedByteArray} or @link{fromConstantByteArray} instead */ public static Binary fromByteArray(final byte[] value) { return fromReusedByteArray(value); // Assume producer intends to reuse byte[] }
@Deprecated /** * @deprecated Use @link{fromReusedByteArray} or @link{fromConstantByteArray} instead */ public static Binary fromByteArray(final byte[] value, final int offset, final int length) { return fromReusedByteArray(value, offset, length); // Assume producer intends to reuse byte[] }
@Deprecated /** * @deprecated Use @link{fromReusedByteArray} or @link{fromConstantByteArray} instead */ public static Binary fromByteArray(final byte[] value, final int offset, final int length) { return fromReusedByteArray(value, offset, length); // Assume producer intends to reuse byte[] }
@Deprecated /** * @deprecated Use @link{fromReusedByteArray} or @link{fromConstantByteArray} instead */ public static Binary fromByteArray(final byte[] value) { return fromReusedByteArray(value); // Assume producer intends to reuse byte[] }
/** * Sets min and max values, re-uses the byte[] passed in. * Any changes made to byte[] will be reflected in min and max values as well. * @param minBytes byte array to set the min value to * @param maxBytes byte array to set the max value to */ @Override public void setMinMaxFromBytes(byte[] minBytes, byte[] maxBytes) { max = Binary.fromReusedByteArray(maxBytes); min = Binary.fromReusedByteArray(minBytes); this.markAsNotEmpty(); }
/** * Sets min and max values, re-uses the byte[] passed in. * Any changes made to byte[] will be reflected in min and max values as well. * @param minBytes byte array to set the min value to * @param maxBytes byte array to set the max value to */ @Override public void setMinMaxFromBytes(byte[] minBytes, byte[] maxBytes) { max = Binary.fromReusedByteArray(maxBytes); min = Binary.fromReusedByteArray(minBytes); this.markAsNotEmpty(); }
@Override public void write(int repetitionLevel, byte[] value) { column.writeBinary(repetitionLevel, Binary.fromReusedByteArray(value)); } }
@Override public Binary slice(int start, int length) { if (isBackingBytesReused) { return Binary.fromReusedByteArray(value, offset + start, length); } else { return Binary.fromConstantByteArray(value, offset + start, length); } }
@Override public Binary slice(int start, int length) { if (isBackingBytesReused) { return Binary.fromReusedByteArray(value, start, length); } else { return Binary.fromConstantByteArray(value, start, length); } }
@Override public Binary slice(int start, int length) { if (isBackingBytesReused) { return Binary.fromReusedByteArray(value, offset + start, length); } else { return Binary.fromConstantByteArray(value, offset + start, length); } }
@Override public Binary slice(int start, int length) { if (isBackingBytesReused) { return Binary.fromReusedByteArray(value, start, length); } else { return Binary.fromConstantByteArray(value, start, length); } }
private void writeBinaryToRecordConsumer(ByteBuffer buf) { recordConsumer.addBinary(Binary.fromReusedByteArray(buf.array(), buf.position(), buf.limit() - buf.position())); }
@Override public void write(int repetitionLevel, BigDecimal decimal) { Preconditions.checkArgument(decimal.scale() == scale, "Cannot write value as decimal(%s,%s), wrong scale: %s", precision, scale, decimal); Preconditions.checkArgument(decimal.precision() <= precision, "Cannot write value as decimal(%s,%s), too large: %s", precision, scale, decimal); byte fillByte = (byte) (decimal.signum() < 0 ? 0xFF : 0x00); byte[] unscaled = decimal.unscaledValue().toByteArray(); byte[] buf = bytes.get(); int offset = length - unscaled.length; for (int i = 0; i < length; i += 1) { if (i < offset) { buf[i] = fillByte; } else { buf[i] = unscaled[i - offset]; } } column.writeBinary(repetitionLevel, Binary.fromReusedByteArray(buf)); } }
@Override public void write(int repetitionLevel, Fixed buffer) { column.writeBinary(repetitionLevel, Binary.fromReusedByteArray(buffer.bytes())); } }
CarbonDictionaryWrapper(Encoding encoding, CarbonDictionary dictionary) { super(encoding); binaries = new Binary[dictionary.getDictionarySize()]; for (int i = 0; i < binaries.length; i++) { binaries[i] = Binary.fromReusedByteArray(dictionary.getDictionaryValue(i)); } }
private Binary fromAvroString(Object value) { if (value instanceof Utf8) { Utf8 utf8 = (Utf8) value; return Binary.fromReusedByteArray(utf8.getBytes(), 0, utf8.getByteLength()); } return Binary.fromCharSequence((CharSequence) value); }
@Override public void write(BaseRow row, int ordinal) { recordConsumer.addBinary( Binary.fromReusedByteArray(row.getBinaryString(ordinal).getBytes())); } }
@Override public void writeValue(RecordConsumer consumer, DrillBuf buffer, int start, int end, int precision) { int typeLength = DecimalUtility.getMaxBytesSizeForPrecision(precision); int length = end - start; int startPos = typeLength - length; byte[] output = new byte[typeLength]; if (startPos >= 0) { buffer.getBytes(start, output, startPos, length); if (output[startPos] < 0) { Arrays.fill(output, 0, output.length - length, (byte) -1); } } else { // in this case value from FIXED_LEN_BYTE_ARRAY or BINARY field with greater length was taken, ignore leading bytes buffer.getBytes(start - startPos, output, 0, length + startPos); } consumer.addBinary(Binary.fromReusedByteArray(output)); } }
@Override public void write(int repetitionLevel, CharSequence value) { if (value instanceof Utf8) { Utf8 utf8 = (Utf8) value; column.writeBinary(repetitionLevel, Binary.fromReusedByteArray(utf8.getBytes(), 0, utf8.getByteLength())); } else { column.writeBinary(repetitionLevel, Binary.fromString(value.toString())); } } }
private void writePrimitive(final Object object) throws SerialisationException { if (object instanceof String) { recordConsumer.addBinary(Binary.fromString((String) object)); } else if (object instanceof byte[]) { recordConsumer.addBinary(Binary.fromReusedByteArray((byte[]) object)); } else if (object instanceof Long) { recordConsumer.addLong((long) object); } else if (object instanceof Integer) { recordConsumer.addInteger((int) object); } else if (object instanceof Float) { recordConsumer.addFloat((float) object); } else if (object instanceof Double) { recordConsumer.addDouble((double) object); } else if (object instanceof Boolean) { recordConsumer.addBoolean((boolean) object); } else { throw new SerialisationException(object.getClass().getCanonicalName() + " is not a supported primitive type"); } } }