private void evaluateDecimal(ColumnVector colVector) { DecimalColumnVector dcv = (DecimalColumnVector) colVector; dcv.isRepeating = true; if (!isNullValue) { dcv.isNull[0] = false; dcv.set(0, decimalValue); } else { dcv.isNull[0] = true; dcv.noNulls = false; } }
resultCV = new DecimalColumnVector(length, ((DecimalColumnVector) child).precision, ((DecimalColumnVector) child).scale); System.arraycopy(((DecimalColumnVector) lcv.child).vector, start,
/** * Follow the convention that null decimal values are internally set to the smallest * positive value available. Prevents accidental zero-divide later in expression * evaluation. */ public static void setNullDataEntriesDecimal( DecimalColumnVector v, boolean selectedInUse, int[] sel, int n) { if (v.noNulls) { return; } else if (v.isRepeating && v.isNull[0]) { v.setNullDataValue(0); } else if (selectedInUse) { for (int j = 0; j != n; j++) { int i = sel[j]; if(v.isNull[i]) { v.setNullDataValue(i); } } } else { for (int i = 0; i != n; i++) { if(v.isNull[i]) { v.setNullDataValue(i); } } } }
arg2ColVector.copySelected(batch.selectedInUse, sel, n, outputColVector); } else { outputColVector.fill(arg3Scalar); arg2ColVector.flatten(batch.selectedInUse, sel, n); if (!arg2IsNull[i]) { outputIsNull[i] = false; outputColVector.set(i, vector2[i]); } else { outputIsNull[i] = true; outputColVector.set(i, arg3Scalar); if (!arg2IsNull[i]) { outputIsNull[i] = false; outputColVector.set(i, vector2[i]); } else { outputIsNull[i] = true; outputColVector.set(i, arg3Scalar); if (!arg2IsNull[i]) { outputIsNull[i] = false; outputColVector.set(i, vector2[i]); } else { outputIsNull[i] = true; outputColVector.set(i, arg3Scalar);
outputColVector.fill(arg2Scalar); } else { outputColVector.fill(arg3Scalar); outputColVector.set(i, vector1[i] == 1 ? arg2Scalar : arg3Scalar); outputColVector.set(i, vector1[i] == 1 ? arg2Scalar : arg3Scalar); outputColVector.set(i, vector1[i] == 1 ? arg2Scalar : arg3Scalar); int i = sel[j]; outputIsNull[i] = false; outputColVector.set(i, !arg1ColVector.isNull[i] && vector1[i] == 1 ? arg2Scalar : arg3Scalar); Arrays.fill(outputIsNull, 0, n, false); for(int i = 0; i != n; i++) { outputColVector.set(i, !arg1ColVector.isNull[i] && vector1[i] == 1 ? arg2Scalar : arg3Scalar);
private VectorizedRowBatch getBatchDecimalTimestamp(double[] doubleValues) { VectorizedRowBatch b = new VectorizedRowBatch(2); DecimalColumnVector dv; b.cols[0] = dv = new DecimalColumnVector(doubleValues.length, HiveDecimal.SYSTEM_DEFAULT_PRECISION, HiveDecimal.SYSTEM_DEFAULT_SCALE); b.cols[1] = new TimestampColumnVector(doubleValues.length); dv.noNulls = true; Random r = new Random(94830); for (int i = 0; i < doubleValues.length; i++) { long millis = RandomTypeUtil.randomMillis(r); Timestamp ts = new Timestamp(millis); int nanos = RandomTypeUtil.randomNanos(r); ts.setNanos(nanos); TimestampWritableV2 tsw = new TimestampWritableV2( org.apache.hadoop.hive.common.type.Timestamp.ofEpochMilli(ts.getTime(), ts.getNanos())); double asDouble = tsw.getDouble(); doubleValues[i] = asDouble; HiveDecimal hiveDecimal = HiveDecimal.create(new BigDecimal(asDouble)); dv.set(i, hiveDecimal); } b.size = doubleValues.length; return b; }
dv.isRepeating = true; } else { dv.fill((HiveDecimal) value);
final DecimalColumnVector result; if (previousVector == null) { result = new DecimalColumnVector(precision, scale); } else { result = (DecimalColumnVector) previousVector; HiveDecimal dec = HiveDecimal.create(bInt, scaleInData); dec = HiveDecimalUtils.enforcePrecisionScale(dec, precision, scale); result.set(0, dec); HiveDecimal dec = HiveDecimal.create(bInt, scaleInData); dec = HiveDecimalUtils.enforcePrecisionScale(dec, precision, scale); result.set(i, dec);
outputColVector.fill(arg2Scalar); } else { arg3ColVector.copySelected(batch.selectedInUse, sel, n, outputColVector); arg3ColVector.flatten(batch.selectedInUse, sel, n); if (vector1[i] == 1) { outputIsNull[i] = false; outputColVector.set(i, arg2Scalar); } else { if (!arg3IsNull[i]) { outputIsNull[i] = false; outputColVector.set(i, vector3[i]); } else { outputIsNull[i] = true; if (vector1[i] == 1) { outputIsNull[i] = false; outputColVector.set(i, arg2Scalar); } else { if (!arg3IsNull[i]) { outputIsNull[i] = false; outputColVector.set(i, vector3[i]); } else { outputIsNull[i] = true; if (!arg1ColVector.isNull[i] && vector1[i] == 1) { outputIsNull[i] = false; outputColVector.set(i, arg2Scalar);
private void evaluateDecimal(VectorizedRowBatch vrg) { DecimalColumnVector dcv = (DecimalColumnVector) vrg.cols[outputColumnNum]; dcv.isRepeating = true; if (!isNullValue) { dcv.isNull[0] = false; dcv.set(0, decimalValue); } else { dcv.isNull[0] = true; dcv.noNulls = false; } }
private VectorizedRowBatch getBatchDoubleDecimal() { VectorizedRowBatch b = new VectorizedRowBatch(2); DoubleColumnVector dv; short scale = 2; b.cols[0] = dv = new DoubleColumnVector(); b.cols[1] = new DecimalColumnVector(18, scale); b.size = 3; dv.vector[0] = 0d; dv.vector[1] = -1d; dv.vector[2] = 99999999999999.0d; return b; }
arg2ColVector.copySelected(batch.selectedInUse, sel, n, outputColVector); } else { arg3ColVector.copySelected(batch.selectedInUse, sel, n, outputColVector); arg2ColVector.flatten(batch.selectedInUse, sel, n); arg3ColVector.flatten(batch.selectedInUse, sel, n); if (!arg2IsNull[i]) { outputIsNull[i] = false; outputColVector.set(i, vector2[i]); } else { outputIsNull[i] = true; if (!arg3IsNull[i]) { outputIsNull[i] = false; outputColVector.set(i, vector3[i]); } else { outputIsNull[i] = true; if (!arg2IsNull[i]) { outputIsNull[i] = false; outputColVector.set(i, vector2[i]); } else { outputIsNull[i] = true; if (!arg3IsNull[i]) { outputIsNull[i] = false; outputColVector.set(i, vector3[i]); } else {
/** * Follow the convention that null decimal values are internally set to the smallest * positive value available. Prevents accidental zero-divide later in expression * evaluation. */ public static void setNullDataEntriesDecimal( DecimalColumnVector v, boolean selectedInUse, int[] sel, int n) { if (v.noNulls) { return; } else if (v.isRepeating && v.isNull[0]) { v.setNullDataValue(0); } else if (selectedInUse) { for (int j = 0; j != n; j++) { int i = sel[j]; if(v.isNull[i]) { v.setNullDataValue(i); } } } else { for (int i = 0; i != n; i++) { if(v.isNull[i]) { v.setNullDataValue(i); } } } }
/** * Convert input decimal value to a decimal with a possibly different precision and scale, * at position i in the respective vectors. */ protected void convert(DecimalColumnVector outputColVector, DecimalColumnVector inputColVector, int i) { // The set routine enforces precision and scale. outputColVector.set(i, inputColVector.vector[i]); }
private VectorizedRowBatch getBatchLongDecimal() { VectorizedRowBatch b = new VectorizedRowBatch(2); LongColumnVector lv; b.cols[0] = lv = new LongColumnVector(); b.cols[1] = new DecimalColumnVector(18, 2); lv.vector[0] = 0; lv.vector[1] = -1; lv.vector[2] = 99999999999999L; return b; }
/** * Follow the convention that null decimal values are internally set to the smallest * positive value available. Prevents accidental zero-divide later in expression * evaluation. */ public static void setNullDataEntriesDecimal( DecimalColumnVector v, boolean selectedInUse, int[] sel, int n) { if (v.noNulls) { return; } else if (v.isRepeating && v.isNull[0]) { v.setNullDataValue(0); } else if (selectedInUse) { for (int j = 0; j != n; j++) { int i = sel[j]; if(v.isNull[i]) { v.setNullDataValue(i); } } } else { for (int i = 0; i != n; i++) { if(v.isNull[i]) { v.setNullDataValue(i); } } } }
protected void assignDecimal(HiveDecimal value, int index) { outCol.set(index, value); } protected void assignDecimal(HiveDecimalWritable hdw, int index) {
int precision = type.asPrimitiveType().getDecimalMetadata().getPrecision(); int scale = type.asPrimitiveType().getDecimalMetadata().getScale(); lcv.child = new DecimalColumnVector(total, precision, scale); for (int i = 0; i < valueList.size(); i++) { ((DecimalColumnVector) lcv.child).vector[i].set(((List<byte[]>) valueList).get(i), scale);
protected void assignDecimal(HiveDecimalWritable hdw, int index) { outCol.set(index, hdw); } }
/** * This batch has output decimal column precision 5 and scale 2. * The goal is to allow testing of input long values that, when * converted to decimal, will not fit in the given precision. * Then it will be possible to check that the results are NULL. */ private VectorizedRowBatch getBatchLongDecimalPrec5Scale2() { VectorizedRowBatch b = new VectorizedRowBatch(2); LongColumnVector lv; b.cols[0] = lv = new LongColumnVector(); b.cols[1] = new DecimalColumnVector(5, 2); lv.vector[0] = 0; lv.vector[1] = -1; lv.vector[2] = 99999999999999L; return b; }