How to use

TimestampDatum

in

org.apache.tajo.datum

public String toString() {
 return asChars();
}

@SuppressWarnings("unused")
public static TimestampDatum createTimestamp(long julianTimestamp) {
 return new TimestampDatum(julianTimestamp);
}

public String toString(TimeZone timeZone, boolean includeTimeZone) {
 return asChars(asTimeMeta(), timeZone, includeTimeZone);
}

@Override
public Datum plus(Datum datum) {
 switch (datum.kind()) {
 case INTERVAL:
  IntervalDatum interval = (IntervalDatum) datum;
  TimeMeta tm = asTimeMeta();
  tm.plusInterval(interval.months, interval.milliseconds);
  return new TimestampDatum(DateTimeUtil.toJulianTimestamp(tm));
 case TIME:
  TimeMeta tm1 = asTimeMeta();
  TimeMeta tm2 = datum.asTimeMeta();
  tm1.plusTime(DateTimeUtil.toTime(tm2));
  return new TimestampDatum(DateTimeUtil.toJulianTimestamp(tm1));
 default:
  throw new InvalidOperationException("operator does not exist: " + type() + " + " + datum.type());
 }
}

public int getMonthOfYear() {
 TimeMeta tm = asTimeMeta();
 return tm.monthOfYear;
}

@Override
public Datum plus(Datum datum) {
 switch (datum.type()) {
 case INTERVAL: {
  IntervalDatum interval = ((IntervalDatum) datum);
  TimeMeta tm = asTimeMeta();
  tm.plusInterval(interval.months, interval.milliseconds);
  return new TimeDatum(DateTimeUtil.toTime(tm));
 }
 case DATE: {
  DateDatum dateDatum = (DateDatum) datum;
  TimeMeta dateTm = dateDatum.asTimeMeta();
  dateTm.plusTime(time);
  return new TimestampDatum(DateTimeUtil.toJulianTimestamp(dateTm));
 }
 case TIMESTAMP: {
  TimestampDatum timestampDatum = (TimestampDatum) datum;
  TimeMeta tm = timestampDatum.asTimeMeta();
  tm.plusTime(time);
  return new TimestampDatum(DateTimeUtil.toJulianTimestamp(tm));
 }
 default:
  throw new InvalidOperationException("operator does not exist: " + type() + " + " + datum.type());
 }
}

TimestampDatum timestampDatum = (TimestampDatum) datum;
dateValue = new DateValue(""+timestampDatum.getYear(),
 ""+timestampDatum.getMonthOfYear(), ""+timestampDatum.getDayOfMonth());
timeValue = new TimeValue(""+timestampDatum.getHourOfDay()
 , ""+timestampDatum.getMinuteOfHour(), ""+timestampDatum.getSecondOfMinute());

public static void fillRow(int i, RowWriter builder) {
 builder.startRow();
 builder.putBool(i % 1 == 0 ? true : false); // 0
 builder.putInt2((short) 1);                 // 1
 builder.putInt4(i);                         // 2
 builder.putInt8(i);                         // 3
 builder.putFloat4(i);                       // 4
 builder.putFloat8(i);                       // 5
 builder.putText((UNICODE_FIELD_PREFIX + i).getBytes());  // 6
 builder.putTimestamp(DatumFactory.createTimestamp("2014-04-16 08:48:00").asInt8() + i); // 7
 builder.putDate(DatumFactory.createDate("2014-04-16").asInt4() + i); // 8
 builder.putTime(DatumFactory.createTime("08:48:00").asInt8() + i); // 9
 builder.putInterval(DatumFactory.createInterval((i + 1) + " hours")); // 10
 builder.putProtoDatum(new ProtobufDatum(ProtoUtil.convertString(i + ""))); // 11
 builder.endRow();
}

@Override
public Datum plus(Datum datum) {
 switch (datum.type()) {
 case INTERVAL:
  IntervalDatum interval = (IntervalDatum) datum;
  TimeMeta tm = asTimeMeta();
  tm.plusInterval(interval.months, interval.milliseconds);
  return new TimestampDatum(DateTimeUtil.toJulianTimestamp(tm));
 case TIME:
  TimeMeta tm1 = asTimeMeta();
  TimeMeta tm2 = datum.asTimeMeta();
  tm1.plusTime(DateTimeUtil.toTime(tm2));
  return new TimestampDatum(DateTimeUtil.toJulianTimestamp(tm1));
 default:
  throw new InvalidOperationException("operator does not exist: " + type() + " + " + datum.type());
 }
}

