Examples with ValueDate org.h2.value.ValueDate used on opensource projects

Example 16 with ValueDate

use of org.h2.value.ValueDate in project h2database by h2database.

the class DateTimeUtils method dateAndTimeFromValue.

/**
 * Extracts date value and nanos of day from the specified value.
 *
 * @param value
 *            value to extract fields from
 * @param provider
 *            the cast information provider
 * @return array with date value and nanos of day
 */
public static long[] dateAndTimeFromValue(Value value, CastDataProvider provider) {
    long dateValue = EPOCH_DATE_VALUE;
    long timeNanos = 0;
    if (value instanceof ValueTimestamp) {
        ValueTimestamp v = (ValueTimestamp) value;
        dateValue = v.getDateValue();
        timeNanos = v.getTimeNanos();
    } else if (value instanceof ValueDate) {
        dateValue = ((ValueDate) value).getDateValue();
    } else if (value instanceof ValueTime) {
        timeNanos = ((ValueTime) value).getNanos();
    } else if (value instanceof ValueTimestampTimeZone) {
        ValueTimestampTimeZone v = (ValueTimestampTimeZone) value;
        dateValue = v.getDateValue();
        timeNanos = v.getTimeNanos();
    } else if (value instanceof ValueTimeTimeZone) {
        timeNanos = ((ValueTimeTimeZone) value).getNanos();
    } else {
        ValueTimestamp v = (ValueTimestamp) value.convertTo(TypeInfo.TYPE_TIMESTAMP, provider);
        dateValue = v.getDateValue();
        timeNanos = v.getTimeNanos();
    }
    return new long[] { dateValue, timeNanos };
}

Example 17 with ValueDate

use of org.h2.value.ValueDate in project h2database by h2database.

the class CompatibilityDatePlusTimeOperation method getValue.

@Override
public Value getValue(SessionLocal session) {
    Value l = left.getValue(session);
    Value r = right.getValue(session);
    if (l == ValueNull.INSTANCE || r == ValueNull.INSTANCE) {
        return ValueNull.INSTANCE;
    }
    switch(l.getValueType()) {
        case Value.TIME:
            if (r.getValueType() == Value.DATE) {
                return // 
                ValueTimestamp.fromDateValueAndNanos(// 
                ((ValueDate) r).getDateValue(), ((ValueTime) l).getNanos());
            }
            break;
        case Value.TIME_TZ:
            if (r.getValueType() == Value.DATE) {
                ValueTimeTimeZone t = (ValueTimeTimeZone) l;
                return ValueTimestampTimeZone.fromDateValueAndNanos(((ValueDate) r).getDateValue(), t.getNanos(), t.getTimeZoneOffsetSeconds());
            }
            break;
        case Value.TIMESTAMP:
            {
                if (r.getValueType() == Value.TIME_TZ) {
                    ValueTimestamp ts = (ValueTimestamp) l;
                    l = ValueTimestampTimeZone.fromDateValueAndNanos(ts.getDateValue(), ts.getTimeNanos(), ((ValueTimeTimeZone) r).getTimeZoneOffsetSeconds());
                }
                break;
            }
    }
    long[] a = DateTimeUtils.dateAndTimeFromValue(l, session);
    long dateValue = a[0], timeNanos = a[1] + (r instanceof ValueTime ? ((ValueTime) r).getNanos() : ((ValueTimeTimeZone) r).getNanos());
    if (timeNanos >= NANOS_PER_DAY) {
        timeNanos -= NANOS_PER_DAY;
        dateValue = DateTimeUtils.incrementDateValue(dateValue);
    }
    return DateTimeUtils.dateTimeToValue(l, dateValue, timeNanos);
}

Example 18 with ValueDate

use of org.h2.value.ValueDate in project h2database by h2database.

the class IntervalOperation method getDateTimeWithInterval.

private Value getDateTimeWithInterval(SessionLocal session, Value l, Value r, int lType, int rType) {
    switch(lType) {
        case Value.TIME:
            if (DataType.isYearMonthIntervalType(rType)) {
                throw DbException.getInternalError("type=" + rType);
            }
            return ValueTime.fromNanos(getTimeWithInterval(r, ((ValueTime) l).getNanos()));
        case Value.TIME_TZ:
            {
                if (DataType.isYearMonthIntervalType(rType)) {
                    throw DbException.getInternalError("type=" + rType);
                }
                ValueTimeTimeZone t = (ValueTimeTimeZone) l;
                return ValueTimeTimeZone.fromNanos(getTimeWithInterval(r, t.getNanos()), t.getTimeZoneOffsetSeconds());
            }
        case Value.DATE:
        case Value.TIMESTAMP:
        case Value.TIMESTAMP_TZ:
            if (DataType.isYearMonthIntervalType(rType)) {
                long m = IntervalUtils.intervalToAbsolute((ValueInterval) r).longValue();
                if (opType == IntervalOpType.DATETIME_MINUS_INTERVAL) {
                    m = -m;
                }
                return DateTimeFunction.dateadd(session, DateTimeFunction.MONTH, m, l);
            } else {
                BigInteger a2 = IntervalUtils.intervalToAbsolute((ValueInterval) r);
                if (lType == Value.DATE) {
                    BigInteger a1 = BigInteger.valueOf(absoluteDayFromDateValue(((ValueDate) l).getDateValue()));
                    a2 = a2.divide(NANOS_PER_DAY_BI);
                    BigInteger n = opType == IntervalOpType.DATETIME_PLUS_INTERVAL ? a1.add(a2) : a1.subtract(a2);
                    return ValueDate.fromDateValue(dateValueFromAbsoluteDay(n.longValue()));
                } else {
                    long[] a = dateAndTimeFromValue(l, session);
                    long absoluteDay = absoluteDayFromDateValue(a[0]);
                    long timeNanos = a[1];
                    BigInteger[] dr = a2.divideAndRemainder(NANOS_PER_DAY_BI);
                    if (opType == IntervalOpType.DATETIME_PLUS_INTERVAL) {
                        absoluteDay += dr[0].longValue();
                        timeNanos += dr[1].longValue();
                    } else {
                        absoluteDay -= dr[0].longValue();
                        timeNanos -= dr[1].longValue();
                    }
                    if (timeNanos >= NANOS_PER_DAY) {
                        timeNanos -= NANOS_PER_DAY;
                        absoluteDay++;
                    } else if (timeNanos < 0) {
                        timeNanos += NANOS_PER_DAY;
                        absoluteDay--;
                    }
                    return dateTimeToValue(l, dateValueFromAbsoluteDay(absoluteDay), timeNanos);
                }
            }
    }
    throw DbException.getInternalError("type=" + opType);
}

