From c0d999e85f22a2a46862c1323a39bc5add54f923 Mon Sep 17 00:00:00 2001 From: Oscar Westra van Holthe - Kind Date: Mon, 25 Sep 2023 12:36:30 +0200 Subject: [PATCH 1/5] AVRO-2123: Add TimePeriod This adds a new `java.time.TemporalAmount` implementation, which supports the Avro `duration` logical type (neither `java.time.Period` nor `java.time.Duration` support it). --- .../java/org/apache/avro/util/TimePeriod.java | 380 ++++++++++++++++++ .../org/apache/avro/util/TimePeriodTest.java | 304 ++++++++++++++ 2 files changed, 684 insertions(+) create mode 100644 lang/java/avro/src/main/java/org/apache/avro/util/TimePeriod.java create mode 100644 lang/java/avro/src/test/java/org/apache/avro/util/TimePeriodTest.java diff --git a/lang/java/avro/src/main/java/org/apache/avro/util/TimePeriod.java b/lang/java/avro/src/main/java/org/apache/avro/util/TimePeriod.java new file mode 100644 index 00000000000..2e4b05db6e8 --- /dev/null +++ b/lang/java/avro/src/main/java/org/apache/avro/util/TimePeriod.java @@ -0,0 +1,380 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.avro.util; + +import java.io.Serializable; +import java.time.DateTimeException; +import java.time.Duration; +import java.time.Period; +import java.time.chrono.ChronoPeriod; +import java.time.chrono.IsoChronology; +import java.time.temporal.ChronoUnit; +import java.time.temporal.Temporal; +import java.time.temporal.TemporalAmount; +import java.time.temporal.TemporalUnit; +import java.time.temporal.UnsupportedTemporalTypeException; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +import static java.time.temporal.ChronoUnit.DAYS; +import static java.time.temporal.ChronoUnit.MILLIS; +import static java.time.temporal.ChronoUnit.MONTHS; +import static java.util.Collections.unmodifiableList; +import static java.util.Objects.requireNonNull; + +/** + *

A temporal amount to model an + * {@link org.apache.avro.LogicalTypes.Duration Avro duration} (the logical type). + *

+ * + *

It consists of a number of months, days and milliseconds, all modelled as an + * unsigned integer.

+ * + *

Compared to {@link Period java.time.Period}, this class has a smaller range + * ('only' supporting a little less than 358 million years), and cannot support negative time periods.

+ * + *

Compared to {@link Duration java.time.Duration}, this class has less + * precision (milliseconds compared to nanoseconds), cannot support negative durations, and has a much smaller range. + * Where {@code java.time.Duration} supports fixed ranges up to about 68 years, {@code TimePeriod} can only handle about + * 49 days.

+ * + *

Given the time span of what we do,

+ * supporting a little less than 358 million years), and cannot support negative time periods.

+ * + *

Comparison with the regular {@code java.time} classes:

+ * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
TimePeriod{@link Period}{@link Duration}
Precisionmillisecondsdaysnanoseconds
Time range (approx.)0 - 49 daysunsupported-68 - 68 years
Date range (approx.)0 to 370 million years-2.3 to 2.3 billion yearsunsupported
+ * + * @see Avro 1.11 specification on duration + */ +public final class TimePeriod implements TemporalAmount, Serializable { + private static final long MAX_UNSIGNED_INT = 0xffffffffL; + private static final long MONTHS_PER_YEAR = 12; + private static final long MONTHS_PER_DECADE = MONTHS_PER_YEAR * 10; + private static final long MONTHS_PER_CENTURY = MONTHS_PER_DECADE * 10; + private static final long MONTHS_PER_MILLENNIUM = MONTHS_PER_CENTURY * 10; + private static final long MILLIS_PER_SECOND = 1_000; + private static final long MILLIS_PER_MINUTE = MILLIS_PER_SECOND * 60; + private static final long MILLIS_PER_HOUR = MILLIS_PER_MINUTE * 60; + private static final long MILLIS_IN_HALF_DAY = MILLIS_PER_HOUR * 12; + private static final long MICROS_PER_MILLI = 1_000; + private static final long NANOS_PER_MILLI = 1_000_000; + + private final long months; + private final long days; + private final long millis; + + /** + * Create a TimePeriod from another TemporalAmount, such as a {@link Period} or a {@link Duration}. + * + * @param amount a temporal amount + * @return the corresponding TimePeriod + */ + public static TimePeriod from(TemporalAmount amount) { + if (requireNonNull(amount, "amount") instanceof TimePeriod) { + return (TimePeriod) amount; + } + if (amount instanceof ChronoPeriod) { + if (!IsoChronology.INSTANCE.equals(((ChronoPeriod) amount).getChronology())) { + throw new DateTimeException("TimePeriod requires ISO chronology: " + amount); + } + } + long months = 0; + long days = 0; + long millis = 0; + for (TemporalUnit unit : amount.getUnits()) { + if (unit instanceof ChronoUnit) { + long unitAmount = amount.get(unit); + switch ((ChronoUnit) unit) { + case MILLENNIA: + months = unsignedInt(months + unitAmount * MONTHS_PER_MILLENNIUM); + break; + case CENTURIES: + months = unsignedInt(months + unitAmount * MONTHS_PER_CENTURY); + break; + case DECADES: + months = unsignedInt(months + unitAmount * MONTHS_PER_DECADE); + break; + case YEARS: + months = unsignedInt(months + unitAmount * MONTHS_PER_YEAR); + break; + case MONTHS: + months = unsignedInt(months + unitAmount); + break; + case WEEKS: + days = unsignedInt(days + unitAmount * 7); + break; + case DAYS: + days = unsignedInt(days + unitAmount); + break; + case HALF_DAYS: + days = unsignedInt(days + (unitAmount / 2)); // Truncates halves + if (unitAmount % 2 != 0) { + millis = unsignedInt(millis + MILLIS_IN_HALF_DAY); + } + break; + case HOURS: + millis = unsignedInt(millis + unitAmount * MILLIS_PER_HOUR); + break; + case MINUTES: + millis = unsignedInt(millis + unitAmount * MILLIS_PER_MINUTE); + break; + case SECONDS: + millis = unsignedInt(millis + unitAmount * MILLIS_PER_SECOND); + break; + case MILLIS: + millis = unsignedInt(millis + unitAmount); + break; + case MICROS: + if (unitAmount % MICROS_PER_MILLI != 0) { + throw new DateTimeException( + "Cannot add " + unitAmount + " microseconds: not a whole number of milliseconds"); + } + millis = unsignedInt(millis + unitAmount / MICROS_PER_MILLI); + break; + case NANOS: + if (unitAmount % NANOS_PER_MILLI != 0) { + throw new DateTimeException( + "Cannot add " + unitAmount + " nanoseconds: not a whole number of milliseconds"); + } + millis = unsignedInt(millis + unitAmount / NANOS_PER_MILLI); + break; + default: + throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit); + } + } else { + throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit); + } + } + return new TimePeriod(months, days, millis); + } + + /** + * Create a TimePeriod from a number of months, days and milliseconds + * + * @param months a number of months + * @param days a number of days + * @param millis a number of milliseconds + * @return the corresponding TimePeriod + * @throws ArithmeticException if any of the parameters does not fit an unsigned long (0..4294967296) + */ + public static TimePeriod of(long months, long days, long millis) { + return new TimePeriod(unsignedInt(months), unsignedInt(days), unsignedInt(millis)); + } + + private static long unsignedInt(long number) { + if (number != (number & MAX_UNSIGNED_INT)) { + throw new ArithmeticException("Overflow/underflow of unsigned int"); + } + return number; + } + + private TimePeriod(long months, long days, long millis) { + this.months = months; + this.days = days; + this.millis = millis; + } + + public Duration toDuration() { + return Duration.from(this); + } + + public Period toPeriod() { + if (isDateBased()) { + // We use unsigned ints, which have double the range of a signed int that + // Period uses. We can split months to years and months to ensure there's no + // overflow. But we cannot split days, as both days and months have varying + // lengths. + int yearsAsInt = (int) (months / MONTHS_PER_YEAR); + int monthsAsInt = (int) (months % MONTHS_PER_YEAR); + int daysAsInt = (int) days; + if (days != daysAsInt) { + throw new DateTimeException( + "Too many days: a Period can contain at most " + Integer.MAX_VALUE + " days."); + } + return Period.ofYears(yearsAsInt).withMonths(monthsAsInt).withDays(daysAsInt); + } + throw new DateTimeException("Cannot convert this TimePeriod to a Period: is not date based"); + } + + /** + * Determines if the TimePeriod is date based (i.e., if its milliseconds component is 0). + * + * @return {@code true} iff the TimePeriod is date based + */ + public boolean isDateBased() { + return millis == 0; + } + + /** + * Determines if the TimePeriod is time based (i.e., if its months and days components are 0). + * + * @return {@code true} iff the TimePeriod is time based + */ + public boolean isTimeBased() { + return months == 0 && days == 0; + } + + public long getMonths() { + return months; + } + + public long getDays() { + return days; + } + + public long getMillis() { + return millis; + } + + @Override + public long get(TemporalUnit unit) { + if (unit == MONTHS) { + return months; + } else if (unit == DAYS) { + return days; + } else if (unit == MILLIS) { + return millis; + } else { + throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit); + } + } + + @Override + public List getUnits() { + List units = new ArrayList<>(); + // The zero-checks ensure compatibility with the Java Time classes Period and + // Duration where possible. + if (months != 0) { + units.add(MONTHS); + } + if (days != 0) { + units.add(DAYS); + } + if (millis != 0) { + units.add(MILLIS); + } + return unmodifiableList(units); + } + + @Override + public Temporal addTo(Temporal temporal) { + return addTo(temporal, months, days, millis); + } + + @Override + public Temporal subtractFrom(Temporal temporal) { + return addTo(temporal, -months, -days, -millis); + } + + private Temporal addTo(Temporal temporal, long months, long days, long millis) { + // The zero-checks ensure we can add a TimePeriod to a Temporal even when it + // does not support all fields, as long as the unsupported fields are zero. + if (months != 0) { + temporal = temporal.plus(months, MONTHS); + } + if (days != 0) { + temporal = temporal.plus(days, DAYS); + } + if (millis != 0) { + temporal = temporal.plus(millis, MILLIS); + } + return temporal; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + TimePeriod that = (TimePeriod) o; + return months == that.months && days == that.days && millis == that.millis; + } + + @Override + public int hashCode() { + return Objects.hash(months, days, millis); + } + + @Override + public String toString() { + StringBuilder buffer = new StringBuilder(); + buffer.append("P"); + if (months != 0) { + int years = (int) (months / MONTHS_PER_YEAR); + int monthsLeft = (int) (months % MONTHS_PER_YEAR); + if (years != 0) { + buffer.append(years).append("Y"); + } + if (monthsLeft != 0) { + buffer.append(monthsLeft).append("M"); + } + } + if (days != 0 || (months == 0 && millis == 0)) { + buffer.append(days); + } + if (millis != 0) { + long millisLeft = millis; + int hours = (int) (millisLeft / MILLIS_PER_HOUR); + millisLeft -= MILLIS_PER_HOUR * hours; + int minutes = (int) (millisLeft / MILLIS_PER_MINUTE); + millisLeft -= MILLIS_PER_MINUTE * minutes; + int seconds = (int) (millisLeft / MILLIS_PER_SECOND); + millisLeft -= MILLIS_PER_SECOND * seconds; + if (millisLeft != 0) { + buffer.append(String.format("T%02d:%02d:%02d.%03d", hours, minutes, seconds, millisLeft)); + } else if (seconds != 0) { + buffer.append(String.format("T%02d:%02d:%02d", hours, minutes, seconds)); + } else if (minutes != 0) { + buffer.append(String.format("T%02d:%02d", hours, minutes)); + } else { + buffer.append(String.format("T%02d", hours)); + } + } + return buffer.toString(); + } +} diff --git a/lang/java/avro/src/test/java/org/apache/avro/util/TimePeriodTest.java b/lang/java/avro/src/test/java/org/apache/avro/util/TimePeriodTest.java new file mode 100644 index 00000000000..eac67652c7f --- /dev/null +++ b/lang/java/avro/src/test/java/org/apache/avro/util/TimePeriodTest.java @@ -0,0 +1,304 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.avro.util; + +import org.junit.jupiter.api.Test; + +import java.time.DateTimeException; +import java.time.Duration; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.Period; +import java.time.chrono.IsoChronology; +import java.time.chrono.JapaneseChronology; +import java.time.temporal.ChronoUnit; +import java.time.temporal.Temporal; +import java.time.temporal.TemporalAmount; +import java.time.temporal.TemporalUnit; +import java.time.temporal.UnsupportedTemporalTypeException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import static java.time.temporal.ChronoUnit.DAYS; +import static java.time.temporal.ChronoUnit.ERAS; +import static java.time.temporal.ChronoUnit.MICROS; +import static java.time.temporal.ChronoUnit.MILLIS; +import static java.time.temporal.ChronoUnit.MONTHS; +import static java.time.temporal.ChronoUnit.NANOS; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class TimePeriodTest { + // This Long is too large to fit into an unsigned int. + private static final long TOO_LARGE = Integer.MAX_VALUE * 3L; + + @Test + void validateConstruction() { + TimePeriod timePeriod = TimePeriod.of(12, 34, 56); + assertSame(timePeriod, TimePeriod.from(timePeriod)); + assertComponents(12, 34, 56, timePeriod); + + assertComponents(14, 3, 0, TimePeriod.from(IsoChronology.INSTANCE.period(1,2,3))); + + assertComponents(36_000, 0, 0, TimePeriod.from(TimeAmount.of(ChronoUnit.MILLENNIA, 3))); + assertComponents(3_600, 0, 0, TimePeriod.from(TimeAmount.of(ChronoUnit.CENTURIES, 3))); + assertComponents(360, 0, 0, TimePeriod.from(TimeAmount.of(ChronoUnit.DECADES, 3))); + assertComponents(36, 0, 0, TimePeriod.from(TimeAmount.of(ChronoUnit.YEARS, 3))); + assertComponents(3, 0, 0, TimePeriod.from(TimeAmount.of(MONTHS, 3))); + + assertComponents(0, 21, 0, TimePeriod.from(TimeAmount.of(ChronoUnit.WEEKS, 3))); + assertComponents(0, 3, 0, TimePeriod.from(TimeAmount.of(DAYS, 3))); + assertComponents(0, 2, 0, TimePeriod.from(TimeAmount.of(ChronoUnit.HALF_DAYS, 4))); + assertComponents(0, 2, 43_200_000, TimePeriod.from(TimeAmount.of(ChronoUnit.HALF_DAYS, 5))); + + assertComponents(0, 0, 10_800_000, TimePeriod.from(TimeAmount.of(ChronoUnit.HOURS, 3))); + assertComponents(0, 0, 180_000, TimePeriod.from(TimeAmount.of(ChronoUnit.MINUTES, 3))); + assertComponents(0, 0, 3_000, TimePeriod.from(TimeAmount.of(ChronoUnit.SECONDS, 3))); + assertComponents(0, 0, 3, TimePeriod.from(TimeAmount.of(MILLIS, 3))); + assertComponents(0, 0, 3, TimePeriod.from(TimeAmount.of(MICROS, 3_000))); + assertComponents(0, 0, 3, TimePeriod.from(TimeAmount.of(NANOS, 3_000_000))); + + // Micros and nanos must be a multiple of milliseconds + assertThrows(DateTimeException.class, () -> TimePeriod.from(TimeAmount.of(ChronoUnit.MICROS, 3))); + assertThrows(DateTimeException.class, () -> TimePeriod.from(TimeAmount.of(ChronoUnit.NANOS, 3))); + // Unsupported cases (null, non-ISO chronology, unknown temporal unit, non-ChronoUnit) + assertThrows(NullPointerException.class, () -> TimePeriod.from(null)); + assertThrows(DateTimeException.class, () -> TimePeriod.from(JapaneseChronology.INSTANCE.period(1,2,3))); + assertThrows(UnsupportedTemporalTypeException.class, () -> TimePeriod.from(TimeAmount.of(ChronoUnit.ERAS, 1))); + assertThrows(UnsupportedTemporalTypeException.class, () -> TimePeriod.from(TimeAmount.of(DummyUnit.INSTANCE, 3))); + // Arguments are long, but must fit an unsigned long + assertThrows(ArithmeticException.class, () -> TimePeriod.of(TOO_LARGE, 0, 0)); + assertThrows(ArithmeticException.class, () -> TimePeriod.of(0, TOO_LARGE, 0)); + assertThrows(ArithmeticException.class, () -> TimePeriod.of(0, 0, TOO_LARGE)); + + // Odd one out: querying an unsupported temporal unit + // (assertComponents handles all valid cases) + assertThrows(UnsupportedTemporalTypeException.class, () -> TimePeriod.of(1,1,1).get(ERAS)); + } + + @Test + void checkConversionsFromJavaTime() { + assertEquals(TimePeriod.of(12, 0, 0), TimePeriod.from(Period.ofYears(1))); + assertEquals(TimePeriod.of(2, 0, 0), TimePeriod.from(Period.ofMonths(2))); + assertEquals(TimePeriod.of(0, 21, 0), TimePeriod.from(Period.ofWeeks(3))); + assertEquals(TimePeriod.of(0, 4, 0), TimePeriod.from(Period.ofDays(4))); + + assertEquals(TimePeriod.of(0, 0, 1), TimePeriod.from(Duration.ofNanos(1_000_000))); + assertEquals(TimePeriod.of(0, 0, 2), TimePeriod.from(Duration.ofMillis(2))); + assertEquals(TimePeriod.of(0, 0, 3_000), TimePeriod.from(Duration.ofSeconds(3))); + assertEquals(TimePeriod.of(0, 0, 240000), TimePeriod.from(Duration.ofMinutes(4))); + assertEquals(TimePeriod.of(0, 0, 18000000), TimePeriod.from(Duration.ofHours(5))); + // Duration never takes into account things like daylight saving + assertEquals(TimePeriod.of(0, 0, 518400000), TimePeriod.from(Duration.ofDays(6))); + } + + @Test + void checkConversionsToJavaTime() { + TimePeriod months = TimePeriod.of(1, 0, 0); + TimePeriod days = TimePeriod.of(0, 2, 0); + TimePeriod time = TimePeriod.of(0, 0, 3); + TimePeriod all = TimePeriod.of(1, 2, 3); + + assertTrue(months.isDateBased()); + assertTrue(days.isDateBased()); + assertFalse(all.isDateBased()); + assertFalse(time.isDateBased()); + + assertEquals(Period.of(0, 1, 0), months.toPeriod()); + assertEquals(Period.of(0, 0, 2), days.toPeriod()); + assertThrows(DateTimeException.class, all::toPeriod); + assertThrows(DateTimeException.class, time::toPeriod); + + assertThrows(DateTimeException.class, () -> TimePeriod.of(0, Integer.MAX_VALUE * 2L, 0).toPeriod()); + + assertFalse(months.isTimeBased()); + assertFalse(days.isTimeBased()); + assertFalse(all.isTimeBased()); + assertTrue(time.isTimeBased()); + + assertThrows(DateTimeException.class, months::toDuration); + // Note: though Duration supports this, it uses a fixed 86400 seconds + assertEquals(Duration.ofSeconds(172800), days.toDuration()); + assertThrows(DateTimeException.class, all::toDuration); + assertEquals(Duration.ofMillis(3), time.toDuration()); + } + + @Test + void checkAddingToTemporalItems() { + TimePeriod monthAndTwoDays = TimePeriod.of(1, 2, 0); + TimePeriod threeMillis = TimePeriod.of(0, 0, 3); + TimePeriod complexTimePeriod = TimePeriod.of(1, 2, 3); + + LocalDateTime localDateTime = LocalDateTime.of(2001, 2, 3, 4, 5, 6, 7_000_000); + LocalDate localDate = LocalDate.of(2001, 2, 3); + LocalTime localTime = LocalTime.of(4, 5, 6, 7_000_000); + + assertEquals(localDateTime.plusMonths(1).plusDays(2), localDateTime.plus(monthAndTwoDays)); + assertEquals(localDateTime.plus(3, MILLIS), localDateTime.plus(threeMillis)); + assertEquals(localDateTime.plusMonths(1).plusDays(2).plus(3, MILLIS), localDateTime.plus(complexTimePeriod)); + + assertEquals(localDate.plusMonths(1).plusDays(2), localDate.plus(monthAndTwoDays)); + + assertEquals(localTime.plus(3, MILLIS), localTime.plus(threeMillis)); + + assertEquals(localDateTime.minusMonths(1).minusDays(2), localDateTime.minus(monthAndTwoDays)); + assertEquals(localDateTime.minus(3, MILLIS), localDateTime.minus(threeMillis)); + assertEquals(localDateTime.minusMonths(1).minusDays(2).minus(3, MILLIS), localDateTime.minus(complexTimePeriod)); + + assertEquals(localDate.minusMonths(1).minusDays(2), localDate.minus(monthAndTwoDays)); + + assertEquals(localTime.minus(3, MILLIS), localTime.minus(threeMillis)); + } + + @Test + void checkEqualityTests() { + TimePeriod timePeriod1a = TimePeriod.of(1, 2, 3); + TimePeriod timePeriod1b = TimePeriod.of(1, 2, 3); + TimePeriod timePeriod2 = TimePeriod.of(9, 9, 9); + TimePeriod timePeriod3 = TimePeriod.of(1, 9, 9); + TimePeriod timePeriod4 = TimePeriod.of(1, 2, 9); + + //noinspection EqualsWithItself + assertEquals(timePeriod1a, timePeriod1a); + assertEquals(timePeriod1a, timePeriod1b); + assertEquals(timePeriod1a.hashCode(), timePeriod1b.hashCode()); + + assertNotEquals(timePeriod1a, null); + //noinspection AssertBetweenInconvertibleTypes + assertNotEquals(timePeriod1a, "not equal"); + assertNotEquals(timePeriod1a, timePeriod2); + assertNotEquals(timePeriod1a.hashCode(), timePeriod2.hashCode()); + assertNotEquals(timePeriod1a, timePeriod3); + assertNotEquals(timePeriod1a.hashCode(), timePeriod3.hashCode()); + assertNotEquals(timePeriod1a, timePeriod4); + assertNotEquals(timePeriod1a.hashCode(), timePeriod4.hashCode()); + } + + @Test + void checkStringRepresentation() { + assertEquals("P0", TimePeriod.of(0,0,0).toString()); + assertEquals("P1Y", TimePeriod.of(12,0,0).toString()); + assertEquals("P2M", TimePeriod.of(2,0,0).toString()); + assertEquals("P3", TimePeriod.of(0,3,0).toString()); + assertEquals("P1Y2M3", TimePeriod.of(14,3,0).toString()); + assertEquals("PT04", TimePeriod.of(0,0, 14400000).toString()); + assertEquals("PT00:05", TimePeriod.of(0,0, 300000).toString()); + assertEquals("PT00:00:06", TimePeriod.of(0,0, 6000).toString()); + assertEquals("PT00:00:00.007", TimePeriod.of(0,0, 7).toString()); + assertEquals("P1Y2M3T04:05:06.007", TimePeriod.of(14,3, 14706007).toString()); + + // Days and millis will never overflow to months/days, to respect differences + // in months and days (daylight saving). + assertEquals("P123T1193:02:47.295", TimePeriod.of(0,123, 4294967295L).toString()); + } + + private void assertComponents(long months, long days, long millis, TimePeriod timePeriod) { + List expectedUnits = new ArrayList<>(Arrays.asList(MONTHS, DAYS, MILLIS)); + if (months == 0) { + expectedUnits.remove(MONTHS); + } + if (days == 0) { + expectedUnits.remove(DAYS); + } + if (millis == 0) { + expectedUnits.remove(MILLIS); + } + assertEquals(expectedUnits, timePeriod.getUnits()); + + assertEquals(months, timePeriod.getMonths()); + assertEquals(months, timePeriod.get(MONTHS)); + assertEquals(days, timePeriod.getDays()); + assertEquals(days, timePeriod.get(DAYS)); + assertEquals(millis, timePeriod.getMillis()); + assertEquals(millis, timePeriod.get(MILLIS)); + } + + private static class TimeAmount implements TemporalAmount { + private final Map amountsPerUnit = new LinkedHashMap<>(); + + static TimeAmount of(TemporalUnit unit, long amount) { + return new TimeAmount().with(unit, amount); + } + + TimeAmount with(TemporalUnit unit, long amount) { + amountsPerUnit.put(unit, amount); + return this; + } + + @Override + public long get(TemporalUnit unit) { + return amountsPerUnit.get(unit); + } + + @Override + public List getUnits() { + return new ArrayList<>(amountsPerUnit.keySet()); + } + + @Override + public Temporal addTo(Temporal temporal) { + throw new UnsupportedOperationException(); + } + + @Override + public Temporal subtractFrom(Temporal temporal) { + throw new UnsupportedOperationException(); + } + } + + private static class DummyUnit implements TemporalUnit { + private static final DummyUnit INSTANCE = new DummyUnit(); + @Override + public Duration getDuration() { + return null; + } + + @Override + public boolean isDurationEstimated() { + return false; + } + + @Override + public boolean isDateBased() { + return false; + } + + @Override + public boolean isTimeBased() { + return false; + } + + @Override + public R addTo(R temporal, long amount) { + return null; + } + + @Override + public long between(Temporal temporal1Inclusive, Temporal temporal2Exclusive) { + return 0; + } + } +} From d1015cf1a6e9b22d02a050fed63b885af856349b Mon Sep 17 00:00:00 2001 From: Oscar Westra van Holthe - Kind Date: Mon, 25 Sep 2023 14:11:14 +0200 Subject: [PATCH 2/5] AVRO-2123: Add logical type "duration" Also refactors logical type "uuid" to include validation. --- .../java/org/apache/avro/LogicalTypes.java | 45 ++++++++++++++++-- .../java/org/apache/avro/TestLogicalType.java | 46 +++++++++++++++---- 2 files changed, 78 insertions(+), 13 deletions(-) diff --git a/lang/java/avro/src/main/java/org/apache/avro/LogicalTypes.java b/lang/java/avro/src/main/java/org/apache/avro/LogicalTypes.java index 086c5d266a2..fe45cbe204e 100644 --- a/lang/java/avro/src/main/java/org/apache/avro/LogicalTypes.java +++ b/lang/java/avro/src/main/java/org/apache/avro/LogicalTypes.java @@ -18,15 +18,15 @@ package org.apache.avro; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + import java.util.Collections; import java.util.Map; import java.util.Objects; import java.util.ServiceLoader; import java.util.concurrent.ConcurrentHashMap; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - public class LogicalTypes { private static final Logger LOG = LoggerFactory.getLogger(LogicalTypes.class); @@ -182,6 +182,7 @@ private static LogicalType fromSchemaImpl(Schema schema, boolean throwErrors) { } private static final String DECIMAL = "decimal"; + private static final String DURATION = "duration"; private static final String UUID = "uuid"; private static final String DATE = "date"; private static final String TIME_MILLIS = "time-millis"; @@ -201,12 +202,18 @@ public static Decimal decimal(int precision, int scale) { return new Decimal(precision, scale); } - private static final LogicalType UUID_TYPE = new LogicalType("uuid"); + private static final LogicalType UUID_TYPE = new Uuid(); public static LogicalType uuid() { return UUID_TYPE; } + private static final LogicalType DURATION_TYPE = new Duration(); + + public static LogicalType duration() { + return DURATION_TYPE; + } + private static final Date DATE_TYPE = new Date(); public static Date date() { @@ -249,6 +256,36 @@ public static LocalTimestampMicros localTimestampMicros() { return LOCAL_TIMESTAMP_MICROS_TYPE; } + /** Uuid represents a uuid without a time */ + public static class Uuid extends LogicalType { + private Uuid() { + super(UUID); + } + + @Override + public void validate(Schema schema) { + super.validate(schema); + if (schema.getType() != Schema.Type.STRING) { + throw new IllegalArgumentException("Uuid can only be used with an underlying string type"); + } + } + } + + /** Duration represents a duration, consisting on months, days and milliseconds */ + public static class Duration extends LogicalType { + private Duration() { + super(DURATION); + } + + @Override + public void validate(Schema schema) { + super.validate(schema); + if (schema.getType() != Schema.Type.FIXED || schema.getFixedSize() != 12) { + throw new IllegalArgumentException("Duration can only be used with an underlying fixed type of size 12."); + } + } + } + /** Decimal represents arbitrary-precision fixed-scale decimal numbers */ public static class Decimal extends LogicalType { private static final String PRECISION_PROP = "precision"; diff --git a/lang/java/avro/src/test/java/org/apache/avro/TestLogicalType.java b/lang/java/avro/src/test/java/org/apache/avro/TestLogicalType.java index acc8899b21c..fae51c9bf7c 100644 --- a/lang/java/avro/src/test/java/org/apache/avro/TestLogicalType.java +++ b/lang/java/avro/src/test/java/org/apache/avro/TestLogicalType.java @@ -18,16 +18,21 @@ package org.apache.avro; -import java.util.Arrays; -import java.util.concurrent.Callable; - import org.hamcrest.collection.IsMapContaining; import org.junit.jupiter.api.Test; +import java.util.Arrays; +import java.util.concurrent.Callable; + import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; public class TestLogicalType { @@ -59,13 +64,13 @@ void invalidLogicalTypeIgnored() { void decimalWithNonByteArrayTypes() { final LogicalType decimal = LogicalTypes.decimal(5, 2); // test simple types - Schema[] nonBytes = new Schema[] { Schema.createRecord("Record", null, null, false), + Schema[] nonBytes = new Schema[]{Schema.createRecord("Record", null, null, false), Schema.createArray(Schema.create(Schema.Type.BYTES)), Schema.createMap(Schema.create(Schema.Type.BYTES)), Schema.createEnum("Enum", null, null, Arrays.asList("a", "b")), Schema.createUnion(Arrays.asList(Schema.create(Schema.Type.BYTES), Schema.createFixed("fixed", null, null, 4))), Schema.create(Schema.Type.BOOLEAN), Schema.create(Schema.Type.INT), Schema.create(Schema.Type.LONG), Schema.create(Schema.Type.FLOAT), Schema.create(Schema.Type.DOUBLE), Schema.create(Schema.Type.NULL), - Schema.create(Schema.Type.STRING) }; + Schema.create(Schema.Type.STRING)}; for (final Schema schema : nonBytes) { assertThrows("Should reject type: " + schema.getType(), IllegalArgumentException.class, "Logical type decimal must be backed by fixed or bytes", () -> { @@ -197,6 +202,30 @@ void bytesDecimalToFromJson() { assertEquals(schema, parsed, "Constructed and parsed schemas should match"); } + @Test + void uuidExtendsString() { + Schema uuidSchema = LogicalTypes.uuid().addToSchema(Schema.create(Schema.Type.STRING)); + assertEquals(LogicalTypes.uuid(), uuidSchema.getLogicalType()); + + assertThrows("UUID requires a string", IllegalArgumentException.class, + "Uuid can only be used with an underlying string type", + () -> LogicalTypes.uuid().addToSchema(Schema.create(Schema.Type.INT))); + } + + @Test + void durationExtendsFixed12() { + Schema durationSchema = LogicalTypes.duration().addToSchema(Schema.createFixed("f", null, null, 12)); + assertEquals(LogicalTypes.duration(), durationSchema.getLogicalType()); + + assertThrows("Duration requires a fixed(12)", IllegalArgumentException.class, + "Duration can only be used with an underlying fixed type of size 12.", + () -> LogicalTypes.duration().addToSchema(Schema.create(Schema.Type.INT))); + + assertThrows("Duration requires a fixed(12)", IllegalArgumentException.class, + "Duration can only be used with an underlying fixed type of size 12.", + () -> LogicalTypes.duration().addToSchema(Schema.createFixed("wrong", null, null, 42))); + } + @Test void logicalTypeEquals() { LogicalTypes.Decimal decimal90 = LogicalTypes.decimal(9); @@ -308,12 +337,11 @@ public static void assertEqualsFalse(String message, Object o1, Object o2) { * * @param message A String message to describe this assertion * @param expected An Exception class that the Runnable should throw - * @param containedInMessage A String that should be contained by the thrown - * exception's message + * @param containedInMessage A String that should be contained by the thrown exception's message * @param callable A Callable that is expected to throw the exception */ public static void assertThrows(String message, Class expected, String containedInMessage, - Callable callable) { + Callable callable) { try { callable.call(); fail("No exception was thrown (" + message + "), expected: " + expected.getName()); From f269887e46271fbbf3cec62a842fdd1793a5a6a0 Mon Sep 17 00:00:00 2001 From: Oscar Westra van Holthe - Kind Date: Mon, 25 Sep 2023 14:20:46 +0200 Subject: [PATCH 3/5] AVRO-2123: Add conversion for logical "duration" --- .../java/org/apache/avro/Conversions.java | 158 +++++++++++------- .../avro/generic/TestGenericLogicalTypes.java | 83 ++++++--- 2 files changed, 157 insertions(+), 84 deletions(-) diff --git a/lang/java/avro/src/main/java/org/apache/avro/Conversions.java b/lang/java/avro/src/main/java/org/apache/avro/Conversions.java index 7d01fc62a37..22bbaa6f0a2 100644 --- a/lang/java/avro/src/main/java/org/apache/avro/Conversions.java +++ b/lang/java/avro/src/main/java/org/apache/avro/Conversions.java @@ -18,15 +18,18 @@ package org.apache.avro; -import java.math.RoundingMode; import org.apache.avro.generic.GenericData; import org.apache.avro.generic.GenericEnumSymbol; import org.apache.avro.generic.GenericFixed; import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.util.TimePeriod; import java.math.BigDecimal; import java.math.BigInteger; +import java.math.RoundingMode; import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.IntBuffer; import java.util.Arrays; import java.util.Collection; import java.util.Map; @@ -127,7 +130,7 @@ private static BigDecimal validate(final LogicalTypes.Decimal decimal, BigDecima scaleAdjusted = true; } catch (ArithmeticException aex) { throw new AvroTypeException( - "Cannot encode decimal with scale " + valueScale + " as scale " + scale + " without rounding"); + "Cannot encode decimal with scale " + valueScale + " as scale " + scale + " without rounding"); } } @@ -136,10 +139,10 @@ private static BigDecimal validate(final LogicalTypes.Decimal decimal, BigDecima if (valuePrecision > precision) { if (scaleAdjusted) { throw new AvroTypeException("Cannot encode decimal with precision " + valuePrecision + " as max precision " - + precision + ". This is after safely adjusting scale from " + valueScale + " to required " + scale); + + precision + ". This is after safely adjusting scale from " + valueScale + " to required " + scale); } else { throw new AvroTypeException( - "Cannot encode decimal with precision " + valuePrecision + " as max precision " + precision); + "Cannot encode decimal with precision " + valuePrecision + " as max precision " + precision); } } @@ -147,6 +150,43 @@ private static BigDecimal validate(final LogicalTypes.Decimal decimal, BigDecima } } + public static class DurationConversion extends Conversion { + @Override + public Class getConvertedType() { + return TimePeriod.class; + } + + @Override + public String getLogicalTypeName() { + return "duration"; + } + + @Override + public Schema getRecommendedSchema() { + return LogicalTypes.duration().addToSchema(Schema.createFixed("time.Duration", + "A 12-byte byte array encoding a duration in months, days and milliseconds.", null, 12)); + } + + @Override + public TimePeriod fromFixed(GenericFixed value, Schema schema, LogicalType type) { + IntBuffer buffer = ByteBuffer.wrap(value.bytes()).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer(); + long months = Integer.toUnsignedLong(buffer.get()); + long days = Integer.toUnsignedLong(buffer.get()); + long millis = Integer.toUnsignedLong(buffer.get()); + return TimePeriod.of(months, days, millis); + } + + @Override + public GenericFixed toFixed(TimePeriod value, Schema schema, LogicalType type) { + ByteBuffer buffer = ByteBuffer.allocate(12).order(ByteOrder.LITTLE_ENDIAN); + IntBuffer intBuffer = buffer.asIntBuffer(); + intBuffer.put((int) value.getMonths()); + intBuffer.put((int) value.getDays()); + intBuffer.put((int) value.getMillis()); + return new GenericData.Fixed(schema, buffer.array()); + } + } + /** * Convert an underlying representation of a logical type (such as a ByteBuffer) * to a higher level object (such as a BigDecimal). @@ -158,7 +198,7 @@ private static BigDecimal validate(final LogicalTypes.Decimal decimal, BigDecima * @param conversion The tool used to finish the conversion. Cannot be null if * datum is not null. * @return The result object, which is a high level object of the logical type. - * The null datum always converts to a null value. + * The null datum always converts to a null value. * @throws IllegalArgumentException if datum is not null, but schema, type or * conversion is. */ @@ -169,40 +209,40 @@ public static Object convertToLogicalType(Object datum, Schema schema, LogicalTy if (schema == null || type == null || conversion == null) { throw new IllegalArgumentException("Parameters cannot be null! Parameter values:" - + Arrays.deepToString(new Object[] { datum, schema, type, conversion })); + + Arrays.deepToString(new Object[]{datum, schema, type, conversion})); } try { switch (schema.getType()) { - case RECORD: - return conversion.fromRecord((IndexedRecord) datum, schema, type); - case ENUM: - return conversion.fromEnumSymbol((GenericEnumSymbol) datum, schema, type); - case ARRAY: - return conversion.fromArray((Collection) datum, schema, type); - case MAP: - return conversion.fromMap((Map) datum, schema, type); - case FIXED: - return conversion.fromFixed((GenericFixed) datum, schema, type); - case STRING: - return conversion.fromCharSequence((CharSequence) datum, schema, type); - case BYTES: - return conversion.fromBytes((ByteBuffer) datum, schema, type); - case INT: - return conversion.fromInt((Integer) datum, schema, type); - case LONG: - return conversion.fromLong((Long) datum, schema, type); - case FLOAT: - return conversion.fromFloat((Float) datum, schema, type); - case DOUBLE: - return conversion.fromDouble((Double) datum, schema, type); - case BOOLEAN: - return conversion.fromBoolean((Boolean) datum, schema, type); + case RECORD: + return conversion.fromRecord((IndexedRecord) datum, schema, type); + case ENUM: + return conversion.fromEnumSymbol((GenericEnumSymbol) datum, schema, type); + case ARRAY: + return conversion.fromArray((Collection) datum, schema, type); + case MAP: + return conversion.fromMap((Map) datum, schema, type); + case FIXED: + return conversion.fromFixed((GenericFixed) datum, schema, type); + case STRING: + return conversion.fromCharSequence((CharSequence) datum, schema, type); + case BYTES: + return conversion.fromBytes((ByteBuffer) datum, schema, type); + case INT: + return conversion.fromInt((Integer) datum, schema, type); + case LONG: + return conversion.fromLong((Long) datum, schema, type); + case FLOAT: + return conversion.fromFloat((Float) datum, schema, type); + case DOUBLE: + return conversion.fromDouble((Double) datum, schema, type); + case BOOLEAN: + return conversion.fromBoolean((Boolean) datum, schema, type); } return datum; } catch (ClassCastException e) { throw new AvroRuntimeException( - "Cannot convert " + datum + ':' + datum.getClass().getSimpleName() + ": expected generic type", e); + "Cannot convert " + datum + ':' + datum.getClass().getSimpleName() + ": expected generic type", e); } } @@ -217,8 +257,8 @@ public static Object convertToLogicalType(Object datum, Schema schema, LogicalTy * @param conversion The tool used to finish the conversion. Cannot be null if * datum is not null. * @return The result object, which is an underlying representation object of - * the logical type. If the input param datum is null, a null value will - * be returned. + * the logical type. If the input param datum is null, a null value will + * be returned. * @throws IllegalArgumentException if datum is not null, but schema, type or * conversion is. */ @@ -229,41 +269,41 @@ public static Object convertToRawType(Object datum, Schema schema, LogicalTy if (schema == null || type == null || conversion == null) { throw new IllegalArgumentException("Parameters cannot be null! Parameter values:" - + Arrays.deepToString(new Object[] { datum, schema, type, conversion })); + + Arrays.deepToString(new Object[]{datum, schema, type, conversion})); } try { Class fromClass = conversion.getConvertedType(); switch (schema.getType()) { - case RECORD: - return conversion.toRecord(fromClass.cast(datum), schema, type); - case ENUM: - return conversion.toEnumSymbol(fromClass.cast(datum), schema, type); - case ARRAY: - return conversion.toArray(fromClass.cast(datum), schema, type); - case MAP: - return conversion.toMap(fromClass.cast(datum), schema, type); - case FIXED: - return conversion.toFixed(fromClass.cast(datum), schema, type); - case STRING: - return conversion.toCharSequence(fromClass.cast(datum), schema, type); - case BYTES: - return conversion.toBytes(fromClass.cast(datum), schema, type); - case INT: - return conversion.toInt(fromClass.cast(datum), schema, type); - case LONG: - return conversion.toLong(fromClass.cast(datum), schema, type); - case FLOAT: - return conversion.toFloat(fromClass.cast(datum), schema, type); - case DOUBLE: - return conversion.toDouble(fromClass.cast(datum), schema, type); - case BOOLEAN: - return conversion.toBoolean(fromClass.cast(datum), schema, type); + case RECORD: + return conversion.toRecord(fromClass.cast(datum), schema, type); + case ENUM: + return conversion.toEnumSymbol(fromClass.cast(datum), schema, type); + case ARRAY: + return conversion.toArray(fromClass.cast(datum), schema, type); + case MAP: + return conversion.toMap(fromClass.cast(datum), schema, type); + case FIXED: + return conversion.toFixed(fromClass.cast(datum), schema, type); + case STRING: + return conversion.toCharSequence(fromClass.cast(datum), schema, type); + case BYTES: + return conversion.toBytes(fromClass.cast(datum), schema, type); + case INT: + return conversion.toInt(fromClass.cast(datum), schema, type); + case LONG: + return conversion.toLong(fromClass.cast(datum), schema, type); + case FLOAT: + return conversion.toFloat(fromClass.cast(datum), schema, type); + case DOUBLE: + return conversion.toDouble(fromClass.cast(datum), schema, type); + case BOOLEAN: + return conversion.toBoolean(fromClass.cast(datum), schema, type); } return datum; } catch (ClassCastException e) { throw new AvroRuntimeException( - "Cannot convert " + datum + ':' + datum.getClass().getSimpleName() + ": expected logical type", e); + "Cannot convert " + datum + ':' + datum.getClass().getSimpleName() + ": expected logical type", e); } } diff --git a/lang/java/avro/src/test/java/org/apache/avro/generic/TestGenericLogicalTypes.java b/lang/java/avro/src/test/java/org/apache/avro/generic/TestGenericLogicalTypes.java index 25a838db335..9cc3589c6fa 100644 --- a/lang/java/avro/src/test/java/org/apache/avro/generic/TestGenericLogicalTypes.java +++ b/lang/java/avro/src/test/java/org/apache/avro/generic/TestGenericLogicalTypes.java @@ -18,19 +18,6 @@ package org.apache.avro.generic; -import java.io.File; -import java.io.IOException; -import java.math.BigDecimal; -import java.nio.ByteBuffer; -import java.time.Instant; -import java.time.LocalDateTime; -import java.time.ZoneOffset; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.UUID; - import org.apache.avro.Conversion; import org.apache.avro.Conversions; import org.apache.avro.CustomType; @@ -43,11 +30,26 @@ import org.apache.avro.file.FileReader; import org.apache.avro.io.DatumReader; import org.apache.avro.io.DatumWriter; - +import org.apache.avro.util.TimePeriod; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; +import java.io.File; +import java.io.IOException; +import java.math.BigDecimal; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.time.Instant; +import java.time.LocalDateTime; +import java.time.ZoneOffset; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Random; +import java.util.UUID; + import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.is; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -64,6 +66,7 @@ public class TestGenericLogicalTypes { public static void addLogicalTypes() { GENERIC.addLogicalTypeConversion(new Conversions.DecimalConversion()); GENERIC.addLogicalTypeConversion(new Conversions.UUIDConversion()); + GENERIC.addLogicalTypeConversion(new Conversions.DurationConversion()); GENERIC.addLogicalTypeConversion(new TimeConversions.LocalTimestampMicrosConversion()); GENERIC.addLogicalTypeConversion(new TimeConversions.LocalTimestampMillisConversion()); } @@ -116,6 +119,35 @@ public void writeNullableUUID() throws IOException { "Should read UUIDs as Strings"); } + @Test + public void readWriteDuration() throws IOException { + Schema fixedSchema = Schema.createFixed("bare.Fixed", null, null, 12); + + Schema durationSchema = Schema.createFixed("time.Duration", null, null, 12); + LogicalTypes.duration().addToSchema(durationSchema); + + // These two are necessary for schema evolution! + fixedSchema.addAlias(durationSchema.getFullName()); + durationSchema.addAlias(fixedSchema.getFullName()); + + Random rng = new Random(); + TimePeriod d1 = TimePeriod.of(rng.nextInt(1000), rng.nextInt(1000), rng.nextInt(1000)); + ByteBuffer b1 = ByteBuffer.allocate(12).order(ByteOrder.LITTLE_ENDIAN) + .putInt((int) d1.getMonths()).putInt((int) d1.getDays()).putInt((int) d1.getMillis()); + GenericFixed f1 = new GenericData.Fixed(fixedSchema, b1.array()); + + TimePeriod d2 = TimePeriod.of(rng.nextInt(1000), rng.nextInt(1000), rng.nextInt(1000)); + ByteBuffer b2 = ByteBuffer.allocate(12).order(ByteOrder.LITTLE_ENDIAN) + .putInt((int) d2.getMonths()).putInt((int) d2.getDays()).putInt((int) d2.getMillis()); + GenericFixed f2 = new GenericData.Fixed(fixedSchema, b2.array()); + + File test = write(fixedSchema, f1, f2); + assertEquals(Arrays.asList(d1, d2), read(GENERIC.createDatumReader(durationSchema), test), "Should convert fixed bytes to durations"); + + test = write(GENERIC, durationSchema, d2, d1); + assertEquals(Arrays.asList(f2, f1), read(GenericData.get().createDatumReader(fixedSchema), test), "Should convert durations to fixed bytes"); + } + @Test public void readDecimalFixed() throws IOException { LogicalType decimal = LogicalTypes.decimal(9, 2); @@ -157,11 +189,11 @@ public void writeDecimalFixed() throws IOException { } @Test - public void decimalToFromBytes() throws IOException { + public void decimalToFromBytes() { LogicalType decimal = LogicalTypes.decimal(9, 2); Schema bytesSchema = Schema.create(Schema.Type.BYTES); - // Check that the round trip to and from bytes + // Check the round trip to and from bytes BigDecimal d1 = new BigDecimal("-34.34"); BigDecimal d2 = new BigDecimal("117230.00"); @@ -178,11 +210,11 @@ public void decimalToFromBytes() throws IOException { } @Test - public void decimalToFromFixed() throws IOException { + public void decimalToFromFixed() { LogicalType decimal = LogicalTypes.decimal(9, 2); Schema fixedSchema = Schema.createFixed("aFixed", null, null, 4); - // Check that the round trip to and from fixed data. + // Check the round trip to and from fixed data. BigDecimal d1 = new BigDecimal("-34.34"); BigDecimal d2 = new BigDecimal("117230.00"); @@ -247,7 +279,8 @@ private List read(DatumReader reader, File file) throws IOException { return data; } - private File write(Schema schema, D... data) throws IOException { + @SafeVarargs + private final File write(Schema schema, D... data) throws IOException { return write(GenericData.get(), schema, data); } @@ -308,12 +341,12 @@ private void testCopy(Schema schema, Object value, GenericData model) { // test nested in array Schema arraySchema = Schema.createArray(schema); - ArrayList array = new ArrayList(Collections.singletonList(value)); + ArrayList array = new ArrayList<>(Collections.singletonList(value)); checkCopy(array, model.deepCopy(arraySchema, array), true); // test record nested in array Schema recordArraySchema = Schema.createArray(recordSchema); - ArrayList recordArray = new ArrayList(Collections.singletonList(record)); + ArrayList recordArray = new ArrayList<>(Collections.singletonList(record)); checkCopy(recordArray, model.deepCopy(recordArraySchema, recordArray), true); } @@ -329,7 +362,7 @@ public void readLocalTimestampMillis() throws IOException { Schema longSchema = Schema.create(Schema.Type.LONG); Schema timestampSchema = timestamp.addToSchema(Schema.create(Schema.Type.LONG)); - LocalDateTime i1 = LocalDateTime.of(1986, 06, 26, 12, 07, 11, 42000000); + LocalDateTime i1 = LocalDateTime.of(1986, 6, 26, 12, 7, 11, 42000000); LocalDateTime i2 = LocalDateTime.ofInstant(Instant.ofEpochMilli(0), ZoneOffset.UTC); List expected = Arrays.asList(i1, i2); @@ -350,7 +383,7 @@ public void writeLocalTimestampMillis() throws IOException { Schema longSchema = Schema.create(Schema.Type.LONG); Schema timestampSchema = timestamp.addToSchema(Schema.create(Schema.Type.LONG)); - LocalDateTime i1 = LocalDateTime.of(1986, 06, 26, 12, 07, 11, 42000000); + LocalDateTime i1 = LocalDateTime.of(1986, 6, 26, 12, 7, 11, 42000000); LocalDateTime i2 = LocalDateTime.ofInstant(Instant.ofEpochMilli(0), ZoneOffset.UTC); Conversion conversion = new TimeConversions.LocalTimestampMillisConversion(); @@ -370,7 +403,7 @@ public void readLocalTimestampMicros() throws IOException { Schema longSchema = Schema.create(Schema.Type.LONG); Schema timestampSchema = timestamp.addToSchema(Schema.create(Schema.Type.LONG)); - LocalDateTime i1 = LocalDateTime.of(1986, 06, 26, 12, 07, 11, 420000); + LocalDateTime i1 = LocalDateTime.of(1986, 6, 26, 12, 7, 11, 420000); LocalDateTime i2 = LocalDateTime.ofInstant(Instant.ofEpochSecond(0, 4000), ZoneOffset.UTC); List expected = Arrays.asList(i1, i2); @@ -391,7 +424,7 @@ public void writeLocalTimestampMicros() throws IOException { Schema longSchema = Schema.create(Schema.Type.LONG); Schema timestampSchema = timestamp.addToSchema(Schema.create(Schema.Type.LONG)); - LocalDateTime i1 = LocalDateTime.of(1986, 06, 26, 12, 07, 11, 420000); + LocalDateTime i1 = LocalDateTime.of(1986, 6, 26, 12, 7, 11, 420000); LocalDateTime i2 = LocalDateTime.ofInstant(Instant.ofEpochSecond(0, 4000), ZoneOffset.UTC); Conversion conversion = new TimeConversions.LocalTimestampMicrosConversion(); From 9d78480de00bdd7b8cdaced0a03c86efa9345502 Mon Sep 17 00:00:00 2001 From: Oscar Westra van Holthe - Kind Date: Mon, 25 Sep 2023 16:24:03 +0200 Subject: [PATCH 4/5] AVRO-2123: Apply spotless --- .../java/org/apache/avro/Conversions.java | 116 +++++++++--------- .../java/org/apache/avro/LogicalTypes.java | 4 +- .../java/org/apache/avro/util/TimePeriod.java | 108 +++++++++------- .../java/org/apache/avro/TestLogicalType.java | 9 +- .../avro/generic/TestGenericLogicalTypes.java | 14 ++- .../org/apache/avro/util/TimePeriodTest.java | 36 +++--- 6 files changed, 157 insertions(+), 130 deletions(-) diff --git a/lang/java/avro/src/main/java/org/apache/avro/Conversions.java b/lang/java/avro/src/main/java/org/apache/avro/Conversions.java index 22bbaa6f0a2..1a1754226b4 100644 --- a/lang/java/avro/src/main/java/org/apache/avro/Conversions.java +++ b/lang/java/avro/src/main/java/org/apache/avro/Conversions.java @@ -130,7 +130,7 @@ private static BigDecimal validate(final LogicalTypes.Decimal decimal, BigDecima scaleAdjusted = true; } catch (ArithmeticException aex) { throw new AvroTypeException( - "Cannot encode decimal with scale " + valueScale + " as scale " + scale + " without rounding"); + "Cannot encode decimal with scale " + valueScale + " as scale " + scale + " without rounding"); } } @@ -139,10 +139,10 @@ private static BigDecimal validate(final LogicalTypes.Decimal decimal, BigDecima if (valuePrecision > precision) { if (scaleAdjusted) { throw new AvroTypeException("Cannot encode decimal with precision " + valuePrecision + " as max precision " - + precision + ". This is after safely adjusting scale from " + valueScale + " to required " + scale); + + precision + ". This is after safely adjusting scale from " + valueScale + " to required " + scale); } else { throw new AvroTypeException( - "Cannot encode decimal with precision " + valuePrecision + " as max precision " + precision); + "Cannot encode decimal with precision " + valuePrecision + " as max precision " + precision); } } @@ -198,7 +198,7 @@ public GenericFixed toFixed(TimePeriod value, Schema schema, LogicalType type) { * @param conversion The tool used to finish the conversion. Cannot be null if * datum is not null. * @return The result object, which is a high level object of the logical type. - * The null datum always converts to a null value. + * The null datum always converts to a null value. * @throws IllegalArgumentException if datum is not null, but schema, type or * conversion is. */ @@ -209,40 +209,40 @@ public static Object convertToLogicalType(Object datum, Schema schema, LogicalTy if (schema == null || type == null || conversion == null) { throw new IllegalArgumentException("Parameters cannot be null! Parameter values:" - + Arrays.deepToString(new Object[]{datum, schema, type, conversion})); + + Arrays.deepToString(new Object[] { datum, schema, type, conversion })); } try { switch (schema.getType()) { - case RECORD: - return conversion.fromRecord((IndexedRecord) datum, schema, type); - case ENUM: - return conversion.fromEnumSymbol((GenericEnumSymbol) datum, schema, type); - case ARRAY: - return conversion.fromArray((Collection) datum, schema, type); - case MAP: - return conversion.fromMap((Map) datum, schema, type); - case FIXED: - return conversion.fromFixed((GenericFixed) datum, schema, type); - case STRING: - return conversion.fromCharSequence((CharSequence) datum, schema, type); - case BYTES: - return conversion.fromBytes((ByteBuffer) datum, schema, type); - case INT: - return conversion.fromInt((Integer) datum, schema, type); - case LONG: - return conversion.fromLong((Long) datum, schema, type); - case FLOAT: - return conversion.fromFloat((Float) datum, schema, type); - case DOUBLE: - return conversion.fromDouble((Double) datum, schema, type); - case BOOLEAN: - return conversion.fromBoolean((Boolean) datum, schema, type); + case RECORD: + return conversion.fromRecord((IndexedRecord) datum, schema, type); + case ENUM: + return conversion.fromEnumSymbol((GenericEnumSymbol) datum, schema, type); + case ARRAY: + return conversion.fromArray((Collection) datum, schema, type); + case MAP: + return conversion.fromMap((Map) datum, schema, type); + case FIXED: + return conversion.fromFixed((GenericFixed) datum, schema, type); + case STRING: + return conversion.fromCharSequence((CharSequence) datum, schema, type); + case BYTES: + return conversion.fromBytes((ByteBuffer) datum, schema, type); + case INT: + return conversion.fromInt((Integer) datum, schema, type); + case LONG: + return conversion.fromLong((Long) datum, schema, type); + case FLOAT: + return conversion.fromFloat((Float) datum, schema, type); + case DOUBLE: + return conversion.fromDouble((Double) datum, schema, type); + case BOOLEAN: + return conversion.fromBoolean((Boolean) datum, schema, type); } return datum; } catch (ClassCastException e) { throw new AvroRuntimeException( - "Cannot convert " + datum + ':' + datum.getClass().getSimpleName() + ": expected generic type", e); + "Cannot convert " + datum + ':' + datum.getClass().getSimpleName() + ": expected generic type", e); } } @@ -257,8 +257,8 @@ public static Object convertToLogicalType(Object datum, Schema schema, LogicalTy * @param conversion The tool used to finish the conversion. Cannot be null if * datum is not null. * @return The result object, which is an underlying representation object of - * the logical type. If the input param datum is null, a null value will - * be returned. + * the logical type. If the input param datum is null, a null value will + * be returned. * @throws IllegalArgumentException if datum is not null, but schema, type or * conversion is. */ @@ -269,41 +269,41 @@ public static Object convertToRawType(Object datum, Schema schema, LogicalTy if (schema == null || type == null || conversion == null) { throw new IllegalArgumentException("Parameters cannot be null! Parameter values:" - + Arrays.deepToString(new Object[]{datum, schema, type, conversion})); + + Arrays.deepToString(new Object[] { datum, schema, type, conversion })); } try { Class fromClass = conversion.getConvertedType(); switch (schema.getType()) { - case RECORD: - return conversion.toRecord(fromClass.cast(datum), schema, type); - case ENUM: - return conversion.toEnumSymbol(fromClass.cast(datum), schema, type); - case ARRAY: - return conversion.toArray(fromClass.cast(datum), schema, type); - case MAP: - return conversion.toMap(fromClass.cast(datum), schema, type); - case FIXED: - return conversion.toFixed(fromClass.cast(datum), schema, type); - case STRING: - return conversion.toCharSequence(fromClass.cast(datum), schema, type); - case BYTES: - return conversion.toBytes(fromClass.cast(datum), schema, type); - case INT: - return conversion.toInt(fromClass.cast(datum), schema, type); - case LONG: - return conversion.toLong(fromClass.cast(datum), schema, type); - case FLOAT: - return conversion.toFloat(fromClass.cast(datum), schema, type); - case DOUBLE: - return conversion.toDouble(fromClass.cast(datum), schema, type); - case BOOLEAN: - return conversion.toBoolean(fromClass.cast(datum), schema, type); + case RECORD: + return conversion.toRecord(fromClass.cast(datum), schema, type); + case ENUM: + return conversion.toEnumSymbol(fromClass.cast(datum), schema, type); + case ARRAY: + return conversion.toArray(fromClass.cast(datum), schema, type); + case MAP: + return conversion.toMap(fromClass.cast(datum), schema, type); + case FIXED: + return conversion.toFixed(fromClass.cast(datum), schema, type); + case STRING: + return conversion.toCharSequence(fromClass.cast(datum), schema, type); + case BYTES: + return conversion.toBytes(fromClass.cast(datum), schema, type); + case INT: + return conversion.toInt(fromClass.cast(datum), schema, type); + case LONG: + return conversion.toLong(fromClass.cast(datum), schema, type); + case FLOAT: + return conversion.toFloat(fromClass.cast(datum), schema, type); + case DOUBLE: + return conversion.toDouble(fromClass.cast(datum), schema, type); + case BOOLEAN: + return conversion.toBoolean(fromClass.cast(datum), schema, type); } return datum; } catch (ClassCastException e) { throw new AvroRuntimeException( - "Cannot convert " + datum + ':' + datum.getClass().getSimpleName() + ": expected logical type", e); + "Cannot convert " + datum + ':' + datum.getClass().getSimpleName() + ": expected logical type", e); } } diff --git a/lang/java/avro/src/main/java/org/apache/avro/LogicalTypes.java b/lang/java/avro/src/main/java/org/apache/avro/LogicalTypes.java index fe45cbe204e..4292756a2d2 100644 --- a/lang/java/avro/src/main/java/org/apache/avro/LogicalTypes.java +++ b/lang/java/avro/src/main/java/org/apache/avro/LogicalTypes.java @@ -271,7 +271,9 @@ public void validate(Schema schema) { } } - /** Duration represents a duration, consisting on months, days and milliseconds */ + /** + * Duration represents a duration, consisting on months, days and milliseconds + */ public static class Duration extends LogicalType { private Duration() { super(DURATION); diff --git a/lang/java/avro/src/main/java/org/apache/avro/util/TimePeriod.java b/lang/java/avro/src/main/java/org/apache/avro/util/TimePeriod.java index 2e4b05db6e8..0f656f2b4df 100644 --- a/lang/java/avro/src/main/java/org/apache/avro/util/TimePeriod.java +++ b/lang/java/avro/src/main/java/org/apache/avro/util/TimePeriod.java @@ -39,54 +39,71 @@ import static java.util.Objects.requireNonNull; /** - *

A temporal amount to model an - * {@link org.apache.avro.LogicalTypes.Duration Avro duration} (the logical type). + *

+ * A temporal amount to model an {@link org.apache.avro.LogicalTypes.Duration + * Avro duration} (the logical type). *

* - *

It consists of a number of months, days and milliseconds, all modelled as an - * unsigned integer.

+ *

+ * It consists of a number of months, days and milliseconds, all modelled as an + * unsigned integer. + *

* - *

Compared to {@link Period java.time.Period}, this class has a smaller range - * ('only' supporting a little less than 358 million years), and cannot support negative time periods.

+ *

+ * Compared to {@link Period java.time.Period}, this class has a smaller range + * ('only' supporting a little less than 358 million years), and cannot support + * negative time periods. + *

* - *

Compared to {@link Duration java.time.Duration}, this class has less - * precision (milliseconds compared to nanoseconds), cannot support negative durations, and has a much smaller range. - * Where {@code java.time.Duration} supports fixed ranges up to about 68 years, {@code TimePeriod} can only handle about - * 49 days.

+ *

+ * Compared to {@link Duration java.time.Duration}, this class has less + * precision (milliseconds compared to nanoseconds), cannot support negative + * durations, and has a much smaller range. Where {@code java.time.Duration} + * supports fixed ranges up to about 68 years, {@code TimePeriod} can only + * handle about 49 days. + *

* - *

Given the time span of what we do,

- * supporting a little less than 358 million years), and cannot support negative time periods.

+ *

+ * Given the time span of what we do, + *

+ * supporting a little less than 358 million years), and cannot support negative + * time periods. + *

* - *

Comparison with the regular {@code java.time} classes:

+ *

+ * Comparison with the regular {@code java.time} classes: + *

* * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * *
TimePeriod{@link Period}{@link Duration}
Precisionmillisecondsdaysnanoseconds
Time range (approx.)0 - 49 daysunsupported-68 - 68 years
Date range (approx.)0 to 370 million years-2.3 to 2.3 billion yearsunsupported
TimePeriod{@link Period}{@link Duration}
Precisionmillisecondsdaysnanoseconds
Time range (approx.)0 - 49 daysunsupported-68 - 68 years
Date range (approx.)0 to 370 million years-2.3 to 2.3 billion yearsunsupported
* - * @see Avro 1.11 specification on duration + * @see Avro 1.11 + * specification on duration */ public final class TimePeriod implements TemporalAmount, Serializable { private static final long MAX_UNSIGNED_INT = 0xffffffffL; @@ -106,7 +123,8 @@ public final class TimePeriod implements TemporalAmount, Serializable { private final long millis; /** - * Create a TimePeriod from another TemporalAmount, such as a {@link Period} or a {@link Duration}. + * Create a TimePeriod from another TemporalAmount, such as a {@link Period} or + * a {@link Duration}. * * @param amount a temporal amount * @return the corresponding TimePeriod @@ -197,7 +215,8 @@ public static TimePeriod from(TemporalAmount amount) { * @param days a number of days * @param millis a number of milliseconds * @return the corresponding TimePeriod - * @throws ArithmeticException if any of the parameters does not fit an unsigned long (0..4294967296) + * @throws ArithmeticException if any of the parameters does not fit an unsigned + * long (0..4294967296) */ public static TimePeriod of(long months, long days, long millis) { return new TimePeriod(unsignedInt(months), unsignedInt(days), unsignedInt(millis)); @@ -230,8 +249,7 @@ public Period toPeriod() { int monthsAsInt = (int) (months % MONTHS_PER_YEAR); int daysAsInt = (int) days; if (days != daysAsInt) { - throw new DateTimeException( - "Too many days: a Period can contain at most " + Integer.MAX_VALUE + " days."); + throw new DateTimeException("Too many days: a Period can contain at most " + Integer.MAX_VALUE + " days."); } return Period.ofYears(yearsAsInt).withMonths(monthsAsInt).withDays(daysAsInt); } @@ -239,7 +257,8 @@ public Period toPeriod() { } /** - * Determines if the TimePeriod is date based (i.e., if its milliseconds component is 0). + * Determines if the TimePeriod is date based (i.e., if its milliseconds + * component is 0). * * @return {@code true} iff the TimePeriod is date based */ @@ -248,7 +267,8 @@ public boolean isDateBased() { } /** - * Determines if the TimePeriod is time based (i.e., if its months and days components are 0). + * Determines if the TimePeriod is time based (i.e., if its months and days + * components are 0). * * @return {@code true} iff the TimePeriod is time based */ diff --git a/lang/java/avro/src/test/java/org/apache/avro/TestLogicalType.java b/lang/java/avro/src/test/java/org/apache/avro/TestLogicalType.java index fae51c9bf7c..4476ac7db2c 100644 --- a/lang/java/avro/src/test/java/org/apache/avro/TestLogicalType.java +++ b/lang/java/avro/src/test/java/org/apache/avro/TestLogicalType.java @@ -64,13 +64,13 @@ void invalidLogicalTypeIgnored() { void decimalWithNonByteArrayTypes() { final LogicalType decimal = LogicalTypes.decimal(5, 2); // test simple types - Schema[] nonBytes = new Schema[]{Schema.createRecord("Record", null, null, false), + Schema[] nonBytes = new Schema[] { Schema.createRecord("Record", null, null, false), Schema.createArray(Schema.create(Schema.Type.BYTES)), Schema.createMap(Schema.create(Schema.Type.BYTES)), Schema.createEnum("Enum", null, null, Arrays.asList("a", "b")), Schema.createUnion(Arrays.asList(Schema.create(Schema.Type.BYTES), Schema.createFixed("fixed", null, null, 4))), Schema.create(Schema.Type.BOOLEAN), Schema.create(Schema.Type.INT), Schema.create(Schema.Type.LONG), Schema.create(Schema.Type.FLOAT), Schema.create(Schema.Type.DOUBLE), Schema.create(Schema.Type.NULL), - Schema.create(Schema.Type.STRING)}; + Schema.create(Schema.Type.STRING) }; for (final Schema schema : nonBytes) { assertThrows("Should reject type: " + schema.getType(), IllegalArgumentException.class, "Logical type decimal must be backed by fixed or bytes", () -> { @@ -337,11 +337,12 @@ public static void assertEqualsFalse(String message, Object o1, Object o2) { * * @param message A String message to describe this assertion * @param expected An Exception class that the Runnable should throw - * @param containedInMessage A String that should be contained by the thrown exception's message + * @param containedInMessage A String that should be contained by the thrown + * exception's message * @param callable A Callable that is expected to throw the exception */ public static void assertThrows(String message, Class expected, String containedInMessage, - Callable callable) { + Callable callable) { try { callable.call(); fail("No exception was thrown (" + message + "), expected: " + expected.getName()); diff --git a/lang/java/avro/src/test/java/org/apache/avro/generic/TestGenericLogicalTypes.java b/lang/java/avro/src/test/java/org/apache/avro/generic/TestGenericLogicalTypes.java index 9cc3589c6fa..6df4a8af6a2 100644 --- a/lang/java/avro/src/test/java/org/apache/avro/generic/TestGenericLogicalTypes.java +++ b/lang/java/avro/src/test/java/org/apache/avro/generic/TestGenericLogicalTypes.java @@ -132,20 +132,22 @@ public void readWriteDuration() throws IOException { Random rng = new Random(); TimePeriod d1 = TimePeriod.of(rng.nextInt(1000), rng.nextInt(1000), rng.nextInt(1000)); - ByteBuffer b1 = ByteBuffer.allocate(12).order(ByteOrder.LITTLE_ENDIAN) - .putInt((int) d1.getMonths()).putInt((int) d1.getDays()).putInt((int) d1.getMillis()); + ByteBuffer b1 = ByteBuffer.allocate(12).order(ByteOrder.LITTLE_ENDIAN).putInt((int) d1.getMonths()) + .putInt((int) d1.getDays()).putInt((int) d1.getMillis()); GenericFixed f1 = new GenericData.Fixed(fixedSchema, b1.array()); TimePeriod d2 = TimePeriod.of(rng.nextInt(1000), rng.nextInt(1000), rng.nextInt(1000)); - ByteBuffer b2 = ByteBuffer.allocate(12).order(ByteOrder.LITTLE_ENDIAN) - .putInt((int) d2.getMonths()).putInt((int) d2.getDays()).putInt((int) d2.getMillis()); + ByteBuffer b2 = ByteBuffer.allocate(12).order(ByteOrder.LITTLE_ENDIAN).putInt((int) d2.getMonths()) + .putInt((int) d2.getDays()).putInt((int) d2.getMillis()); GenericFixed f2 = new GenericData.Fixed(fixedSchema, b2.array()); File test = write(fixedSchema, f1, f2); - assertEquals(Arrays.asList(d1, d2), read(GENERIC.createDatumReader(durationSchema), test), "Should convert fixed bytes to durations"); + assertEquals(Arrays.asList(d1, d2), read(GENERIC.createDatumReader(durationSchema), test), + "Should convert fixed bytes to durations"); test = write(GENERIC, durationSchema, d2, d1); - assertEquals(Arrays.asList(f2, f1), read(GenericData.get().createDatumReader(fixedSchema), test), "Should convert durations to fixed bytes"); + assertEquals(Arrays.asList(f2, f1), read(GenericData.get().createDatumReader(fixedSchema), test), + "Should convert durations to fixed bytes"); } @Test diff --git a/lang/java/avro/src/test/java/org/apache/avro/util/TimePeriodTest.java b/lang/java/avro/src/test/java/org/apache/avro/util/TimePeriodTest.java index eac67652c7f..cd9809be414 100644 --- a/lang/java/avro/src/test/java/org/apache/avro/util/TimePeriodTest.java +++ b/lang/java/avro/src/test/java/org/apache/avro/util/TimePeriodTest.java @@ -61,7 +61,7 @@ void validateConstruction() { assertSame(timePeriod, TimePeriod.from(timePeriod)); assertComponents(12, 34, 56, timePeriod); - assertComponents(14, 3, 0, TimePeriod.from(IsoChronology.INSTANCE.period(1,2,3))); + assertComponents(14, 3, 0, TimePeriod.from(IsoChronology.INSTANCE.period(1, 2, 3))); assertComponents(36_000, 0, 0, TimePeriod.from(TimeAmount.of(ChronoUnit.MILLENNIA, 3))); assertComponents(3_600, 0, 0, TimePeriod.from(TimeAmount.of(ChronoUnit.CENTURIES, 3))); @@ -84,9 +84,10 @@ void validateConstruction() { // Micros and nanos must be a multiple of milliseconds assertThrows(DateTimeException.class, () -> TimePeriod.from(TimeAmount.of(ChronoUnit.MICROS, 3))); assertThrows(DateTimeException.class, () -> TimePeriod.from(TimeAmount.of(ChronoUnit.NANOS, 3))); - // Unsupported cases (null, non-ISO chronology, unknown temporal unit, non-ChronoUnit) + // Unsupported cases (null, non-ISO chronology, unknown temporal unit, + // non-ChronoUnit) assertThrows(NullPointerException.class, () -> TimePeriod.from(null)); - assertThrows(DateTimeException.class, () -> TimePeriod.from(JapaneseChronology.INSTANCE.period(1,2,3))); + assertThrows(DateTimeException.class, () -> TimePeriod.from(JapaneseChronology.INSTANCE.period(1, 2, 3))); assertThrows(UnsupportedTemporalTypeException.class, () -> TimePeriod.from(TimeAmount.of(ChronoUnit.ERAS, 1))); assertThrows(UnsupportedTemporalTypeException.class, () -> TimePeriod.from(TimeAmount.of(DummyUnit.INSTANCE, 3))); // Arguments are long, but must fit an unsigned long @@ -96,7 +97,7 @@ void validateConstruction() { // Odd one out: querying an unsupported temporal unit // (assertComponents handles all valid cases) - assertThrows(UnsupportedTemporalTypeException.class, () -> TimePeriod.of(1,1,1).get(ERAS)); + assertThrows(UnsupportedTemporalTypeException.class, () -> TimePeriod.of(1, 1, 1).get(ERAS)); } @Test @@ -181,13 +182,13 @@ void checkEqualityTests() { TimePeriod timePeriod3 = TimePeriod.of(1, 9, 9); TimePeriod timePeriod4 = TimePeriod.of(1, 2, 9); - //noinspection EqualsWithItself + // noinspection EqualsWithItself assertEquals(timePeriod1a, timePeriod1a); assertEquals(timePeriod1a, timePeriod1b); assertEquals(timePeriod1a.hashCode(), timePeriod1b.hashCode()); assertNotEquals(timePeriod1a, null); - //noinspection AssertBetweenInconvertibleTypes + // noinspection AssertBetweenInconvertibleTypes assertNotEquals(timePeriod1a, "not equal"); assertNotEquals(timePeriod1a, timePeriod2); assertNotEquals(timePeriod1a.hashCode(), timePeriod2.hashCode()); @@ -199,20 +200,20 @@ void checkEqualityTests() { @Test void checkStringRepresentation() { - assertEquals("P0", TimePeriod.of(0,0,0).toString()); - assertEquals("P1Y", TimePeriod.of(12,0,0).toString()); - assertEquals("P2M", TimePeriod.of(2,0,0).toString()); - assertEquals("P3", TimePeriod.of(0,3,0).toString()); - assertEquals("P1Y2M3", TimePeriod.of(14,3,0).toString()); - assertEquals("PT04", TimePeriod.of(0,0, 14400000).toString()); - assertEquals("PT00:05", TimePeriod.of(0,0, 300000).toString()); - assertEquals("PT00:00:06", TimePeriod.of(0,0, 6000).toString()); - assertEquals("PT00:00:00.007", TimePeriod.of(0,0, 7).toString()); - assertEquals("P1Y2M3T04:05:06.007", TimePeriod.of(14,3, 14706007).toString()); + assertEquals("P0", TimePeriod.of(0, 0, 0).toString()); + assertEquals("P1Y", TimePeriod.of(12, 0, 0).toString()); + assertEquals("P2M", TimePeriod.of(2, 0, 0).toString()); + assertEquals("P3", TimePeriod.of(0, 3, 0).toString()); + assertEquals("P1Y2M3", TimePeriod.of(14, 3, 0).toString()); + assertEquals("PT04", TimePeriod.of(0, 0, 14400000).toString()); + assertEquals("PT00:05", TimePeriod.of(0, 0, 300000).toString()); + assertEquals("PT00:00:06", TimePeriod.of(0, 0, 6000).toString()); + assertEquals("PT00:00:00.007", TimePeriod.of(0, 0, 7).toString()); + assertEquals("P1Y2M3T04:05:06.007", TimePeriod.of(14, 3, 14706007).toString()); // Days and millis will never overflow to months/days, to respect differences // in months and days (daylight saving). - assertEquals("P123T1193:02:47.295", TimePeriod.of(0,123, 4294967295L).toString()); + assertEquals("P123T1193:02:47.295", TimePeriod.of(0, 123, 4294967295L).toString()); } private void assertComponents(long months, long days, long millis, TimePeriod timePeriod) { @@ -271,6 +272,7 @@ public Temporal subtractFrom(Temporal temporal) { private static class DummyUnit implements TemporalUnit { private static final DummyUnit INSTANCE = new DummyUnit(); + @Override public Duration getDuration() { return null; From cd08aec842a4d31765c4bf017463d430ff54e046 Mon Sep 17 00:00:00 2001 From: Oscar Westra van Holthe - Kind Date: Mon, 25 Sep 2023 16:58:41 +0200 Subject: [PATCH 5/5] AVRO-2123: Javadoc cleanup --- .../src/main/java/org/apache/avro/util/TimePeriod.java | 7 ------- 1 file changed, 7 deletions(-) diff --git a/lang/java/avro/src/main/java/org/apache/avro/util/TimePeriod.java b/lang/java/avro/src/main/java/org/apache/avro/util/TimePeriod.java index 0f656f2b4df..a1f7fa4e8b5 100644 --- a/lang/java/avro/src/main/java/org/apache/avro/util/TimePeriod.java +++ b/lang/java/avro/src/main/java/org/apache/avro/util/TimePeriod.java @@ -64,13 +64,6 @@ *

* *

- * Given the time span of what we do, - *

- * supporting a little less than 358 million years), and cannot support negative - * time periods. - *

- * - *

* Comparison with the regular {@code java.time} classes: *

*