public int getYear() {
 TimeMeta tm = asTimeMeta();
 return tm.years;
}

@Override
public Datum plus(Datum datum) {
 switch (datum.kind()) {
 case INTERVAL: {
  IntervalDatum interval = ((IntervalDatum) datum);
  TimeMeta tm = asTimeMeta();
  tm.plusInterval(interval.months, interval.milliseconds);
  return new TimeDatum(DateTimeUtil.toTime(tm));
 }
 case DATE: {
  DateDatum dateDatum = (DateDatum) datum;
  TimeMeta dateTm = dateDatum.asTimeMeta();
  dateTm.plusTime(time);
  return new TimestampDatum(DateTimeUtil.toJulianTimestamp(dateTm));
 }
 case TIMESTAMP: {
  TimestampDatum timestampDatum = (TimestampDatum) datum;
  TimeMeta tm = timestampDatum.asTimeMeta();
  tm.plusTime(time);
  return new TimestampDatum(DateTimeUtil.toJulianTimestamp(tm));
 }
 default:
  throw new InvalidOperationException("operator does not exist: " + type() + " + " + datum.type());
 }
}

public static void validateTupleResult(int j, Tuple t) {
 assertTrue((j % 1 == 0) == t.getBool(0));
 assertTrue(1 == t.getInt2(1));
 assertEquals(j, t.getInt4(2));
 assertEquals(j, t.getInt8(3));
 assertTrue(j == t.getFloat4(4));
 assertTrue(j == t.getFloat8(5));
 assertEquals(new String(UNICODE_FIELD_PREFIX + j), t.getText(6));
 assertEquals(DatumFactory.createTimestamp("2014-04-16 08:48:00").asInt8() + (long) j, t.getInt8(7));
 assertEquals(DatumFactory.createDate("2014-04-16").asInt4() + j, t.getInt4(8));
 assertEquals(DatumFactory.createTime("08:48:00").asInt8() + j, t.getInt8(9));
 assertEquals(DatumFactory.createInterval((j + 1) + " hours"), t.getInterval(10));
 assertEquals(new ProtobufDatum(ProtoUtil.convertString(j + "")), t.getProtobufDatum(11));
}

@SuppressWarnings("unused")
public static TimestampDatum createTimestamp(long julianTimestamp) {
 return new TimestampDatum(julianTimestamp);
}

public String toString() {
 return asChars();
}

public String toString(TimeZone timeZone, boolean includeTimeZone) {
 return asChars(asTimeMeta(), timeZone, includeTimeZone);
}

@Override
public Datum minus(Datum datum) {
 switch (datum.type()) {
 case INTERVAL:
  IntervalDatum interval = (IntervalDatum) datum;
  TimeMeta tm = asTimeMeta();
  tm.plusInterval(-interval.months, -interval.milliseconds);
  return new TimestampDatum(DateTimeUtil.toJulianTimestamp(tm));
 case TIMESTAMP:
  return new IntervalDatum((timestamp - ((TimestampDatum) datum).timestamp) / 1000);
 case TIME:
  TimeMeta tm1 = asTimeMeta();
  TimeMeta tm2 = datum.asTimeMeta();
  tm1.plusTime(0 - DateTimeUtil.toTime(tm2));
  return new TimestampDatum(DateTimeUtil.toJulianTimestamp(tm1));
 default:
  throw new InvalidOperationException("operator does not exist: " + type() + " - " + datum.type());
 }
}

public int getMinuteOfHour() {
 TimeMeta tm = asTimeMeta();
 return tm.minutes;
}

 writer.skipField();
} else {
 writer.putTimestamp(DatumFactory.createTimestamp("2014-04-16 08:48:00").asInt8() + i); // 7

public static TimestampDatum createTimestmpDatumWithJavaMillis(long millis) {
 return new TimestampDatum(DateTimeUtil.javaTimeToJulianTime(millis));
}

@Override
public byte[] asTextBytes() {
 return asChars().getBytes(TextDatum.DEFAULT_CHARSET);
}