[
https://issues.apache.org/jira/browse/PHOENIX-6823?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17640718#comment-17640718
]
ASF GitHub Bot commented on PHOENIX-6823:
-----------------------------------------
stoty commented on code in PR #1530:
URL: https://github.com/apache/phoenix/pull/1530#discussion_r1034779244
##########
phoenix-core/src/test/java/org/apache/phoenix/expression/RoundFloorCeilExpressionsTest.java:
##########
@@ -688,4 +720,1207 @@ public void testFloorDateExpressionForWeek() throws
Exception {
Date resultDate = (Date)result;
assertEquals(DateUtil.parseDate("2016-01-04 00:00:00"), resultDate);
}
+
+ private RoundDateExpression getRoundMsExpression(String s, TimeUnit u, int
m) throws SQLException {
+ return
(RoundDateExpression)RoundDateExpression.create(LiteralExpression.newConstant(s),
u, m );
+ }
+
+ // The three tests below are backported from PHOENIX-5066.
+ // When PHOENIX-5066 lands, these can be removed as redundant.
+
+ @Test
+ public void testRoundingGMT() throws SQLException {
+ // We operate on Instants for time units up to Days, simply counting
millis
+
+ RoundDateExpression oddWholeSecondExp =
+ getRoundMsExpression("2022-11-11 11:11:11", TimeUnit.SECOND,
1);
+ java.sql.Timestamp oddWholeSecond =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-11
11:11:11").getTime());
+ long lowerBoundaryOddWholeSecond = oddWholeSecond.getTime() - HALF_SEC;
+ long upperBoundaryOddWholeSecond = oddWholeSecond.getTime() + HALF_SEC
- 1;
+ assertEquals(lowerBoundaryOddWholeSecond,
+ oddWholeSecondExp.rangeLower(oddWholeSecond.getTime()));
+ assertEquals(upperBoundaryOddWholeSecond,
+ oddWholeSecondExp.rangeUpper(oddWholeSecond.getTime()));
+ assertEquals(oddWholeSecond,
+ new
java.sql.Timestamp(oddWholeSecondExp.roundTime(lowerBoundaryOddWholeSecond)));
+ assertNotEquals(oddWholeSecond,
+ new
java.sql.Timestamp(oddWholeSecondExp.roundTime(lowerBoundaryOddWholeSecond -
1)));
+ assertEquals(oddWholeSecond,
+ new
java.sql.Timestamp(oddWholeSecondExp.roundTime(upperBoundaryOddWholeSecond)));
+ assertNotEquals(oddWholeSecond,
+ new
java.sql.Timestamp(oddWholeSecondExp.roundTime(upperBoundaryOddWholeSecond +
1)));
+
+ // 10 sec range
+ RoundDateExpression oddWholeSecondRound10Exp =
+ getRoundMsExpression("2022-11-11 11:11:10", TimeUnit.SECOND,
10);
+ java.sql.Timestamp oddWholeSecondRound10 =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-11
11:11:10").getTime());
+ long lowerBoundaryOddWholeSecondRound10 =
oddWholeSecondRound10.getTime() - 5 * SEC;
+ long upperBoundaryOddWholeSecondRound10 =
oddWholeSecondRound10.getTime() + 5 * SEC - 1;
+ assertEquals(lowerBoundaryOddWholeSecondRound10,
+ oddWholeSecondRound10Exp.rangeLower(oddWholeSecond.getTime()));
+ assertEquals(upperBoundaryOddWholeSecondRound10,
+ oddWholeSecondRound10Exp.rangeUpper(oddWholeSecond.getTime()));
+ assertEquals(oddWholeSecondRound10, new java.sql.Timestamp(
+
oddWholeSecondRound10Exp.roundTime(lowerBoundaryOddWholeSecondRound10)));
+ assertNotEquals(oddWholeSecondRound10, new java.sql.Timestamp(
+
oddWholeSecondRound10Exp.roundTime(lowerBoundaryOddWholeSecondRound10 - 1)));
+ assertEquals(oddWholeSecondRound10, new java.sql.Timestamp(
+
oddWholeSecondRound10Exp.roundTime(upperBoundaryOddWholeSecondRound10)));
+ assertNotEquals(oddWholeSecondRound10, new java.sql.Timestamp(
+
oddWholeSecondRound10Exp.roundTime(upperBoundaryOddWholeSecondRound10 + 1)));
+
+ // 15 sec range
+ RoundDateExpression oddWholeSecondRound15Exp =
+ getRoundMsExpression("2022-11-11 11:11:15", TimeUnit.SECOND,
15);
+ java.sql.Timestamp oddWholeSecondRound15 =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-11
11:11:15").getTime());
+ long lowerBoundaryOddWholeSecondRound15 =
oddWholeSecondRound15.getTime() - 15 * HALF_SEC;
+ long upperBoundaryOddWholeSecondRound15 =
+ oddWholeSecondRound15.getTime() + 15 * HALF_SEC - 1;
+ assertEquals(lowerBoundaryOddWholeSecondRound15,
+ oddWholeSecondRound15Exp.rangeLower(oddWholeSecond.getTime()));
+ assertEquals(upperBoundaryOddWholeSecondRound15,
+ oddWholeSecondRound15Exp.rangeUpper(oddWholeSecond.getTime()));
+ assertEquals(oddWholeSecondRound15, new java.sql.Timestamp(
+
oddWholeSecondRound15Exp.roundTime(lowerBoundaryOddWholeSecondRound15)));
+ assertNotEquals(oddWholeSecondRound15, new java.sql.Timestamp(
+
oddWholeSecondRound15Exp.roundTime(lowerBoundaryOddWholeSecondRound15 - 1)));
+ assertEquals(oddWholeSecondRound15, new java.sql.Timestamp(
+
oddWholeSecondRound15Exp.roundTime(upperBoundaryOddWholeSecondRound15)));
+ assertNotEquals(oddWholeSecondRound15, new java.sql.Timestamp(
+
oddWholeSecondRound15Exp.roundTime(upperBoundaryOddWholeSecondRound15 + 1)));
+
+ RoundDateExpression evenWholeSecondExp =
+ getRoundMsExpression("2022-11-11 11:11:12", TimeUnit.SECOND,
1);
+ java.sql.Timestamp evenWholeSecond =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-11
11:11:12").getTime());
+ long lowerBoundaryEvenWholeSecond = evenWholeSecond.getTime() -
HALF_SEC;
+ long upperBoundaryEvenWholeSecond = evenWholeSecond.getTime() +
HALF_SEC - 1;
+ assertEquals(lowerBoundaryEvenWholeSecond,
+ evenWholeSecondExp.rangeLower(evenWholeSecond.getTime()));
+ assertEquals(upperBoundaryEvenWholeSecond,
+ evenWholeSecondExp.rangeUpper(evenWholeSecond.getTime()));
+ assertEquals(evenWholeSecond,
+ new
java.sql.Timestamp(evenWholeSecondExp.roundTime(lowerBoundaryEvenWholeSecond)));
+ assertNotEquals(evenWholeSecond,
+ new
java.sql.Timestamp(evenWholeSecondExp.roundTime(lowerBoundaryEvenWholeSecond -
1)));
+ assertEquals(evenWholeSecond,
+ new
java.sql.Timestamp(evenWholeSecondExp.roundTime(upperBoundaryEvenWholeSecond)));
+ assertNotEquals(evenWholeSecond,
+ new
java.sql.Timestamp(evenWholeSecondExp.roundTime(upperBoundaryEvenWholeSecond +
1)));
+
+ RoundDateExpression oddWholeMinuteExp =
+ getRoundMsExpression("2022-11-11 11:11:0", TimeUnit.MINUTE, 1);
+ java.sql.Timestamp oddWholeMinute =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-11
11:11:0").getTime());
+ long lowerBoundaryOddWholeMinute = oddWholeMinute.getTime() - HALF_MIN;
+ long upperBoundaryOddWholeMinute = oddWholeMinute.getTime() + HALF_MIN
- 1;
+ assertEquals(lowerBoundaryOddWholeMinute,
+ oddWholeMinuteExp.rangeLower(oddWholeMinute.getTime()));
+ assertEquals(upperBoundaryOddWholeMinute,
+ oddWholeMinuteExp.rangeUpper(oddWholeMinute.getTime()));
+ assertEquals(oddWholeMinute,
+ new
java.sql.Timestamp(oddWholeMinuteExp.roundTime(lowerBoundaryOddWholeMinute)));
+ assertNotEquals(oddWholeMinute,
+ new
java.sql.Timestamp(oddWholeMinuteExp.roundTime(lowerBoundaryOddWholeMinute -
1)));
+ assertEquals(oddWholeMinute,
+ new
java.sql.Timestamp(oddWholeMinuteExp.roundTime(upperBoundaryOddWholeMinute)));
+ assertNotEquals(oddWholeMinute,
+ new
java.sql.Timestamp(oddWholeMinuteExp.roundTime(upperBoundaryOddWholeMinute +
1)));
+
+ RoundDateExpression oddWholeMinuteRound20Exp =
+ getRoundMsExpression("2022-11-11 11:20:0", TimeUnit.MINUTE,
20);
+ java.sql.Timestamp oddWholeMinuteRound20 =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-11
11:20:0").getTime());
+ long lowerBoundaryOddWholeMinute20 = oddWholeMinuteRound20.getTime() -
10 * MIN;
+ long upperBoundaryOddWholeMinute20 = oddWholeMinuteRound20.getTime() +
10 * MIN - 1;
+ assertEquals(lowerBoundaryOddWholeMinute20,
+ oddWholeMinuteRound20Exp.rangeLower(oddWholeMinute.getTime()));
+ assertEquals(upperBoundaryOddWholeMinute20,
+ oddWholeMinuteRound20Exp.rangeUpper(oddWholeMinute.getTime()));
+ assertEquals(oddWholeMinuteRound20, new java.sql.Timestamp(
+
oddWholeMinuteRound20Exp.roundTime(lowerBoundaryOddWholeMinute20)));
+ assertNotEquals(oddWholeMinuteRound20, new java.sql.Timestamp(
+
oddWholeMinuteRound20Exp.roundTime(lowerBoundaryOddWholeMinute20 - 1)));
+ assertEquals(oddWholeMinuteRound20, new java.sql.Timestamp(
+
oddWholeMinuteRound20Exp.roundTime(upperBoundaryOddWholeMinute20)));
+ assertNotEquals(oddWholeMinuteRound20, new java.sql.Timestamp(
+
oddWholeMinuteRound20Exp.roundTime(upperBoundaryOddWholeMinute20 + 1)));
+
+ // Minutes since epoch, don't expect the rounded value to be "round"
+
+ RoundDateExpression oddWholeMinuteRound17Exp =
+ getRoundMsExpression("2022-11-11 11:12:0", TimeUnit.MINUTE,
17);
+ java.sql.Timestamp oddWholeMinuteRound17 =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-11
11:12:00").getTime());
+ long lowerBoundaryOddWholeMinute17 = oddWholeMinuteRound17.getTime() -
17 * HALF_MIN;
+ long upperBoundaryOddWholeMinute17 = oddWholeMinuteRound17.getTime() +
17 * HALF_MIN - 1;
+ assertEquals(lowerBoundaryOddWholeMinute17,
+ oddWholeMinuteRound17Exp.rangeLower(oddWholeMinute.getTime()));
+ assertEquals(upperBoundaryOddWholeMinute17,
+ oddWholeMinuteRound17Exp.rangeUpper(oddWholeMinute.getTime()));
+ assertEquals(oddWholeMinuteRound17, new java.sql.Timestamp(
+
oddWholeMinuteRound17Exp.roundTime(lowerBoundaryOddWholeMinute17)));
+ assertNotEquals(oddWholeMinuteRound17, new java.sql.Timestamp(
+
oddWholeMinuteRound17Exp.roundTime(lowerBoundaryOddWholeMinute17 - 1)));
+ assertEquals(oddWholeMinuteRound17, new java.sql.Timestamp(
+
oddWholeMinuteRound17Exp.roundTime(upperBoundaryOddWholeMinute17)));
+ assertNotEquals(oddWholeMinuteRound17, new java.sql.Timestamp(
+
oddWholeMinuteRound17Exp.roundTime(upperBoundaryOddWholeMinute17 + 1)));
+
+ RoundDateExpression evenWholeMinuteExp =
+ getRoundMsExpression("2022-11-11 11:12:0", TimeUnit.MINUTE, 1);
+ java.sql.Timestamp evenWholeMinute =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-11
11:12:0").getTime());
+ long lowerBoundaryEvenWholeMinute = evenWholeMinute.getTime() -
HALF_MIN;
+ long upperBoundaryEvenWholeMinute = evenWholeMinute.getTime() +
HALF_MIN - 1;
+ assertEquals(lowerBoundaryEvenWholeMinute,
+ evenWholeMinuteExp.rangeLower(evenWholeMinute.getTime()));
+ assertEquals(upperBoundaryEvenWholeMinute,
+ evenWholeMinuteExp.rangeUpper(evenWholeMinute.getTime()));
+ assertEquals(evenWholeMinute,
+ new
java.sql.Timestamp(evenWholeMinuteExp.roundTime(lowerBoundaryEvenWholeMinute)));
+ assertNotEquals(evenWholeMinute,
+ new
java.sql.Timestamp(evenWholeMinuteExp.roundTime(lowerBoundaryEvenWholeMinute -
1)));
+ assertEquals(evenWholeMinute,
+ new
java.sql.Timestamp(evenWholeMinuteExp.roundTime(upperBoundaryEvenWholeMinute)));
+ assertNotEquals(evenWholeMinute,
+ new
java.sql.Timestamp(evenWholeMinuteExp.roundTime(upperBoundaryEvenWholeMinute +
1)));
+
+ RoundDateExpression oddWholeHourExp =
+ getRoundMsExpression("2022-11-11 11:0:0", TimeUnit.HOUR, 1);
+ java.sql.Timestamp oddWholeHour =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-11
11:0:0").getTime());
+ long lowerBoundaryOddWholeHour = oddWholeHour.getTime() - HALF_HOUR;
+ long upperBoundaryOddWholeHour = oddWholeHour.getTime() + HALF_HOUR -
1;
+ assertEquals(lowerBoundaryOddWholeHour,
oddWholeHourExp.rangeLower(oddWholeHour.getTime()));
+ assertEquals(upperBoundaryOddWholeHour,
oddWholeHourExp.rangeUpper(oddWholeHour.getTime()));
+ assertEquals(oddWholeHour,
+ new
java.sql.Timestamp(oddWholeHourExp.roundTime(lowerBoundaryOddWholeHour)));
+ assertNotEquals(oddWholeHour,
+ new
java.sql.Timestamp(oddWholeHourExp.roundTime(lowerBoundaryOddWholeHour - 1)));
+ assertEquals(oddWholeHour,
+ new
java.sql.Timestamp(oddWholeHourExp.roundTime(upperBoundaryOddWholeHour)));
+ assertNotEquals(oddWholeHour,
+ new
java.sql.Timestamp(oddWholeHourExp.roundTime(upperBoundaryOddWholeHour + 1)));
+
+ // Not rounding to hourOfDay
+ RoundDateExpression oddWholeHour10Exp =
+ getRoundMsExpression("2022-11-11 12:0:0", TimeUnit.HOUR, 10);
+ java.sql.Timestamp oddWholeHour10 =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-11
12:0:0").getTime());
+ long lowerBoundaryOddWholeHour10 = oddWholeHour10.getTime() -
HALF_HOUR * 10;
+ long upperBoundaryOddWholeHour10 = oddWholeHour10.getTime() +
HALF_HOUR * 10 - 1;
+ assertEquals(lowerBoundaryOddWholeHour10,
+ oddWholeHour10Exp.rangeLower(oddWholeHour.getTime()));
+ assertEquals(upperBoundaryOddWholeHour10,
+ oddWholeHour10Exp.rangeUpper(oddWholeHour.getTime()));
+ assertEquals(oddWholeHour10,
+ new
java.sql.Timestamp(oddWholeHour10Exp.roundTime(lowerBoundaryOddWholeHour10)));
+ assertNotEquals(oddWholeHour10,
+ new
java.sql.Timestamp(oddWholeHour10Exp.roundTime(lowerBoundaryOddWholeHour10 -
1)));
+ assertEquals(oddWholeHour10,
+ new
java.sql.Timestamp(oddWholeHour10Exp.roundTime(upperBoundaryOddWholeHour10)));
+ assertNotEquals(oddWholeHour10,
+ new
java.sql.Timestamp(oddWholeHour10Exp.roundTime(upperBoundaryOddWholeHour10 +
1)));
+
+ // Not rounding to hourOfDay
+ RoundDateExpression oddWholeHour11Exp =
+ getRoundMsExpression("2022-11-11 07:0:0", TimeUnit.HOUR, 11);
+ java.sql.Timestamp oddWholeHour11 =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-11
07:0:0").getTime());
+ long lowerBoundaryOddWholeHour11 = oddWholeHour11.getTime() -
HALF_HOUR * 11;
+ long upperBoundaryOddWholeHour11 = oddWholeHour11.getTime() +
HALF_HOUR * 11 - 1;
+ assertEquals(lowerBoundaryOddWholeHour11,
+ oddWholeHour11Exp.rangeLower(oddWholeHour.getTime()));
+ assertEquals(upperBoundaryOddWholeHour11,
+ oddWholeHour11Exp.rangeUpper(oddWholeHour.getTime()));
+ assertEquals(oddWholeHour11,
+ new
java.sql.Timestamp(oddWholeHour11Exp.roundTime(lowerBoundaryOddWholeHour11)));
+ assertNotEquals(oddWholeHour11,
+ new
java.sql.Timestamp(oddWholeHour11Exp.roundTime(lowerBoundaryOddWholeHour11 -
1)));
+ assertEquals(oddWholeHour11,
+ new
java.sql.Timestamp(oddWholeHour11Exp.roundTime(upperBoundaryOddWholeHour11)));
+ assertNotEquals(oddWholeHour11,
+ new
java.sql.Timestamp(oddWholeHour11Exp.roundTime(upperBoundaryOddWholeHour11 +
1)));
+
+ RoundDateExpression evenwholeHourExp =
+ getRoundMsExpression("2022-11-11 12:0:0", TimeUnit.HOUR, 1);
+ java.sql.Timestamp evenwholeHour =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-11
12:0:0").getTime());
+ long lowerBoundaryEvenWholeHour = evenwholeHour.getTime() - HALF_HOUR;
+ long upperBoundaryEvenWholeHour = evenwholeHour.getTime() + HALF_HOUR
- 1;
+ assertEquals(lowerBoundaryEvenWholeHour,
+ evenwholeHourExp.rangeLower(evenwholeHour.getTime()));
+ assertEquals(upperBoundaryEvenWholeHour,
+ evenwholeHourExp.rangeUpper(evenwholeHour.getTime()));
+ assertEquals(evenwholeHour,
+ new
java.sql.Timestamp(evenwholeHourExp.roundTime(lowerBoundaryEvenWholeHour)));
+ assertNotEquals(evenwholeHour,
+ new
java.sql.Timestamp(evenwholeHourExp.roundTime(lowerBoundaryEvenWholeHour - 1)));
+ assertEquals(evenwholeHour,
+ new
java.sql.Timestamp(evenwholeHourExp.roundTime(upperBoundaryEvenWholeHour)));
+ assertNotEquals(evenwholeHour,
+ new
java.sql.Timestamp(evenwholeHourExp.roundTime(upperBoundaryEvenWholeHour + 1)));
+
+ // No DST switchover
+ RoundDateExpression oddWholeDayExp =
+ getRoundMsExpression("2022-11-11 0:0:0", TimeUnit.DAY, 1);
+ java.sql.Timestamp oddWholeDay =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-11
0:0:0").getTime());
+ long lowerBoundaryOddWholeDay = oddWholeDay.getTime() - HALF_DAY;
+ long upperBoundaryOddWholeDay = oddWholeDay.getTime() + HALF_DAY - 1;
+ assertEquals(lowerBoundaryOddWholeDay,
oddWholeDayExp.rangeLower(oddWholeDay.getTime()));
+ assertEquals(upperBoundaryOddWholeDay,
oddWholeDayExp.rangeUpper(oddWholeDay.getTime()));
+ assertEquals(oddWholeDay,
+ new
java.sql.Timestamp(oddWholeDayExp.roundTime(lowerBoundaryOddWholeDay)));
+ assertNotEquals(oddWholeDay,
+ new
java.sql.Timestamp(oddWholeDayExp.roundTime(lowerBoundaryOddWholeDay - 1)));
+ assertEquals(oddWholeDay,
+ new
java.sql.Timestamp(oddWholeDayExp.roundTime(upperBoundaryOddWholeDay)));
+ assertNotEquals(oddWholeDay,
+ new
java.sql.Timestamp(oddWholeDayExp.roundTime(upperBoundaryOddWholeDay + 1)));
+
+ RoundDateExpression oddWholeDay10Exp =
+ getRoundMsExpression("2022-11-14 0:0:0", TimeUnit.DAY, 10);
+ java.sql.Timestamp oddWholeDay10 =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-14
0:0:0").getTime());
+ long lowerBoundaryOddWholeDay10 = oddWholeDay10.getTime() - 10 *
HALF_DAY;
+ long upperBoundaryOddWholeDay10 = oddWholeDay10.getTime() + 10 *
HALF_DAY - 1;
+ assertEquals(lowerBoundaryOddWholeDay10,
+ oddWholeDay10Exp.rangeLower(oddWholeDay.getTime()));
+ assertEquals(upperBoundaryOddWholeDay10,
+ oddWholeDay10Exp.rangeUpper(oddWholeDay.getTime()));
+ assertEquals(oddWholeDay10,
+ new
java.sql.Timestamp(oddWholeDay10Exp.roundTime(lowerBoundaryOddWholeDay10)));
+ assertNotEquals(oddWholeDay10,
+ new
java.sql.Timestamp(oddWholeDay10Exp.roundTime(lowerBoundaryOddWholeDay10 - 1)));
+ assertEquals(oddWholeDay10,
+ new
java.sql.Timestamp(oddWholeDay10Exp.roundTime(upperBoundaryOddWholeDay10)));
+ assertNotEquals(oddWholeDay10,
+ new
java.sql.Timestamp(oddWholeDay10Exp.roundTime(upperBoundaryOddWholeDay10 + 1)));
+
+ RoundDateExpression oddWholeDay3Exp =
+ getRoundMsExpression("2022-11-12 0:0:0", TimeUnit.DAY, 3);
+ java.sql.Timestamp oddWholeDay3 =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-12
0:0:0").getTime());
+ long lowerBoundaryOddWholeDay3 = oddWholeDay3.getTime() - 3 * HALF_DAY;
+ long upperBoundaryOddWholeDay3 = oddWholeDay3.getTime() + 3 * HALF_DAY
- 1;
+ assertEquals(lowerBoundaryOddWholeDay3,
oddWholeDay3Exp.rangeLower(oddWholeDay.getTime()));
+ assertEquals(upperBoundaryOddWholeDay3,
oddWholeDay3Exp.rangeUpper(oddWholeDay.getTime()));
+ assertEquals(oddWholeDay3,
+ new
java.sql.Timestamp(oddWholeDay3Exp.roundTime(lowerBoundaryOddWholeDay3)));
+ assertNotEquals(oddWholeDay3,
+ new
java.sql.Timestamp(oddWholeDay3Exp.roundTime(lowerBoundaryOddWholeDay3 - 1)));
+ assertEquals(oddWholeDay3,
+ new
java.sql.Timestamp(oddWholeDay3Exp.roundTime(upperBoundaryOddWholeDay3)));
+ assertNotEquals(oddWholeDay3,
+ new
java.sql.Timestamp(oddWholeDay3Exp.roundTime(upperBoundaryOddWholeDay3 + 1)));
+
+ RoundDateExpression evenWholeDayExp =
+ getRoundMsExpression("2022-11-12 0:0:0", TimeUnit.DAY, 1);
+ java.sql.Timestamp evenWholeDay =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-11-12
0:0:0").getTime());
+ long lowerBoundaryEvenWholeDay = evenWholeDay.getTime() - HALF_DAY;
+ long upperBoundaryEvenWholeDay = evenWholeDay.getTime() + HALF_DAY - 1;
+ assertEquals(lowerBoundaryEvenWholeDay,
evenWholeDayExp.rangeLower(evenWholeDay.getTime()));
+ assertEquals(upperBoundaryEvenWholeDay,
evenWholeDayExp.rangeUpper(evenWholeDay.getTime()));
+ assertEquals(evenWholeDay,
+ new
java.sql.Timestamp(evenWholeDayExp.roundTime(lowerBoundaryEvenWholeDay)));
+ assertNotEquals(evenWholeDay,
+ new
java.sql.Timestamp(evenWholeDayExp.roundTime(lowerBoundaryEvenWholeDay - 1)));
+ assertEquals(evenWholeDay,
+ new
java.sql.Timestamp(evenWholeDayExp.roundTime(upperBoundaryEvenWholeDay)));
+ assertNotEquals(evenWholeDay,
+ new
java.sql.Timestamp(evenWholeDayExp.roundTime(upperBoundaryEvenWholeDay + 1)));
+
+ // Stateless, we can reuse it for every week test
+ RoundWeekExpression roundWeekExpression = new RoundWeekExpression();
+ java.sql.Timestamp wholeWeekOdd =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-10-10
0:0:0").getTime());
+ long lowerBoundaryWholeWeekOdd = wholeWeekOdd.getTime() - (HALF_WEEK -
1);
+ long upperBoundaryWholeWeekOdd = wholeWeekOdd.getTime() + HALF_WEEK -
1;
+ assertEquals(lowerBoundaryWholeWeekOdd,
+ roundWeekExpression.rangeLower(wholeWeekOdd.getTime()));
+ assertEquals(upperBoundaryWholeWeekOdd,
+ roundWeekExpression.rangeUpper(wholeWeekOdd.getTime()));
+ assertEquals(wholeWeekOdd,
+ new java.sql.Timestamp(roundWeekExpression.roundDateTime(new
org.joda.time.DateTime(
+ lowerBoundaryWholeWeekOdd,
GJChronology.getInstanceUTC()))));
+ assertNotEquals(wholeWeekOdd,
+ new java.sql.Timestamp(roundWeekExpression.roundDateTime(new
org.joda.time.DateTime(
+ lowerBoundaryWholeWeekOdd - 1,
GJChronology.getInstanceUTC()))));
+ assertEquals(wholeWeekOdd,
+ new java.sql.Timestamp(roundWeekExpression.roundDateTime(new
org.joda.time.DateTime(
+ upperBoundaryWholeWeekOdd,
GJChronology.getInstanceUTC()))));
+ assertNotEquals(wholeWeekOdd,
+ new java.sql.Timestamp(roundWeekExpression.roundDateTime(new
org.joda.time.DateTime(
+ upperBoundaryWholeWeekOdd + 1,
GJChronology.getInstanceUTC()))));
+
+ java.sql.Timestamp wholeWeekEven =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-10-17
0:0:0").getTime());
+ long lowerBoundaryWholeWeekEven = wholeWeekEven.getTime() - HALF_WEEK;
+ long upperBoundaryWholeWeekEven = wholeWeekEven.getTime() + HALF_WEEK;
+ assertEquals(lowerBoundaryWholeWeekEven,
+ roundWeekExpression.rangeLower(wholeWeekEven.getTime()));
+ assertEquals(upperBoundaryWholeWeekEven,
+ roundWeekExpression.rangeUpper(wholeWeekEven.getTime()));
+ assertEquals(wholeWeekEven,
+ new java.sql.Timestamp(roundWeekExpression.roundDateTime(new
org.joda.time.DateTime(
+ lowerBoundaryWholeWeekEven,
GJChronology.getInstanceUTC()))));
+ assertNotEquals(wholeWeekEven,
+ new java.sql.Timestamp(roundWeekExpression.roundDateTime(new
org.joda.time.DateTime(
+ lowerBoundaryWholeWeekEven - 1,
GJChronology.getInstanceUTC()))));
+ assertEquals(wholeWeekEven,
+ new java.sql.Timestamp(roundWeekExpression.roundDateTime(new
org.joda.time.DateTime(
+ upperBoundaryWholeWeekEven,
GJChronology.getInstanceUTC()))));
+ assertNotEquals(wholeWeekEven,
+ new java.sql.Timestamp(roundWeekExpression.roundDateTime(new
org.joda.time.DateTime(
+ upperBoundaryWholeWeekEven + 1,
GJChronology.getInstanceUTC()))));
+
+ RoundMonthExpression roundMonthExpression = new RoundMonthExpression();
+ // We're still using roundHalfEven here for backwards compatibility
+ java.sql.Timestamp wholeMonthEven =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-06-1
0:0:0").getTime());
+ // May is 31 days
+ long lowerBoundaryWholeMonthEven = wholeMonthEven.getTime() - 31 *
HALF_DAY;
+ // June is 30 days
+ long upperBoundaryWholeMonthEven = wholeMonthEven.getTime() + 30 *
HALF_DAY;
+ assertEquals(lowerBoundaryWholeMonthEven,
+ roundMonthExpression.rangeLower(wholeMonthEven.getTime()));
+ assertEquals(upperBoundaryWholeMonthEven,
+ roundMonthExpression.rangeUpper(wholeMonthEven.getTime()));
+ assertEquals(wholeMonthEven,
+ new java.sql.Timestamp(roundMonthExpression.roundDateTime(new
org.joda.time.DateTime(
+ lowerBoundaryWholeMonthEven,
GJChronology.getInstanceUTC()))));
+ assertNotEquals(wholeMonthEven,
+ new java.sql.Timestamp(roundMonthExpression.roundDateTime(new
org.joda.time.DateTime(
+ lowerBoundaryWholeMonthEven - 1,
GJChronology.getInstanceUTC()))));
+ assertEquals(wholeMonthEven,
+ new java.sql.Timestamp(roundMonthExpression.roundDateTime(new
org.joda.time.DateTime(
+ upperBoundaryWholeMonthEven,
GJChronology.getInstanceUTC()))));
+ assertNotEquals(wholeMonthEven,
+ new java.sql.Timestamp(roundMonthExpression.roundDateTime(new
org.joda.time.DateTime(
+ upperBoundaryWholeMonthEven + 1,
GJChronology.getInstanceUTC()))));
+
+ // We're still using roundHalfEven here for backwards compatibility
+ java.sql.Timestamp wholeMonthOdd =
+ new java.sql.Timestamp(DateUtil.parseDate("2022-07-1
0:0:0").getTime());
+ // June is 30 days
+ long lowerBoundaryWholeMonthOdd = wholeMonthOdd.getTime() - 30 *
HALF_DAY + 1;
+ // July is 31 days
+ long upperBoundaryWholeMonthOdd = wholeMonthOdd.getTime() + 31 *
HALF_DAY - 1;
+ assertEquals(lowerBoundaryWholeMonthOdd,
+ roundMonthExpression.rangeLower(wholeMonthOdd.getTime()));
+ assertEquals(upperBoundaryWholeMonthOdd,
+ roundMonthExpression.rangeUpper(wholeMonthOdd.getTime()));
+ assertEquals(wholeMonthOdd,
+ new java.sql.Timestamp(roundMonthExpression.roundDateTime(new
org.joda.time.DateTime(
+ lowerBoundaryWholeMonthOdd,
GJChronology.getInstanceUTC()))));
+ assertNotEquals(wholeMonthOdd,
+ new java.sql.Timestamp(roundMonthExpression.roundDateTime(new
org.joda.time.DateTime(
+ lowerBoundaryWholeMonthOdd - 1,
GJChronology.getInstanceUTC()))));
+ assertEquals(wholeMonthOdd,
+ new java.sql.Timestamp(roundMonthExpression.roundDateTime(new
org.joda.time.DateTime(
+ upperBoundaryWholeMonthOdd,
GJChronology.getInstanceUTC()))));
+ assertNotEquals(wholeMonthOdd,
+ new java.sql.Timestamp(roundMonthExpression.roundDateTime(new
org.joda.time.DateTime(
+ upperBoundaryWholeMonthOdd + 1,
GJChronology.getInstanceUTC()))));
+
+ // We're still using roundHalfEven here for backwards compatibility
+ java.sql.Timestamp wholeMonthLeap =
+ new java.sql.Timestamp(DateUtil.parseDate("2024-02-1
0:0:0").getTime());
+ // January is 31 days
+ long lowerBoundaryWholeMonthLeap = wholeMonthLeap.getTime() - 31 *
HALF_DAY;
+ // February is is 29 days
Review Comment:
Thanks, fixed the typos you called out.
> calling Joda-based round() function on temporal PK field causes division by
> zero error
> --------------------------------------------------------------------------------------
>
> Key: PHOENIX-6823
> URL: https://issues.apache.org/jira/browse/PHOENIX-6823
> Project: Phoenix
> Issue Type: Bug
> Components: core
> Affects Versions: 5.2.0, 5.1.2
> Reporter: Istvan Toth
> Assignee: Istvan Toth
> Priority: Major
>
>
> {noformat}
> 0: jdbc:phoenix:> create table bubu (df date primary key);
> No rows affected (0.689 seconds)
> 0: jdbc:phoenix:> select * from bubu where round(df,'YEAR',1)=DATE
> '2022-01-01 00:00:00';
> java.lang.ArithmeticException: / by zero
> at
> org.apache.phoenix.expression.function.RoundDateExpression$1.getKeyRange(RoundDateExpression.java:272)
> ...{noformat}
> This is caused by getKeyRange not being updated when the Joda-based time
> units were added.
> Also, the keyrange pushdown logic is just wrong, even for the non-joda cases.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
