Adding LocalDateTime conversion and some code clean up

Author: Michael-A-McMahon

src/main/java/oracle/r2dbc/impl/OracleColumnMetadataImpl.java

@@ -204,11 +204,10 @@ static OracleColumnMetadataImpl fromResultSetMetaData(
 
       case Types.DATE:
         // Override JDBC's java.sql.Date type mapping to use LocalDate
-        return newMetadata(
-          LocalDate.class, resultSetMetaData, jdbcIndex);
+        return newMetadata(LocalDate.class, resultSetMetaData, jdbcIndex);
 
-      case OracleTypes.TIMESTAMPLTZ:
       case Types.TIMESTAMP:
+      case OracleTypes.TIMESTAMPLTZ:
         // Override JDBC's java.sql.Timestamp type mapping, and Oracle JDBC's
         // oracle.sql.TIMESTAMPLTZ type mapping to use LocalDateTime, and to
         // use an appropriate precision value. Note that the Oracle type

src/main/java/oracle/r2dbc/impl/OracleReactiveJdbcAdapter.java

@@ -25,8 +25,6 @@
 import io.r2dbc.spi.Option;
 import io.r2dbc.spi.R2dbcException;
 import io.r2dbc.spi.R2dbcTimeoutException;
-import io.r2dbc.spi.Result;
-import io.r2dbc.spi.Row;
 import oracle.jdbc.OracleBlob;
 import oracle.jdbc.OracleClob;
 import oracle.jdbc.OracleConnection;
@@ -49,17 +47,12 @@
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
-import java.sql.RowId;
 import java.sql.SQLException;
-import java.sql.Statement;
-import java.sql.Types;
 import java.sql.Wrapper;
 import java.time.Duration;
-import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Flow;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.locks.ReentrantLock;

src/main/java/oracle/r2dbc/impl/OracleRowImpl.java

@@ -25,15 +25,13 @@
 import io.r2dbc.spi.Clob;
 import io.r2dbc.spi.R2dbcException;
 import io.r2dbc.spi.Row;
-import oracle.jdbc.OracleType;
+import oracle.jdbc.OracleTypes;
 
-import java.io.IOException;
 import java.nio.ByteBuffer;
-import java.sql.JDBCType;
 import java.sql.ResultSet;
-import java.sql.SQLType;
+import java.sql.Timestamp;
 import java.sql.Types;
-import java.util.Objects;
+import java.time.LocalDateTime;
 
 import static oracle.r2dbc.impl.OracleR2dbcExceptions.requireNonNull;
 
@@ -42,7 +40,7 @@
  * Implementation of the {@link Row} SPI for Oracle Database.
  * </p><p>
  * Instances of this class supply the column values of a
- * {@link ReactiveJdbcAdapter.JdbcRow} which represents one row of data
+ * {@link ReactiveJdbcAdapter.JdbcRow} that represents one row of data
  * from a JDBC {@link ResultSet}.
  * </p>
  *
@@ -62,7 +60,7 @@ final class OracleRowImpl implements Row {
 
   /**
    * <p>
-   * Constructs a new row which supplies column values from the specified
+   * Constructs a new row that supplies column values from the specified
    * {@code jdbcRow}, and uses the specified {@code rowMetadata} to determine
    * the default type mapping of column values.
    * </p>
@@ -112,7 +110,7 @@ public Object get(int index) {
   /**
    * {@inheritDoc}
    * <p>
-   * Implements the R2DBC SPI method by using the JDBC ResultSet which backs
+   * Implements the R2DBC SPI method by using the JDBC ResultSet that backs
    * this row to convert the specified column value into the specified {@code
    * type}.
    * </p><p>
@@ -145,7 +143,7 @@ public <T> T get(int index, Class<T> type) {
   /**
    * {@inheritDoc}
    * <p>
-   * Implements the R2DBC SPI method by using the JDBC ResultSet which backs
+   * Implements the R2DBC SPI method by using the JDBC ResultSet that backs
    * this row to convert the specified column value into the Oracle R2DBC
    * Driver's default Java type mapping for the column's SQL type.
    * </p><p>
@@ -181,7 +179,7 @@ public Object get(String name) {
   /**
    * {@inheritDoc}
    * <p>
-   * Implements the R2DBC SPI method by using the JDBC ResultSet which backs
+   * Implements the R2DBC SPI method by using the JDBC ResultSet that backs
    * this row to convert the specified column value into the specified {@code
    * type}.
    * </p><p>
@@ -234,7 +232,7 @@ private int getColumnIndex(String name) {
    * Converts the value of a column at a specified {@code index} to the
    * specified {@code type}. This method implements conversions to target
    * types that are not supported by JDBC drivers. The Oracle R2DBC Driver
-   * will implement some conversions which adapt JDBC supported types into
+   * will implement some conversions that adapt JDBC supported types into
    * R2DBC supported types.
    *
    * @param index 0-based index of a column
@@ -252,6 +250,8 @@ else if (type.equals(io.r2dbc.spi.Blob.class))
       return type.cast(getBlob(index));
     else if (type.equals(io.r2dbc.spi.Clob.class))
       return type.cast(getClob(index));
+    else if (type.equals(LocalDateTime.class))
+      return type.cast(getLocalDateTime(index));
     else
       return jdbcRow.getObject(index, type);
   }
@@ -263,7 +263,7 @@ else if (type.equals(io.r2dbc.spi.Clob.class))
    * </p><p>
    * A JDBC driver is not required to support {@code ByteBuffer} conversions
    * for any SQL type, so this method is necessary to implement the
-   * conversion to {@code ByteBuffer} from a type which is supported by JDBC.
+   * conversion to {@code ByteBuffer} from a type that is supported by JDBC.
    * </p><p>
    * This method should NOT be called when the database column type is BLOB.
    * The JDBC driver may require blocking network I/O in order to materialize a
@@ -285,7 +285,7 @@ private ByteBuffer getByteBuffer(int index) {
    * </p><p>
    * A JDBC driver is not required to support {@code io.r2dbc.spi.Blob}
    * conversions for any SQL type, so this method is necessary to implement the
-   * conversion to {@code Blob} from a type which is supported by JDBC.
+   * conversion to {@code Blob} from a type that is supported by JDBC.
    * </p>
    * @param index 0 based column index
    * @return A column value as a {@code Blob}, or null if the column
@@ -307,27 +307,27 @@ private Blob getBlob(int index) {
    * </p><p>
    * A JDBC driver is not required to support {@code io.r2dbc.spi.Clob}
    * conversions for any SQL type, so this method is necessary to implement the
-   * conversion to {@code Clob} from a type which is supported by JDBC.
+   * conversion to {@code Clob} from a type that is supported by JDBC.
    * </p>
    * @param index 0 based column index
    * @return A column value as a {@code Clob}, or null if the column
    * value is NULL.
    */
   private Clob getClob(int index) {
-    Integer columnTypeCode =
-      rowMetadata.getColumnMetadata(index)
-        .getNativeTypeMetadata()
-        .getVendorTypeNumber();
 
-    boolean isNChar = columnTypeCode != null &&
-      (columnTypeCode == Types.NCLOB
-        || columnTypeCode == Types.NCHAR
-        || columnTypeCode == Types.NVARCHAR
-        || columnTypeCode == Types.LONGNVARCHAR);
-
-    java.sql.Clob jdbcClob = isNChar
-      ? jdbcRow.getObject(index, java.sql.NClob.class)
-      : jdbcRow.getObject(index, java.sql.Clob.class);
+    // Convert to a JDBC NClob or Clob, depending on the column type
+    final java.sql.Clob jdbcClob;
+    switch (getColumnTypeNumber(index)) {
+      case Types.NCLOB:
+      case Types.LONGNVARCHAR:
+      case Types.NVARCHAR:
+      case Types.NCHAR:
+        jdbcClob = jdbcRow.getObject(index, java.sql.NClob.class);
+        break;
+      default:
+        jdbcClob = jdbcRow.getObject(index, java.sql.Clob.class);
+        break;
+    }
 
     return jdbcClob == null
       ? null
@@ -336,6 +336,35 @@ private Clob getClob(int index) {
           adapter.publishClobFree(jdbcClob));
   }
 
+  /**
+   * <p>
+   * Converts the value of a column at the specified {@code index} to a
+   * {@code LocalDateTime}.
+   * </p><p>
+   * A JDBC driver is not required to support {@code LocalDateTime} conversions
+   * for any SQL type. The Oracle JDBC driver is known to support {@code
+   * LocalDateTime} conversions for DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE.
+   * </p><p>
+   * The 21.1 Oracle JDBC Driver does not implement a correct conversion for
+   * TIMESTAMP WITH LOCAL TIME ZONE; The driver returns a value in the database
+   * timezone rather than the session time zone. A correct conversion is
+   * implemented for {@code java.sql.Timestamp}, so this method is implemented
+   * to convert that into a {@code LocalDateTime}.
+   * </p>
+   * @param index 0 based column index
+   * @return A column value as a {@code Clob}, or null if the column
+   * value is NULL.
+   */
+  private LocalDateTime getLocalDateTime(int index) {
+    if (getColumnTypeNumber(index) == OracleTypes.TIMESTAMPLTZ) {
+      Timestamp timestamp = jdbcRow.getObject(index, Timestamp.class);
+      return timestamp == null ? null : timestamp.toLocalDateTime();
+    }
+    else {
+      return jdbcRow.getObject(index, LocalDateTime.class);
+    }
+  }
+
   /**
    * Checks if the specified zero-based {@code index} is a valid column index
    * for this row. This method is used to verify index value parameters
@@ -361,7 +390,7 @@ else if (index >= rowMetadata.getColumnNames().size()) {
    * as {@code type}.
    * </p><p>
    * This method handles cases where the JDBC driver may support a mapping 
-   * which the Oracle R2DBC Driver does not support. For instance, the JDBC
+   * that the Oracle R2DBC Driver does not support. For instance, the JDBC
    * driver may support mapping CLOB columns to String, but the Oracle R2DBC
    * Driver does not support this as the JDBC driver may require blocking 
    * network I/O to convert a CLOB into a String.
@@ -372,15 +401,8 @@ else if (index >= rowMetadata.getColumnNames().size()) {
    * @throws R2dbcException if the type mapping is not supported
    */
   private void requireSupportedTypeMapping(int index, Class<?> type) {
-    Integer sqlTypeCode =
-      rowMetadata.getColumnMetadata(index)
-        .getNativeTypeMetadata()
-        .getVendorTypeNumber();
-
-    if (sqlTypeCode == null)
-      return;
 
-    switch (sqlTypeCode) {
+    switch (getColumnTypeNumber(index)) {
       case Types.BLOB:
         if (! type.equals(Blob.class))
           throw unsupportedTypeMapping("BLOB", index, type);
@@ -392,6 +414,23 @@ private void requireSupportedTypeMapping(int index, Class<?> type) {
     }
   }
 
+  /**
+   * Returns the SQL type number of the column at a given {@code index}. The
+   * returned number identifies either a standard type defined by
+   * {@link Types} or a vendor specific type defined by the JDBC driver. This
+   * method returns {@link Types#OTHER} if the JDBC driver does not provide a
+   * type code for the column.
+   * @param index 0 based column index
+   * @return A SQL type number
+   */
+  private int getColumnTypeNumber(int index) {
+    Integer typeNumber = rowMetadata.getColumnMetadata(index)
+      .getNativeTypeMetadata()
+      .getVendorTypeNumber();
+
+    return typeNumber == null ? Types.OTHER : typeNumber;
+  }
+
   /**
    * Returns an exception indicating that the Oracle R2DBC Driver does
    * not support mapping the database type specified as {@code sqlTypeName}
@@ -401,7 +440,7 @@ private void requireSupportedTypeMapping(int index, Class<?> type) {
    * @param type Java type to which mapping is not supported
    * @return An exception that expresses the unsupported mapping
    */
-  private R2dbcException unsupportedTypeMapping(
+  private static R2dbcException unsupportedTypeMapping(
     String sqlTypeName, int index, Class<?> type) {
     return OracleR2dbcExceptions.newNonTransientException(
       String.format("Unsupported SQL to Java type mapping. " +

src/test/java/oracle/r2dbc/impl/TypeMappingTest.java

@@ -42,10 +42,9 @@
 import java.time.Month;
 import java.time.OffsetDateTime;
 import java.time.Period;
+import java.time.ZoneId;
 import java.time.ZoneOffset;
 import java.time.temporal.ChronoUnit;
-import java.util.Base64;
-import java.util.Optional;
 import java.util.function.BiConsumer;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -60,8 +59,6 @@
 import static oracle.r2dbc.util.Awaits.awaitOne;
 import static oracle.r2dbc.util.Awaits.awaitUpdate;
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * <p>
@@ -460,7 +457,7 @@ private static <T> void verifyTypeMapping(
           "SELECT javaValue FROM "+table+" WHERE javaValue IS NOT NULL")
           .execute())
           .flatMap(result ->
-              result.map((row, metadata) -> row.get("javaValue"))
+            result.map((row, metadata) -> row.get("javaValue"))
           )));
 
       awaitOne(true,