public static IntervalDatum createInterval(int month, long interval) { return new IntervalDatum(month, interval); }
@Override public String toString() { return asChars(); }
@Override public Datum minus(Datum datum) { if (datum.type() == TajoDataTypes.Type.INTERVAL) { IntervalDatum other = (IntervalDatum) datum; return new IntervalDatum(months - other.months, milliseconds - other.milliseconds); } else { throw new InvalidOperationException("operator does not exist: " + type() + " - " + datum.type()); } }
@Override public Datum multiply(Datum datum) { switch(datum.kind()) { case INT2: case INT4: case INT8: long int8Val = datum.asInt8(); return createIntervalDatum((double)months * int8Val, (double) milliseconds * int8Val); case FLOAT4: case FLOAT8: double float8Val = datum.asFloat8(); return createIntervalDatum((double)months * float8Val, (double) milliseconds * float8Val); default: throw new InvalidOperationException("operator does not exist: " + type() + " * " + datum.type()); } }
@Override public Datum divide(Datum datum) { switch (datum.type()) { case INT2: case INT4: case INT8: long paramValueI8 = datum.asInt8(); if (!validateDivideZero(paramValueI8)) { return NullDatum.get(); } return createIntervalDatum((double) months / paramValueI8, (double) milliseconds / paramValueI8); case FLOAT4: case FLOAT8: double paramValueF8 = datum.asFloat8(); if (!validateDivideZero(paramValueF8)) { return NullDatum.get(); } return createIntervalDatum((double) months / paramValueF8, (double) milliseconds / paramValueF8); default: throw new InvalidOperationException("operator does not exist: " + type() + " / " + datum.type()); } }
@Override public Datum multiply(Datum datum) { switch (datum.kind()) { case INT2: return DatumFactory.createInt4(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 INTERVAL: IntervalDatum interval = (IntervalDatum)datum; return new IntervalDatum(interval.getMonths() * val, interval.getMilliSeconds() * val); case NULL_TYPE: return datum; default: throw new InvalidOperationException(datum.type()); } }
@Override public void putInterval(IntervalDatum val) { ensureSize(SizeOf.SIZE_OF_INT + SizeOf.SIZE_OF_LONG); long addr = currentAddr(); PlatformDependent.putInt(addr, val.getMonths()); PlatformDependent.putLong(addr + SizeOf.SIZE_OF_INT, val.getMilliSeconds()); putFieldHeader(addr, curOffset); forwardField(SizeOf.SIZE_OF_INT + SizeOf.SIZE_OF_LONG); }
@Override public Datum multiply(Datum datum) { switch (datum.kind()) { case INT2: return DatumFactory.createFloat4(val * datum.asInt2()); case INT4: return DatumFactory.createFloat4(val * datum.asInt4()); case INT8: return DatumFactory.createFloat4(val * datum.asInt8()); case FLOAT4: return DatumFactory.createFloat4(val * datum.asFloat4()); case FLOAT8: return DatumFactory.createFloat8(val * datum.asFloat8()); case INTERVAL: IntervalDatum interval = (IntervalDatum)datum; return new IntervalDatum((int)(interval.getMonths() * val), (long)(interval.getMilliSeconds() * val)); case NULL_TYPE: return datum; default: throw new InvalidOperationException(datum.type()); } }
@Override public void putInterval(IntervalDatum val) { ensureSize(SizeOf.SIZE_OF_INT + SizeOf.SIZE_OF_LONG); long addr = currentAddr(); PlatformDependent.putInt(addr, val.getMonths()); PlatformDependent.putLong(addr + SizeOf.SIZE_OF_INT, val.getMilliSeconds()); putFieldHeader(addr, curOffset); forwardField(SizeOf.SIZE_OF_INT + SizeOf.SIZE_OF_LONG); }
@Override public Datum minus(Datum datum) { if (datum.kind() == TajoDataTypes.Type.INTERVAL) { IntervalDatum other = (IntervalDatum) datum; return new IntervalDatum(months - other.months, milliseconds - other.milliseconds); } else { throw new InvalidOperationException("operator does not exist: " + type() + " - " + datum.type()); } }
@Override public Datum divide(Datum datum) { switch (datum.kind()) { case INT2: case INT4: case INT8: long paramValueI8 = datum.asInt8(); if (!validateDivideZero(paramValueI8)) { return NullDatum.get(); } return createIntervalDatum((double) months / paramValueI8, (double) milliseconds / paramValueI8); case FLOAT4: case FLOAT8: double paramValueF8 = datum.asFloat8(); if (!validateDivideZero(paramValueF8)) { return NullDatum.get(); } return createIntervalDatum((double) months / paramValueF8, (double) milliseconds / paramValueF8); default: throw new InvalidOperationException("operator does not exist: " + type() + " / " + datum.type()); } }
@Override public Datum multiply(Datum datum) { switch(datum.type()) { case INT2: case INT4: case INT8: long int8Val = datum.asInt8(); return createIntervalDatum((double)months * int8Val, (double) milliseconds * int8Val); case FLOAT4: case FLOAT8: double float8Val = datum.asFloat8(); return createIntervalDatum((double)months * float8Val, (double) milliseconds * float8Val); default: throw new InvalidOperationException("operator does not exist: " + type() + " * " + datum.type()); } }
@Override public Datum multiply(Datum datum) { switch (datum.kind()) { case INT2: return DatumFactory.createFloat8(val * datum.asInt2()); case INT4: return DatumFactory.createFloat8(val * datum.asInt4()); case INT8: return DatumFactory.createFloat8(val * datum.asInt8()); case FLOAT4: return DatumFactory.createFloat8(val * datum.asFloat4()); case FLOAT8: return DatumFactory.createFloat8(val * datum.asFloat8()); case INTERVAL: IntervalDatum interval = (IntervalDatum)datum; return new IntervalDatum((int)(interval.getMonths() * val), (long)(interval.getMilliSeconds() * val)); case NULL_TYPE: return datum; default: throw new InvalidOperationException(datum.type()); } }
@Override public void putInterval(IntervalDatum val) { ensureSize(MAXIMUM_VARIANT_INT32 + MAXIMUM_VARIANT_INT64); long addr = currentAddr(); short length = writeRawVarint32(addr, encodeZigZag32(val.getMonths())); length += writeRawVarint64(addr, encodeZigZag64(val.getMilliSeconds())); curFieldIdx++; forwardField(length); }
@SuppressWarnings("unused") public static IntervalDatum createInterval(long interval) { return new IntervalDatum(interval); }
@Override public Datum plus(Datum datum) { switch(datum.type()) { case INTERVAL: IntervalDatum other = (IntervalDatum) datum; return new IntervalDatum(months + other.months, milliseconds + other.milliseconds); case DATE: { DateDatum dateDatum = (DateDatum) datum; TimeMeta tm = dateDatum.asTimeMeta(); tm.plusInterval(months, milliseconds); return new TimestampDatum(DateTimeUtil.toJulianTimestamp(tm)); } case TIME: { TimeMeta tm = datum.asTimeMeta(); tm.plusInterval(months, milliseconds); return new TimeDatum(DateTimeUtil.toTime(tm)); } case TIMESTAMP: { TimeMeta tm = new TimeMeta(); DateTimeUtil.toJulianTimeMeta(datum.asInt8(), tm); tm.plusInterval(months, milliseconds); return new TimestampDatum(DateTimeUtil.toJulianTimestamp(tm)); } default: throw new InvalidOperationException("operator does not exist: " + type() + " + " + datum.type()); } }
@Override public String toString() { return asChars(); }
@Override public Datum multiply(Datum datum) { switch (datum.type()) { case INT2: return DatumFactory.createFloat8(val * datum.asInt2()); case INT4: return DatumFactory.createFloat8(val * datum.asInt4()); case INT8: return DatumFactory.createFloat8(val * datum.asInt8()); case FLOAT4: return DatumFactory.createFloat8(val * datum.asFloat4()); case FLOAT8: return DatumFactory.createFloat8(val * datum.asFloat8()); case INTERVAL: IntervalDatum interval = (IntervalDatum)datum; return new IntervalDatum((int)(interval.getMonths() * val), (long)(interval.getMilliSeconds() * val)); case NULL_TYPE: return datum; default: throw new InvalidOperationException(datum.type()); } }