Example 19 with ValueDate

use of org.h2.value.ValueDate in project h2database by h2database.

the class TestDate method testValueDate.

private void testValueDate() {
    assertEquals("2000-01-01", LegacyDateTimeUtils.fromDate(null, null, Date.valueOf("2000-01-01")).getString());
    assertEquals("0000-00-00", ValueDate.fromDateValue(0).getString());
    assertEquals("9999-12-31", ValueDate.parse("9999-12-31").getString());
    assertEquals("-9999-12-31", ValueDate.parse("-9999-12-31").getString());
    ValueDate d1 = ValueDate.parse("2001-01-01");
    assertEquals("2001-01-01", LegacyDateTimeUtils.toDate(null, null, d1).toString());
    assertEquals("DATE '2001-01-01'", d1.getTraceSQL());
    assertEquals("DATE '2001-01-01'", d1.toString());
    assertEquals(Value.DATE, d1.getValueType());
    long dv = d1.getDateValue();
    assertEquals((int) ((dv >>> 32) ^ dv), d1.hashCode());
    TypeInfo type = d1.getType();
    assertEquals(d1.getString().length(), type.getDisplaySize());
    assertEquals(ValueDate.PRECISION, type.getPrecision());
    ValueDate d1b = ValueDate.parse("2001-01-01");
    assertTrue(d1 == d1b);
    Value.clearCache();
    d1b = ValueDate.parse("2001-01-01");
    assertFalse(d1 == d1b);
    assertTrue(d1.equals(d1));
    assertTrue(d1.equals(d1b));
    assertTrue(d1b.equals(d1));
    assertEquals(0, d1.compareTo(d1b, null, null));
    assertEquals(0, d1b.compareTo(d1, null, null));
    ValueDate d2 = ValueDate.parse("2002-02-02");
    assertFalse(d1.equals(d2));
    assertFalse(d2.equals(d1));
    assertEquals(-1, d1.compareTo(d2, null, null));
    assertEquals(1, d2.compareTo(d1, null, null));
}

Example 20 with ValueDate

use of org.h2.value.ValueDate in project h2database by h2database.

the class TestDate method testDateTimeUtils.

private void testDateTimeUtils() {
    TimeZone old = TimeZone.getDefault();
    /*
         * java.util.TimeZone doesn't support LMT, so perform this test with
         * fixed time zone offset
         */
    TimeZone.setDefault(TimeZone.getTimeZone("GMT+01"));
    DateTimeUtils.resetCalendar();
    try {
        ValueTimestamp ts1 = ValueTimestamp.parse("-999-08-07 13:14:15.16", null);
        ValueTimestamp ts2 = ValueTimestamp.parse("19999-08-07 13:14:15.16", null);
        ValueTime t1 = (ValueTime) ts1.convertTo(TypeInfo.TYPE_TIME);
        ValueTime t2 = (ValueTime) ts2.convertTo(TypeInfo.TYPE_TIME);
        ValueDate d1 = ts1.convertToDate(null);
        ValueDate d2 = ts2.convertToDate(null);
        assertEquals("-0999-08-07 13:14:15.16", ts1.getString());
        assertEquals("-0999-08-07", d1.getString());
        assertEquals("13:14:15.16", t1.getString());
        assertEquals("19999-08-07 13:14:15.16", ts2.getString());
        assertEquals("19999-08-07", d2.getString());
        assertEquals("13:14:15.16", t2.getString());
        TimeZone timeZone = TimeZone.getDefault();
        ValueTimestamp ts1a = LegacyDateTimeUtils.fromTimestamp(null, timeZone, LegacyDateTimeUtils.toTimestamp(null, null, ts1));
        ValueTimestamp ts2a = LegacyDateTimeUtils.fromTimestamp(null, timeZone, LegacyDateTimeUtils.toTimestamp(null, null, ts2));
        assertEquals("-0999-08-07 13:14:15.16", ts1a.getString());
        assertEquals("19999-08-07 13:14:15.16", ts2a.getString());
    } finally {
        TimeZone.setDefault(old);
        DateTimeUtils.resetCalendar();
    }
}