@Override final public void addInt(int value) { parent.add(DatumFactory.createInt2((short)value)); } }
@Override final public void addInt(int value) { parent.add(DatumFactory.createInt2((short)value)); } }
@Override final public void addInt(int value) { parent.add(DatumFactory.createInt2((short)value)); } }
private Datum convertInt(Object value, TajoDataTypes.Type tajoType) { int intValue = (Integer)value; switch (tajoType) { case BIT: return DatumFactory.createBit((byte)(intValue & 0xff)); case INT2: return DatumFactory.createInt2((short)intValue); default: return DatumFactory.createInt4(intValue); } }
private Datum convertInt(Object value, TajoDataTypes.Type tajoType) { int intValue = (Integer)value; switch (tajoType) { case BIT: return DatumFactory.createBit((byte)(intValue & 0xff)); case INT2: return DatumFactory.createInt2((short)intValue); default: return DatumFactory.createInt4(intValue); } }
private Datum convertInt(Object value, TajoDataTypes.Type tajoType) { int intValue = (Integer)value; switch (tajoType) { case BIT: return DatumFactory.createBit((byte)(intValue & 0xff)); case INT2: return DatumFactory.createInt2((short)intValue); default: return DatumFactory.createInt4(intValue); } }
@Override Datum next() throws IOException { super.next(); return valuePresent ? DatumFactory.createInt2((short) reader.next()) : NullDatum.get(); }
@Override Datum next() throws IOException { super.next(); return valuePresent ? DatumFactory.createInt2((short) reader.next()) : NullDatum.get(); }
private static Tuple makeRandomTuple(Tuple tuple) { tuple.put(new Datum[]{ DatumFactory.createInt8(random.nextLong()), DatumFactory.createInt4(random.nextInt()), DatumFactory.createInt2((short) random.nextInt(Short.MAX_VALUE)), DatumFactory.createDate(Math.abs(random.nextInt())), DatumFactory.createTimestamp(Math.abs(random.nextLong())), DatumFactory.createTime(Math.abs(random.nextLong())), DatumFactory.createFloat4(random.nextFloat()), DatumFactory.createFloat8(random.nextDouble()) }); for (int i = 0; i < 3; i++) { if (random.nextBoolean()) { tuple.put(i, tuple.asDatum(i).multiply(MINUS_ONE)); } } for (int i = 6; i < 8; i++) { if (random.nextBoolean()) { tuple.put(i, tuple.asDatum(i).multiply(MINUS_ONE)); } } return tuple; }
public Datum toDatum(int i) { if (keys[i] == null) { return NullDatum.get(); } switch (keyTypes[i]) { case NULL_TYPE: return NullDatum.get(); case BOOLEAN: return DatumFactory.createBool((Boolean) keys[i]); case BIT: return DatumFactory.createBit((Byte)keys[i]); case INT1: case INT2: return DatumFactory.createInt2((Short) keys[i]); case INT4: return DatumFactory.createInt4((Integer) keys[i]); case DATE: return DatumFactory.createDate((Integer) keys[i]); case INT8: return DatumFactory.createInt8((Long) keys[i]); case TIME: return DatumFactory.createTime((Long) keys[i]); case TIMESTAMP: return DatumFactory.createTimestamp((Long) keys[i]); case FLOAT4: return DatumFactory.createFloat4((Float) keys[i]); case FLOAT8: return DatumFactory.createFloat8((Double) keys[i]); case TEXT: return DatumFactory.createText((byte[]) keys[i]); case CHAR: return DatumFactory.createChar((byte[]) keys[i]); case BLOB: return DatumFactory.createBlob((byte[]) keys[i]); case DATUM: return (Datum)keys[i]; default: throw new IllegalArgumentException(); } } }
public Datum toDatum(int i) { if (keys[i] == null) { return NullDatum.get(); } switch (keyTypes[i]) { case NULL_TYPE: return NullDatum.get(); case BOOLEAN: return DatumFactory.createBool((Boolean) keys[i]); case BIT: return DatumFactory.createBit((Byte)keys[i]); case INT1: case INT2: return DatumFactory.createInt2((Short) keys[i]); case INT4: return DatumFactory.createInt4((Integer) keys[i]); case DATE: return DatumFactory.createDate((Integer) keys[i]); case INET4: return DatumFactory.createInet4((Integer) keys[i]); case INT8: return DatumFactory.createInt8((Long) keys[i]); case TIME: return DatumFactory.createTime((Long) keys[i]); case TIMESTAMP: return DatumFactory.createTimestamp((Long) keys[i]); case FLOAT4: return DatumFactory.createFloat4((Float) keys[i]); case FLOAT8: return DatumFactory.createFloat8((Double) keys[i]); case TEXT: return DatumFactory.createText((byte[]) keys[i]); case CHAR: return DatumFactory.createChar((byte[]) keys[i]); case BLOB: return DatumFactory.createBlob((byte[]) keys[i]); case DATUM: return (Datum)keys[i]; default: throw new IllegalArgumentException(); } } }
private static Tuple makeMinTuple(Tuple tuple) { tuple.put(new Datum[]{ DatumFactory.createInt8(Long.MIN_VALUE), DatumFactory.createInt4(Integer.MIN_VALUE), DatumFactory.createInt2(Short.MIN_VALUE), DatumFactory.createDate(0), DatumFactory.createTimestamp(0), DatumFactory.createTime(0), DatumFactory.createFloat4(Float.MIN_VALUE), DatumFactory.createFloat8(Double.MIN_VALUE) }); return tuple; }
@Test public void testPartitionForINT2Asc() { Schema schema = SchemaBuilder.builder() .add("col1", Type.INT2) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); VTuple e = new VTuple(1); s.put(0, DatumFactory.createInt2((short) 1)); e.put(0, DatumFactory.createInt2((short) 30000)); TupleRange expected = new TupleRange(sortSpecs, s, e); UniformRangePartition partitioner = new UniformRangePartition(expected, sortSpecs); int partNum = 64; TupleRange [] ranges = partitioner.partition(partNum); TupleRange prev = null; for (TupleRange r : ranges) { if (prev != null) { assertTrue(prev.compareTo(r) < 0); } prev = r; } assertEquals(partNum, ranges.length); assertTrue(ranges[0].getStart().equals(s)); assertTrue(ranges[partNum - 1].getEnd().equals(e)); }
@Test public void testPartitionForINT2Desc() { Schema schema = SchemaBuilder.builder() .add("col1", Type.INT2) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); sortSpecs[0].setDescOrder(); VTuple s = new VTuple(1); VTuple e = new VTuple(1); s.put(0, DatumFactory.createInt2((short) 30000)); e.put(0, DatumFactory.createInt2((short) 1)); TupleRange expected = new TupleRange(sortSpecs, s, e); UniformRangePartition partitioner = new UniformRangePartition(expected, sortSpecs); int partNum = 64; TupleRange [] ranges = partitioner.partition(partNum); TupleRange prev = null; for (TupleRange r : ranges) { if (prev != null) { assertTrue(prev.compareTo(r) < 0); } prev = r; } assertEquals(partNum, ranges.length); assertTrue(ranges[0].getStart().equals(s)); assertTrue(ranges[partNum - 1].getEnd().equals(e)); }
@Override public Datum plus(Datum datum) { switch (datum.type()) { case INT2: return DatumFactory.createInt2((short) (val + datum.asInt2())); case INT4: return DatumFactory.createInt4(val + datum.asInt4()); case INT8: return DatumFactory.createInt8(val + datum.asInt8()); case FLOAT4: return DatumFactory.createFloat4(val + datum.asFloat4()); case FLOAT8: return DatumFactory.createFloat8(val + datum.asFloat8()); case DATE: TimeMeta tm = datum.asTimeMeta(); tm.plusDays(asInt2()); return new DateDatum(tm); case NULL_TYPE: return datum; default: throw new InvalidOperationException(datum.type()); } }
@Override public Datum minus(Datum datum) { switch (datum.type()) { case INT2: return DatumFactory.createInt2((short) (val - datum.asInt2())); case INT4: return DatumFactory.createInt4(val - datum.asInt4()); case INT8: return DatumFactory.createInt8(val - datum.asInt8()); case FLOAT4: return DatumFactory.createFloat4(val - datum.asFloat4()); case FLOAT8: return DatumFactory.createFloat8(val - datum.asFloat8()); case DATE: TimeMeta tm = datum.asTimeMeta(); tm.plusDays(0 - asInt2()); return new DateDatum(tm); case NULL_TYPE: return datum; default: throw new InvalidOperationException(datum.type()); } }
@Override public Datum plus(Datum datum) { switch (datum.kind()) { case INT2: return DatumFactory.createInt2((short) (val + datum.asInt2())); case INT4: return DatumFactory.createInt4(val + datum.asInt4()); case INT8: return DatumFactory.createInt8(val + datum.asInt8()); case FLOAT4: return DatumFactory.createFloat4(val + datum.asFloat4()); case FLOAT8: return DatumFactory.createFloat8(val + datum.asFloat8()); case DATE: TimeMeta tm = datum.asTimeMeta(); tm.plusDays(asInt2()); return new DateDatum(tm); case NULL_TYPE: return datum; default: throw new InvalidOperationException(datum.type()); } }
@Override public Datum minus(Datum datum) { switch (datum.kind()) { case INT2: return DatumFactory.createInt2((short) (val - datum.asInt2())); case INT4: return DatumFactory.createInt4(val - datum.asInt4()); case INT8: return DatumFactory.createInt8(val - datum.asInt8()); case FLOAT4: return DatumFactory.createFloat4(val - datum.asFloat4()); case FLOAT8: return DatumFactory.createFloat8(val - datum.asFloat8()); case DATE: TimeMeta tm = datum.asTimeMeta(); tm.plusDays(0 - asInt2()); return new DateDatum(tm); case NULL_TYPE: return datum; default: throw new InvalidOperationException(datum.type()); } }
private static Tuple makeMaxTuple(Tuple tuple) { tuple.put(new Datum[]{ DatumFactory.createInt8(Long.MAX_VALUE), DatumFactory.createInt4(Integer.MAX_VALUE), DatumFactory.createInt2(Short.MAX_VALUE), DatumFactory.createDate(Integer.MAX_VALUE), DatumFactory.createTimestamp( // FIXME 'Out of Range of Time' //DateTimeUtil.toJulianDate(JULIAN_MAXYEAR, 1, 1) DateTimeUtil.toJulianTimestamp(DateTimeConstants.JULIAN_MAXYEAR / 20, 1, 1, 0, 0, 0, 0)), DatumFactory.createTime(Long.MAX_VALUE), DatumFactory.createFloat4(Float.MAX_VALUE), DatumFactory.createFloat8(Double.MAX_VALUE) }); return tuple; }
@Test public void testGetDatum() { LazyTuple t1 = new LazyTuple(schema, textRow, -1, nullbytes, serde); assertEquals(DatumFactory.createBool(true), t1.get(0)); assertEquals(DatumFactory.createChar("str"), t1.get(1)); assertEquals(DatumFactory.createInt2((short) 17), t1.get(2)); assertEquals(DatumFactory.createInt4(59), t1.get(3)); assertEquals(DatumFactory.createInt8(23l), t1.get(4)); assertEquals(DatumFactory.createFloat4(77.9f), t1.get(5)); assertEquals(DatumFactory.createFloat8(271.9f), t1.get(6)); assertEquals(DatumFactory.createText("str2"), t1.get(7)); assertEquals(DatumFactory.createBlob("jinho".getBytes()), t1.get(8)); assertEquals(NullDatum.get(), t1.get(9)); assertEquals(NullDatum.get(), t1.get(10)); }