private void evaluateTimestamp(VectorizedRowBatch vrg) { TimestampColumnVector dcv = (TimestampColumnVector) vrg.cols[outputColumnNum]; dcv.isRepeating = true; if (!isNullValue) { dcv.isNull[0] = false; dcv.set(0, timestampValue); } else { dcv.isNull[0] = true; dcv.noNulls = false; } }
@Override protected long getTimestampField(TimestampColumnVector timestampColVector, int elementNum) { return timestampColVector.asScratchTimestamp(elementNum).getTime() / 1000; }
private void iterateSelectionNoNulls( Aggregation myagg, TimestampColumnVector inputColVector, int batchSize, int[] selected) { for (int i=0; i< batchSize; ++i) { myagg.sum += inputColVector.getDouble(selected[i]); myagg.count += 1; } }
private TimestampColumnVector toTimestamp(LongColumnVector date) { TimestampColumnVector vector = new TimestampColumnVector(size); for (int i = 0; i < size; i++) { if (date.isNull[i]) { vector.isNull[i] = true; vector.noNulls = false; } else { vector.set(i, toTimestamp(date.vector[i])); } } return vector; }
@Test public void testDouble() throws Exception { Random r = new Random(1234); TimestampColumnVector timestampColVector = new TimestampColumnVector(); Timestamp[] randTimestamps = new Timestamp[VectorizedRowBatch.DEFAULT_SIZE]; for (int i = 0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { Timestamp randTimestamp = RandomTypeUtil.getRandTimestamp(r).toSqlTimestamp(); randTimestamps[i] = randTimestamp; timestampColVector.set(i, randTimestamp); } for (int i = 0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { Timestamp retrievedTimestamp = timestampColVector.asScratchTimestamp(i); Timestamp randTimestamp = randTimestamps[i]; if (!retrievedTimestamp.equals(randTimestamp)) { assertTrue(false); } double randDouble = TimestampUtils.getDouble(randTimestamp); double retrievedDouble = timestampColVector.getDouble(i); if (randDouble != retrievedDouble) { assertTrue(false); } } } }
public static TimestampColumnVector generateTimestampColumnVector( boolean nulls, boolean repeating, int size, Random rand, Timestamp[] timestampValues) { TimestampColumnVector tcv = new TimestampColumnVector(size); tcv.noNulls = !nulls; tcv.isRepeating = repeating; Timestamp repeatingTimestamp = RandomTypeUtil.getRandTimestamp(rand).toSqlTimestamp(); int nullFrequency = generateNullFrequency(rand); for(int i = 0; i < size; i++) { if(nulls && (repeating || i % nullFrequency == 0)) { tcv.isNull[i] = true; tcv.setNullValue(i); timestampValues[i] = null; }else { tcv.isNull[i] = false; if (!repeating) { Timestamp randomTimestamp = RandomTypeUtil.getRandTimestamp(rand).toSqlTimestamp(); tcv.set(i, randomTimestamp); timestampValues[i] = randomTimestamp; } else { tcv.set(i, repeatingTimestamp); timestampValues[i] = repeatingTimestamp; } } } return tcv; }
public static VectorizedRowBatch getVectorizedRowBatchDateInTimestampOut(int[] intValues) { Random r = new Random(12099); VectorizedRowBatch batch = new VectorizedRowBatch(2); LongColumnVector inV; TimestampColumnVector outV; inV = new LongColumnVector(); outV = new TimestampColumnVector(); for (int i = 0; i < intValues.length; i++) { intValues[i] = r.nextInt() % DAYS_LIMIT; inV.vector[i] = intValues[i]; } batch.cols[0] = inV; batch.cols[1] = outV; batch.size = intValues.length; return batch; }
batch.selectedInUse = false; batch.size = 10; TimestampColumnVector timestampColVector = new TimestampColumnVector(batch.DEFAULT_SIZE);; batch.cols[0] = timestampColVector; timestampColVector.reset(); scratch.setTime(ts0.getTime()); scratch.setNanos(ts0.getNanos()); timestampColVector.set(1, scratch); Timestamp ts1 = new Timestamp(33222); scratch.setTime(ts1.getTime()); scratch.setNanos(ts1.getNanos()); timestampColVector.set(2, scratch); batch.size = 3;
public LongColGreaterTimestampScalar(int colNum, Timestamp value, int outputColumnNum) { super(outputColumnNum); this.colNum = colNum; this.value = TimestampColumnVector.getTimestampAsLong(value); }
private void evaluate(TimestampColumnVector outputColVector, BytesColumnVector inputColVector, int i) { try { org.apache.hadoop.hive.common.type.Timestamp timestamp = PrimitiveObjectInspectorUtils.getTimestampFromString( new String( inputColVector.vector[i], inputColVector.start[i], inputColVector.length[i], "UTF-8")); outputColVector.set(i, timestamp.toSqlTimestamp()); } catch (Exception e) { outputColVector.setNullValue(i); outputColVector.isNull[i] = true; outputColVector.noNulls = false; } }
@Override protected void func(LongColumnVector outV, TimestampColumnVector inV, int i) { outV.vector[i] = DateWritableV2.millisToDays(inV.getTime(i)); } }
/** * Set the data value for all NULL entries to the designated NULL_VALUE. */ public static void setNullDataEntriesTimestamp( TimestampColumnVector v, boolean selectedInUse, int[] sel, int n) { if (v.noNulls) { return; } else if (v.isRepeating && v.isNull[0]) { v.setNullValue(0); } else if (selectedInUse) { for (int j = 0; j != n; j++) { int i = sel[j]; if(v.isNull[i]) { v.setNullValue(i); } } } else { for (int i = 0; i != n; i++) { if(v.isNull[i]) { v.setNullValue(i); } } } }
/** * Input array is used to fill the entire size of the vector row batch */ private VectorizedRowBatch getVectorizedRowBatchTimestampLong(Timestamp[] inputs, int size) { VectorizedRowBatch batch = new VectorizedRowBatch(2, size); TimestampColumnVector tcv = new TimestampColumnVector(size); for (int i = 0; i < size; i++) { tcv.set(i, inputs[i % inputs.length]); } batch.cols[0] = tcv; batch.cols[1] = new LongColumnVector(size); batch.size = size; return batch; }
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; }
public LongColLessEqualTimestampScalar(int colNum, Timestamp value, int outputColumnNum) { super(outputColumnNum); this.colNum = colNum; this.value = TimestampColumnVector.getTimestampAsLong(value); }
protected long evaluateTimestamp(ColumnVector columnVector, int index, long numDays) { TimestampColumnVector tcv = (TimestampColumnVector) columnVector; // Convert to date value (in days) long days = DateWritableV2.millisToDays(tcv.getTime(index)); if (isPositive) { days += numDays; } else { days -= numDays; } return days; }
/** * Set the data value for all NULL entries to the designated NULL_VALUE. */ public static void setNullDataEntriesTimestamp( TimestampColumnVector v, boolean selectedInUse, int[] sel, int n) { if (v.noNulls) { return; } else if (v.isRepeating && v.isNull[0]) { v.setNullValue(0); } else if (selectedInUse) { for (int j = 0; j != n; j++) { int i = sel[j]; if(v.isNull[i]) { v.setNullValue(i); } } } else { for (int i = 0; i != n; i++) { if(v.isNull[i]) { v.setNullValue(i); } } } }
private VectorizedRowBatch getVectorizedRandomRowBatchTimestampLong(int seed, int size) { VectorizedRowBatch batch = new VectorizedRowBatch(2, size); TimestampColumnVector tcv = new TimestampColumnVector(size); Random rand = new Random(seed); for (int i = 0; i < size; i++) { tcv.set(i, RandomTypeUtil.getRandTimestamp(rand).toSqlTimestamp()); } batch.cols[0] = tcv; batch.cols[1] = new LongColumnVector(size); batch.size = size; return batch; }