public static void serializeOldHiveDecimal(ByteStream.Output buffer, HiveDecimalV1 oldDec, boolean invert) { // get the sign of the big decimal int sign = oldDec.compareTo(HiveDecimalV1.ZERO); // we'll encode the absolute value (sign is separate) oldDec = oldDec.abs(); // get the scale factor to turn big decimal into a decimal < 1 // This relies on the BigDecimal precision value, which as of HIVE-10270 // is now different from HiveDecimal.precision() int factor = oldDec.bigDecimalValue().precision() - oldDec.bigDecimalValue().scale(); factor = sign == 1 ? factor : -factor; // convert the absolute big decimal to string oldDec.scaleByPowerOfTen(Math.abs(oldDec.scale())); String digits = oldDec.unscaledValue().toString(); // finally write out the pieces (sign, scale, digits) writeByte(buffer, (byte) ( sign + 1), invert); writeByte(buffer, (byte) ((factor >> 24) ^ 0x80), invert); writeByte(buffer, (byte) ( factor >> 16), invert); writeByte(buffer, (byte) ( factor >> 8), invert); writeByte(buffer, (byte) factor, invert); serializeBytes(buffer, digits.getBytes(decimalCharSet), digits.length(), sign == -1 ? !invert : invert); }
@HiveDecimalWritableVersionV1 public HiveDecimalV1 getHiveDecimal() { return HiveDecimalV1.create(new BigInteger(internalStorage), scale); }
@HiveDecimalWritableVersionV1 @Override public String toString() { return getHiveDecimal().toString(); }
@HiveDecimalVersionV1 public static HiveDecimalV1 enforcePrecisionScale(HiveDecimalV1 dec, int maxPrecision, int maxScale) { if (dec == null) { return null; } // Minor optimization, avoiding creating new objects. if (dec.precision() - dec.scale() <= maxPrecision - maxScale && dec.scale() <= maxScale) { return dec; } BigDecimal bd = enforcePrecisionScale(dec.bd, maxPrecision, maxScale); if (bd == null) { return null; } return HiveDecimalV1.create(bd); }
@HiveDecimalVersionV1 public static HiveDecimalV1 create(BigDecimal b, boolean allowRounding) { BigDecimal bd = normalize(b, allowRounding); return bd == null ? null : new HiveDecimalV1(bd); }
/** * Get a OldHiveDecimal instance from the writable and constraint it with maximum precision/scale. * * @param maxPrecision maximum precision * @param maxScale maximum scale * @return OldHiveDecimal instance */ @HiveDecimalWritableVersionV1 public HiveDecimalV1 getHiveDecimal(int maxPrecision, int maxScale) { return HiveDecimalV1.enforcePrecisionScale(HiveDecimalV1. create(new BigInteger(internalStorage), scale), maxPrecision, maxScale); }
HiveDecimalV1 oldDec = HiveDecimalV1.create(string); assertTrue(oldDec != null); BigInteger oldBigInteger = oldDec.unscaledValue(); int oldScale = oldDec.scale();
HiveDecimalV1 oldDec = HiveDecimalV1.create(bigInteger); if (oldDec != null && isTenPowerBug(oldDec.toString())) { return; Assert.assertEquals(bigInteger, oldDec.unscaledValue()); Assert.assertEquals(bigInteger, dec.unscaledValue());
@HiveDecimalWritableVersionV1 public void set(HiveDecimalV1 value) { set(value.unscaledValue().toByteArray(), value.scale()); }
public static Timestamp decimalToTimestamp(HiveDecimalV1 dec) { try { BigDecimal nanoInstant = dec.bigDecimalValue().multiply(BILLION_BIG_DECIMAL); int nanos = nanoInstant.remainder(BILLION_BIG_DECIMAL).intValue(); if (nanos < 0) { nanos += 1000000000; } long seconds = nanoInstant.subtract(new BigDecimal(nanos)).divide(BILLION_BIG_DECIMAL).longValue(); return Timestamp.ofEpochSecond(seconds, nanos); } catch (IllegalArgumentException | DateTimeException nfe) { return null; } }
@HiveDecimalWritableVersionV1 @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || getClass() != other.getClass()) { return false; } HiveDecimalWritableV1 bdw = (HiveDecimalWritableV1) other; // 'equals' and 'compareTo' are not compatible with HiveDecimals. We want // compareTo which returns true iff the numbers are equal (e.g.: 3.14 is // the same as 3.140). 'Equals' returns true iff equal and the same scale // is set in the decimals (e.g.: 3.14 is not the same as 3.140) return getHiveDecimal().compareTo(bdw.getHiveDecimal()) == 0; }
@HiveDecimalVersionV1 public static HiveDecimalV1 create(int i) { return new HiveDecimalV1(new BigDecimal(i)); }
@HiveDecimalWritableVersionV1 public void set(HiveDecimalV1 value, int maxPrecision, int maxScale) { set(HiveDecimalV1.enforcePrecisionScale(value, maxPrecision, maxScale)); }
@HiveDecimalVersionV1 public static HiveDecimalV1 enforcePrecisionScale(HiveDecimalV1 dec, int maxPrecision, int maxScale) { if (dec == null) { return null; } // Minor optimization, avoiding creating new objects. if (dec.precision() - dec.scale() <= maxPrecision - maxScale && dec.scale() <= maxScale) { return dec; } BigDecimal bd = enforcePrecisionScale(dec.bd, maxPrecision, maxScale); if (bd == null) { return null; } return HiveDecimalV1.create(bd); }
HiveDecimalV1 oldDec = HiveDecimalV1.create(bigInteger); if (oldDec != null && isTenPowerBug(oldDec.toString())) { return; Assert.assertEquals(bigInteger, oldDec.unscaledValue()); Assert.assertEquals(bigInteger, dec.unscaledValue()); BigDecimal bigDecimal = new BigDecimal(bigInteger, scale); oldDec = HiveDecimalV1.create(bigDecimal); dec = HiveDecimal.create(bigDecimal); if (oldDec == null) {
@HiveDecimalWritableVersionV1 public void set(HiveDecimalV1 value) { set(value.unscaledValue().toByteArray(), value.scale()); }
@HiveDecimalVersionV1 public static HiveDecimalV1 create(BigInteger unscaled, int scale) { BigDecimal bd = normalize(new BigDecimal(unscaled, scale), true); return bd == null ? null : new HiveDecimalV1(bd); }
public static Timestamp decimalToTimestamp(HiveDecimalV1 dec) { try { BigDecimal nanoInstant = dec.bigDecimalValue().multiply(BILLION_BIG_DECIMAL); int nanos = nanoInstant.remainder(BILLION_BIG_DECIMAL).intValue(); if (nanos < 0) { nanos += 1000000000; } long seconds = nanoInstant.subtract(new BigDecimal(nanos)).divide(BILLION_BIG_DECIMAL).longValue(); Timestamp t = new Timestamp(seconds * 1000); t.setNanos(nanos); return t; } catch (NumberFormatException nfe) { return null; } catch (IllegalArgumentException iae) { return null; } }
/** * Get a OldHiveDecimal instance from the writable and constraint it with maximum precision/scale. * * @param maxPrecision maximum precision * @param maxScale maximum scale * @return OldHiveDecimal instance */ @HiveDecimalWritableVersionV1 public HiveDecimalV1 getHiveDecimal(int maxPrecision, int maxScale) { return HiveDecimalV1.enforcePrecisionScale(HiveDecimalV1. create(new BigInteger(internalStorage), scale), maxPrecision, maxScale); }
@HiveDecimalWritableVersionV1 @Override public int compareTo(HiveDecimalWritableV1 that) { return getHiveDecimal().compareTo(that.getHiveDecimal()); }