public static VectorizedRowBatch getVectorizedRowBatchDoubleInDoubleOut() { VectorizedRowBatch batch = new VectorizedRowBatch(2); DoubleColumnVector inV; DoubleColumnVector outV; outV = new DoubleColumnVector(); inV = new DoubleColumnVector(); inV.vector[0] = -1.5d; inV.vector[1] = -0.5d; inV.vector[2] = -0.1d; inV.vector[3] = 0d; inV.vector[4] = 0.5d; inV.vector[5] = 0.7d; inV.vector[6] = 1.5d; inV.vector[7] = 1.2345678d; batch.cols[0] = inV; batch.cols[1] = outV; batch.size = 8; return batch; }
resultCV = new DoubleColumnVector(length); System.arraycopy(((DoubleColumnVector) lcv.child).vector, start, ((DoubleColumnVector) resultCV).vector, 0, length);
private VectorizedRowBatch getBatch1Long3DoubleVectors() { VectorizedRowBatch batch = new VectorizedRowBatch(4); LongColumnVector lv = new LongColumnVector(); // set first argument to IF -- boolean flag lv.vector[0] = 0; lv.vector[1] = 0; lv.vector[2] = 1; lv.vector[3] = 1; batch.cols[0] = lv; // set second argument to IF DoubleColumnVector v = new DoubleColumnVector(); v.vector[0] = -1; v.vector[1] = -2; v.vector[2] = -3; v.vector[3] = -4; batch.cols[1] = v; // set third argument to IF v = new DoubleColumnVector(); v.vector[0] = 1; v.vector[1] = 2; v.vector[2] = 3; v.vector[3] = 4; batch.cols[2] = v; // set output column batch.cols[3] = new DoubleColumnVector(); batch.size = 4; return batch; }
public static DoubleColumnVector generateDoubleColumnVector(boolean nulls, boolean repeating, int size, Random rand) { DoubleColumnVector dcv = new DoubleColumnVector(size); dcv.noNulls = !nulls; dcv.isRepeating = repeating; double repeatingValue; do{ repeatingValue= rand.nextDouble(); }while(repeatingValue == 0); int nullFrequency = generateNullFrequency(rand); for(int i = 0; i < size; i++) { if(nulls && (repeating || i % nullFrequency == 0)) { dcv.isNull[i] = true; dcv.vector[i] = DOUBLE_VECTOR_NULL_VALUE; }else { dcv.isNull[i] = false; dcv.vector[i] = repeating ? repeatingValue : rand.nextDouble(); if(dcv.vector[i] == 0) { i--; } } } return dcv; }
public static VectorizedRowBatch getVectorizedRowBatchTimestampInDoubleOut(double[] doubleValues) { Random r = new Random(45993); VectorizedRowBatch batch = new VectorizedRowBatch(2); TimestampColumnVector tcv; DoubleColumnVector dcv; tcv = new TimestampColumnVector(doubleValues.length); dcv = new DoubleColumnVector(doubleValues.length); for (int i = 0; i < doubleValues.length; i++) { doubleValues[i] = r.nextDouble() % (double) SECONDS_LIMIT; dcv.vector[i] = doubleValues[i]; } batch.cols[0] = tcv; batch.cols[1] = dcv; batch.size = doubleValues.length; return batch; }
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; }
public static VectorizedRowBatch getVectorizedRowBatchLongInDoubleOut() { VectorizedRowBatch batch = new VectorizedRowBatch(2); LongColumnVector lcv; DoubleColumnVector dcv; lcv = new LongColumnVector(); dcv = new DoubleColumnVector(); lcv.vector[0] = -2; lcv.vector[1] = -1; lcv.vector[2] = 0; lcv.vector[3] = 1; lcv.vector[4] = 2; batch.cols[0] = lcv; batch.cols[1] = dcv; batch.size = 5; return batch; }
public static VectorizedRowBatch getVectorizedRowBatchDoubleInLongOut() { VectorizedRowBatch batch = new VectorizedRowBatch(2); LongColumnVector lcv; DoubleColumnVector dcv; lcv = new LongColumnVector(); dcv = new DoubleColumnVector(); dcv.vector[0] = -1.5d; dcv.vector[1] = -0.5d; dcv.vector[2] = -0.1d; dcv.vector[3] = 0d; dcv.vector[4] = 0.5d; dcv.vector[5] = 0.7d; dcv.vector[6] = 1.5d; batch.cols[0] = dcv; batch.cols[1] = lcv; batch.size = 7; return batch; }
public static VectorizedRowBatch getVectorizedRowBatchDoubleInTimestampOut() { VectorizedRowBatch batch = new VectorizedRowBatch(2); TimestampColumnVector tcv; DoubleColumnVector dcv; tcv = new TimestampColumnVector(); dcv = new DoubleColumnVector(); dcv.vector[0] = -1.5d; dcv.vector[1] = -0.5d; dcv.vector[2] = -0.1d; dcv.vector[3] = 0d; dcv.vector[4] = 0.5d; dcv.vector[5] = 0.7d; dcv.vector[6] = 1.5d; batch.cols[0] = dcv; batch.cols[1] = tcv; batch.size = 7; return batch; }
public static VectorizedRowBatch getVectorizedRowBatch2LongInDoubleOut() { VectorizedRowBatch batch = new VectorizedRowBatch(3); LongColumnVector lcv, lcv2; lcv = new LongColumnVector(); for (int i = 0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { lcv.vector[i] = i * 37; } batch.cols[0] = lcv; lcv2 = new LongColumnVector(); batch.cols[1] = lcv2; for (int i = 0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { lcv2.vector[i] = i * 37; } batch.cols[2] = new DoubleColumnVector(); batch.size = VectorizedRowBatch.DEFAULT_SIZE; return batch; }
@Test public void testVectorRand() throws HiveException { VectorizedRowBatch b = new VectorizedRowBatch(1); DoubleColumnVector v = new DoubleColumnVector(); b.cols[0] = v; b.size = VectorizedRowBatch.DEFAULT_SIZE;
private VectorizedRowBatch makeBatch() { VectorizedRowBatch batch = new VectorizedRowBatch(3); LongColumnVector lv = new LongColumnVector(); DoubleColumnVector dv = new DoubleColumnVector(); BytesColumnVector bv = new BytesColumnVector(); setSampleStringCol(bv); batch.cols[0] = lv; batch.cols[1] = dv; batch.cols[2] = bv; addRandomNulls(batch); return batch; }
@Test public void testFlatten() { verifyFlatten(new LongColumnVector()); verifyFlatten(new DoubleColumnVector()); verifyFlatten(new BytesColumnVector()); }
return new LongColumnVector(((LongColumnVector) source).vector.length); } else if (source instanceof DoubleColumnVector) { return new DoubleColumnVector(((DoubleColumnVector) source).vector.length); } else if (source instanceof BytesColumnVector) { return new BytesColumnVector(((BytesColumnVector) source).vector.length);
private VectorizedRowBatch getBatchDecimalDouble() { VectorizedRowBatch b = new VectorizedRowBatch(2); DecimalColumnVector dv; short scale = 2; b.cols[0] = dv = new DecimalColumnVector(18, scale); b.cols[1] = new DoubleColumnVector(); b.size = 3; dv.vector[0].set(HiveDecimal.create("1.1")); dv.vector[1].set(HiveDecimal.create("-2.2")); dv.vector[2].set(HiveDecimal.create("9999999999999999.00")); return b; }
@Test public void testFilterDoubleNotBetween() throws HiveException { // Spot check only. null & repeating behavior are checked elsewhere for the same template. int seed = 17; VectorizedRowBatch vrb = VectorizedRowGroupGenUtil.getVectorizedRowBatch( 5, 2, seed); vrb.cols[0] = new DoubleColumnVector(); DoubleColumnVector dcv = (DoubleColumnVector) vrb.cols[0]; //Basic case dcv.vector[0] = 5; dcv.vector[1] = 20; dcv.vector[2] = 17; dcv.vector[3] = 15; dcv.vector[4] = 10; VectorExpression expr = new FilterDoubleColumnNotBetween(0, 10, 20); expr.evaluate(vrb); assertEquals(1, vrb.size); assertTrue(vrb.selectedInUse); assertEquals(0, vrb.selected[0]); }
@Test public void testFilterDoubleBetween() throws HiveException { // Spot check only. null & repeating behavior are checked elsewhere for the same template. int seed = 17; VectorizedRowBatch vrb = VectorizedRowGroupGenUtil.getVectorizedRowBatch( 5, 2, seed); DoubleColumnVector dcv0 = new DoubleColumnVector(); vrb.cols[0] = dcv0; //Basic case dcv0.vector[0] = 5; dcv0.vector[1] = 20; dcv0.vector[2] = 17; dcv0.vector[3] = 15; dcv0.vector[4] = 10; VectorExpression expr = new FilterDoubleColumnBetween(0, 20, 21); expr.evaluate(vrb); assertEquals(1, vrb.size); assertTrue(vrb.selectedInUse); assertEquals(1, vrb.selected[0]); }
colVector = new DoubleColumnVector(); break;
private VectorizedRowBatch getBatchStrDblLongWithStrOut() { VectorizedRowBatch b = new VectorizedRowBatch(4); BytesColumnVector strCol = new BytesColumnVector(); LongColumnVector longCol = new LongColumnVector(); DoubleColumnVector dblCol = new DoubleColumnVector(); BytesColumnVector outCol = new BytesColumnVector(); b.cols[0] = strCol; b.cols[1] = longCol; b.cols[2] = dblCol; b.cols[3] = outCol; strCol.initBuffer(); strCol.setVal(0, blue, 0, blue.length); strCol.setVal(1, red, 0, red.length); longCol.vector[0] = 0; longCol.vector[1] = 1; dblCol.vector[0] = 0.0; dblCol.vector[1] = 1.0; // set one null value for possible later use longCol.isNull[1] = true; // but have no nulls initially longCol.noNulls = true; strCol.noNulls = true; dblCol.noNulls = true; outCol.initBuffer(); b.size = 2; return b; }
@Test public void testFilterDoubleIn() throws HiveException { int seed = 17; VectorizedRowBatch vrb = VectorizedRowGroupGenUtil.getVectorizedRowBatch( 5, 2, seed); DoubleColumnVector dcv0 = new DoubleColumnVector(); vrb.cols[0] = dcv0; double[] inList = {5.0, 20.2}; FilterDoubleColumnInList f = new FilterDoubleColumnInList(0); f.setInListValues(inList); f.setInputTypeInfos(new TypeInfo[] {TypeInfoFactory.doubleTypeInfo}); f.transientInit(); VectorExpression expr1 = f; // Basic sanity check. Other cases are not skipped because it is similar to the case for Long. dcv0.vector[0] = 5.0; dcv0.vector[1] = 20.2; dcv0.vector[2] = 17.0; dcv0.vector[3] = 15.0; dcv0.vector[4] = 10.0; expr1.evaluate(vrb); assertEquals(2, vrb.size); assertTrue(vrb.selectedInUse); assertEquals(0, vrb.selected[0]); assertEquals(1, vrb.selected[1]); }