OffsetTimeCodec

Author: anshlykov

src/main/java/io/r2dbc/postgresql/codec/AbstractTemporalCodec.java

@@ -27,6 +27,8 @@
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.OffsetDateTime;
+import java.time.OffsetTime;
+import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
 import java.time.temporal.Temporal;
 import java.util.EnumSet;
@@ -38,6 +40,7 @@
 import static io.r2dbc.postgresql.type.PostgresqlObjectId.TIME;
 import static io.r2dbc.postgresql.type.PostgresqlObjectId.TIMESTAMP;
 import static io.r2dbc.postgresql.type.PostgresqlObjectId.TIMESTAMPTZ;
+import static io.r2dbc.postgresql.type.PostgresqlObjectId.TIMETZ;
 
 /**
  * Codec to decode all known temporal types.
@@ -46,7 +49,7 @@
  */
 abstract class AbstractTemporalCodec<T extends Temporal> extends AbstractCodec<T> {
 
-    private static final Set<PostgresqlObjectId> SUPPORTED_TYPES = EnumSet.of(DATE, TIMESTAMP, TIMESTAMPTZ, TIME);
+    private static final Set<PostgresqlObjectId> SUPPORTED_TYPES = EnumSet.of(DATE, TIMESTAMP, TIMESTAMPTZ, TIME, TIMETZ);
 
     /**
      * Creates a new {@link AbstractTemporalCodec}.
@@ -130,6 +133,14 @@ private Temporal decodeTemporal(ByteBuf buffer, PostgresqlObjectId dataType, @Nu
                 }
 
                 return PostgresqlDateTimeFormatter.INSTANCE.parse(ByteBufUtils.decode(buffer), ZonedDateTime::from);
+            case TIMETZ:
+                if (FORMAT_BINARY == format) {
+                    long timeNano = buffer.readLong() * 1000;
+                    int offsetSec = -buffer.readInt();
+                    return OffsetTime.of(LocalTime.ofNanoOfDay(timeNano), ZoneOffset.ofTotalSeconds(offsetSec));
+                }
+
+                return PostgresqlTimeFormatter.INSTANCE.parse(ByteBufUtils.decode(buffer), OffsetTime::from);
         }
 
         throw new UnsupportedOperationException(String.format("Cannot decode value for type %s, format %s", dataType, format));

src/main/java/io/r2dbc/postgresql/codec/DefaultCodecs.java

@@ -66,6 +66,7 @@ public DefaultCodecs(ByteBufAllocator byteBufAllocator) {
             new LocalTimeCodec(byteBufAllocator),
             new LongCodec(byteBufAllocator),
             new OffsetDateTimeCodec(byteBufAllocator),
+            new OffsetTimeCodec(byteBufAllocator),
             new ShortCodec(byteBufAllocator),
             new UriCodec(byteBufAllocator),
             new UrlCodec(byteBufAllocator),

src/main/java/io/r2dbc/postgresql/codec/OffsetTimeCodec.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2017-2020 the original author or authors.
+ *
+ * Licensed 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 io.r2dbc.postgresql.codec;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.r2dbc.postgresql.client.Parameter;
+import io.r2dbc.postgresql.message.Format;
+import io.r2dbc.postgresql.type.PostgresqlObjectId;
+import io.r2dbc.postgresql.util.Assert;
+import io.r2dbc.postgresql.util.ByteBufUtils;
+
+import java.time.OffsetTime;
+
+import static io.r2dbc.postgresql.message.Format.FORMAT_TEXT;
+import static io.r2dbc.postgresql.type.PostgresqlObjectId.TIMETZ;
+
+public class OffsetTimeCodec extends AbstractTemporalCodec<OffsetTime> {
+
+    private final ByteBufAllocator byteBufAllocator;
+
+    OffsetTimeCodec(ByteBufAllocator byteBufAllocator) {
+        super(OffsetTime.class);
+        this.byteBufAllocator = Assert.requireNonNull(byteBufAllocator, "byteBufAllocator must not be null");
+    }
+
+    @Override
+    PostgresqlObjectId getDefaultType() {
+        return TIMETZ;
+    }
+
+    @Override
+    OffsetTime doDecode(ByteBuf buffer, PostgresqlObjectId dataType, Format format, Class<? extends OffsetTime> type) {
+        Assert.requireNonNull(buffer, "byteBuf must not be null");
+
+        return decodeTemporal(buffer, dataType, format, OffsetTime.class, OffsetTime::from);
+    }
+
+    @Override
+    Parameter doEncode(OffsetTime value) {
+        Assert.requireNonNull(value, "value must not be null");
+
+        return create(TIMETZ, FORMAT_TEXT, () -> ByteBufUtils.encode(this.byteBufAllocator, value.toString()));
+    }
+
+    @Override
+    public Parameter encodeNull() {
+        return createNull(TIMETZ, FORMAT_TEXT);
+    }
+
+}

src/main/java/io/r2dbc/postgresql/codec/PostgresqlTimeFormatter.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2017-2020 the original author or authors.
+ *
+ * Licensed 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 io.r2dbc.postgresql.codec;
+
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeFormatterBuilder;
+
+import static java.time.temporal.ChronoField.HOUR_OF_DAY;
+import static java.time.temporal.ChronoField.MINUTE_OF_HOUR;
+import static java.time.temporal.ChronoField.NANO_OF_SECOND;
+import static java.time.temporal.ChronoField.SECOND_OF_MINUTE;
+
+class PostgresqlTimeFormatter {
+
+    static final DateTimeFormatter INSTANCE =
+        new DateTimeFormatterBuilder()
+            .appendValue(HOUR_OF_DAY, 2)
+            .appendLiteral(':')
+            .appendValue(MINUTE_OF_HOUR, 2)
+            .optionalStart()
+            .appendLiteral(':')
+            .appendValue(SECOND_OF_MINUTE, 2)
+            .optionalStart()
+            .appendFraction(NANO_OF_SECOND, 0, 9, true)
+            .optionalEnd()
+            .optionalStart()
+            .appendOffset("+HH:mm", "+00")
+            .optionalEnd()
+            .toFormatter();
+
+}

src/test/java/io/r2dbc/postgresql/AbstractCodecIntegrationTests.java

@@ -52,7 +52,9 @@
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.OffsetDateTime;
+import java.time.OffsetTime;
 import java.time.ZoneId;
+import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
 import java.util.Date;
 import java.util.LinkedHashMap;
@@ -445,6 +447,13 @@ void zonedDateTime() {
         }, "TIMESTAMP WITH TIME ZONE");
     }
 
+    @Test
+    void offsetTime() {
+        testCodec(OffsetTime.class, OffsetTime.of(LocalTime.now(), ZoneOffset.UTC), "TIMETZ");
+        testCodec(OffsetTime.class, OffsetTime.of(LocalTime.now(), ZoneOffset.ofHoursMinutes(1, 30)), "TIMETZ");
+        testCodec(OffsetTime.class, OffsetTime.of(LocalTime.now(), ZoneOffset.ofHoursMinutes(-3, -30)), "TIMETZ");
+    }
+
     private static <T> Mono<T> close(Connection connection) {
         return Mono.from(connection
             .close())

src/test/java/io/r2dbc/postgresql/codec/OffsetTimeCodecUnitTests.java

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2017-2020 the original author or authors.
+ *
+ * Licensed 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 io.r2dbc.postgresql.codec;
+
+import java.time.OffsetTime;
+
+import io.r2dbc.postgresql.client.Parameter;
+import io.r2dbc.postgresql.client.ParameterAssert;
+import org.junit.jupiter.api.Test;
+
+import static io.r2dbc.postgresql.client.Parameter.NULL_VALUE;
+import static io.r2dbc.postgresql.message.Format.FORMAT_BINARY;
+import static io.r2dbc.postgresql.message.Format.FORMAT_TEXT;
+import static io.r2dbc.postgresql.type.PostgresqlObjectId.MONEY;
+import static io.r2dbc.postgresql.type.PostgresqlObjectId.TIMETZ;
+import static io.r2dbc.postgresql.type.PostgresqlObjectId.VARCHAR;
+import static io.r2dbc.postgresql.util.ByteBufUtils.encode;
+import static io.r2dbc.postgresql.util.TestByteBufAllocator.TEST;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+
+/**
+ * Unit tests for {@link OffsetTimeCodec}.
+ */
+class OffsetTimeCodecUnitTests {
+
+    private static final int dataType = TIMETZ.getObjectId();
+
+    @Test
+    void constructorNoByteBufAllocator() {
+        assertThatIllegalArgumentException().isThrownBy(() -> new OffsetTimeCodec(null))
+            .withMessage("byteBufAllocator must not be null");
+    }
+
+    @Test
+    void decode() {
+        OffsetTime offsetTime = OffsetTime.parse("21:16:41.123456-09:00");
+
+        assertThat(new OffsetTimeCodec(TEST).decode(encode(TEST, "21:16:41.123456-09:00"), dataType, FORMAT_TEXT, OffsetTime.class))
+            .isEqualTo(offsetTime);
+    }
+
+    @Test
+    void decodeNoByteBuf() {
+        assertThat(new OffsetTimeCodec(TEST).decode(null, dataType, FORMAT_TEXT, OffsetTime.class)).isNull();
+    }
+
+    @Test
+    void doCanDecode() {
+        OffsetTimeCodec codec = new OffsetTimeCodec(TEST);
+
+        assertThat(codec.doCanDecode(TIMETZ, FORMAT_BINARY)).isTrue();
+        assertThat(codec.doCanDecode(MONEY, FORMAT_TEXT)).isFalse();
+        assertThat(codec.doCanDecode(TIMETZ, FORMAT_TEXT)).isTrue();
+    }
+
+    @Test
+    void doCanDecodeNoFormat() {
+        assertThatIllegalArgumentException().isThrownBy(() -> new OffsetTimeCodec(TEST).doCanDecode(VARCHAR, null))
+            .withMessage("format must not be null");
+    }
+
+    @Test
+    void doCanDecodeNoType() {
+        assertThatIllegalArgumentException().isThrownBy(() -> new OffsetTimeCodec(TEST).doCanDecode(null, FORMAT_TEXT))
+            .withMessage("type must not be null");
+    }
+
+    @Test
+    void doEncode() {
+        OffsetTime offsetTime = OffsetTime.now();
+
+        ParameterAssert.assertThat(new OffsetTimeCodec(TEST).doEncode(offsetTime))
+            .hasFormat(FORMAT_TEXT)
+            .hasType(TIMETZ.getObjectId())
+            .hasValue(encode(TEST, offsetTime.toString()));
+    }
+
+    @Test
+    void doEncodeNoValue() {
+        assertThatIllegalArgumentException().isThrownBy(() -> new OffsetTimeCodec(TEST).doEncode(null))
+            .withMessage("value must not be null");
+    }
+
+    @Test
+    void encodeNull() {
+        ParameterAssert.assertThat(new OffsetTimeCodec(TEST).encodeNull())
+            .isEqualTo(new Parameter(FORMAT_TEXT, TIMETZ.getObjectId(), NULL_VALUE));
+    }
+
+}