@Override public int encodedLength(T val) { // default implementation based on existing PDataType methods. return getByteSize(); }
public static int estimateSize(int size, PDataType baseType) { if (baseType.isFixedWidth()) { return baseType.getByteSize() * size; } else { return size * ValueSchema.ESTIMATED_VARIABLE_LENGTH_SIZE; } }
private Integer getMaxLength(Expression expression) { PDataType type = expression.getDataType(); if (type.isFixedWidth() && type.getByteSize() != null) { return type.getByteSize(); } return expression.getMaxLength(); }
/** * Estimate the byte size from the type length. For example, for char, byte size would be the same as length. For * decimal, byte size would have no correlation with the length. */ public Integer estimateByteSizeFromLength(Integer length) { if (isFixedWidth()) { return getByteSize(); } if (isArrayType()) { return null; } // If not fixed width, default to say the byte size is the same as length. return length; }
@Override public int getSize() { return super.getSize() + SizedUtil.BIG_DECIMAL_SIZE + SizedUtil.ARRAY_SIZE + getDataType().getByteSize(); } }
@Override public int skip(PositionedByteRange pbr) { // default implementation based on existing PDataType methods. int len = getByteSize(); pbr.setPosition(pbr.getPosition() + len); return len; }
@Override public int getSize() { return super.getSize() + SizedUtil.LONG_SIZE + SizedUtil.ARRAY_SIZE + getDataType().getByteSize(); }
@Override public int getSize() { return super.getSize() + SizedUtil.LONG_SIZE + SizedUtil.ARRAY_SIZE + getDataType().getByteSize(); }
public PhoenixArray(PhoenixArray pArr, Integer desiredMaxLength) { this.baseType = pArr.baseType; Object[] elements = (Object[])pArr.array; if (baseType.isFixedWidth()) { if (baseType.getByteSize() == null) { elements = coerceToNewLength(baseType, (Object[])pArr.array, desiredMaxLength); maxLength = desiredMaxLength; } } this.array = convertObjectArrayToPrimitiveArray(elements); this.numElements = elements.length; }
@Override public byte[] getViewConstant() { PDataType dataType = autoPartitionCol.getDataType(); Object val = dataType.toObject(autoPartitionNum, PLong.INSTANCE); byte[] bytes = new byte [dataType.getByteSize() + 1]; dataType.toBytes(val, bytes, 0); return bytes; } @Override
private Field(PDatum datum, boolean isNullable, int count, SortOrder sortOrder) { Preconditions.checkNotNull(sortOrder); this.type = datum.getDataType(); this.sortOrder = sortOrder; this.count = count; this.isNullable = isNullable; if (this.type != null && this.type.isFixedWidth() && this.type.getByteSize() == null) { if (datum.getMaxLength() != null) { this.byteSize = datum.getMaxLength(); } } }
@Override public void aggregate(Tuple tuple, ImmutableBytesWritable ptr) { BigDecimal value = (BigDecimal)getDataType().toObject(ptr, getInputDataType(), sortOrder); sum = sum.add(value); if (sumBuffer == null) { sumBuffer = new byte[getDataType().getByteSize()]; } }
@SuppressWarnings("unchecked") @Override public T decode(PositionedByteRange pbr) { // default implementation based on existing PDataType methods. byte[] b = new byte[getByteSize()]; pbr.get(b); return (T)toObject(b, 0, b.length, this, SortOrder.ASC, getMaxLength(null), getScale(null)); }
public static int getFixedByteSize(PDatum e) { assert(e.getDataType().isFixedWidth()); Integer maxLength = e.getMaxLength(); return maxLength == null ? e.getDataType().getByteSize() : maxLength; }
@Override public Integer getMaxLength() { return getElementExpr().getDataType().getByteSize() == null ? getElementExpr().getMaxLength() : null; }
@Override public void write(DataOutput output) throws IOException { WritableUtils.writeVInt(output, (type.ordinal() + 1) * (this.isNullable ? -1 : 1)); WritableUtils.writeVInt(output, count * (sortOrder == SortOrder.ASC ? 1 : -1)); if (type.isFixedWidth() && type.getByteSize() == null) { WritableUtils.writeVInt(output, byteSize); } } }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { if (buffer == null) { buffer = new byte[getDataType().getByteSize()]; } getDataType().getCodec().encodeLong(count, buffer, 0); ptr.set(buffer); return true; }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { PDataType returnType = getDataType(); Expression arg1Expr = children.get(0); if (!arg1Expr.evaluate(tuple, ptr)) return false; if (ptr.getLength() == 0) return true; double arg1 = getArg(arg1Expr, ptr); ptr.set(new byte[returnType.getByteSize()]); returnType.getCodec().encodeDouble(compute(arg1), ptr); return true; }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { Expression childExpr = children.get(0); PDataType dataType = childExpr.getDataType(); if (childExpr.evaluate(tuple, ptr)) { byte[] bytes = ptr.get(); int offset = ptr.getOffset(), length = ptr.getLength(); ptr.set(new byte[getDataType().getByteSize()]); ((PNumericType) dataType).abs(bytes, offset, length, childExpr.getSortOrder(), ptr); return true; } return false; }
public static int getArrayLength(ImmutableBytesWritable ptr, PDataType baseType, Integer maxLength) { byte[] bytes = ptr.get(); if (ptr.getLength() == 0) { return 0; } if (baseType.isFixedWidth()) { int elemLength = maxLength == null ? baseType.getByteSize() : maxLength; return (ptr.getLength() / elemLength); } // In case where the number of elements is greater than SHORT.MAX_VALUE we do negate the number of // elements. So it is always better to return the absolute value return (Bytes.toInt(bytes, (ptr.getOffset() + ptr.getLength() - (Bytes.SIZEOF_BYTE + Bytes.SIZEOF_INT)))); }