bring back relational support to get/set UUID

Author: g31pranjal

fdb-relational-api/src/main/java/com/apple/foundationdb/relational/api/RelationalPreparedStatement.java

@@ -45,6 +45,7 @@
 import java.sql.Time;
 import java.sql.Timestamp;
 import java.util.Calendar;
+import java.util.UUID;
 
 /**
  * Extension of {@link java.sql.PreparedStatement} to allow for Relational specific Prepared Statements.
@@ -160,6 +161,29 @@ public interface RelationalPreparedStatement extends java.sql.PreparedStatement
      */
     void setObject(String parameterName, Object x) throws SQLException;
 
+    /**
+     * Sets the designated parameter to the given Java <code>UUID</code> value.
+     *
+     * @param parameterIndex the first parameter is 1, the second is 2, ...
+     * @param x the parameter value
+     * @exception SQLException if parameterIndex does not correspond to a parameter
+     * marker in the SQL statement;
+     * if a database access error occurs or
+     * this method is called on a closed <code>PreparedStatement</code>
+     */
+    void setUUID(int parameterIndex, UUID x) throws SQLException;
+
+    /**
+     * Sets the designated parameter to the given Java <code>UUID</code> value.
+     *
+     * @param parameterName the name of the parameter
+     * @param x the parameter value
+     * @exception SQLException if parameterName does not correspond to a parameter
+     * marker in the SQL statement; if a database access error occurs or
+     * this method is called on a closed <code>PreparedStatement</code>
+     */
+    void setUUID(String parameterName, UUID x) throws SQLException;
+
     /**
      * Sets the designated parameter to SQL <code>NULL</code>.
      *

fdb-relational-api/src/main/java/com/apple/foundationdb/relational/api/RelationalStruct.java

@@ -28,6 +28,7 @@
 import java.sql.Struct;
 import java.sql.Wrapper;
 import java.util.Map;
+import java.util.UUID;
 
 /**
  * A {@link Struct} but with metadata describing the instance.
@@ -76,6 +77,10 @@ public interface RelationalStruct extends Struct, Wrapper {
 
     RelationalArray getArray(String fieldName) throws SQLException;
 
+    UUID getUUID(int oneBasedPosition) throws SQLException;
+
+    UUID getUUID(String fieldName) throws SQLException;
+
     /**
      * Reports whether the last column read had a value of SQL NULL. See {@link ResultSet#wasNull()}
      */

fdb-relational-api/src/main/java/com/apple/foundationdb/relational/api/SqlTypeNamesSupport.java

@@ -25,6 +25,7 @@
 import java.sql.Array;
 import java.sql.Struct;
 import java.sql.Types;
+import java.util.UUID;
 
 /**
  * Class to host method taken from SqlTypeSupport needed by
@@ -116,6 +117,8 @@ public static int getSqlTypeCodeFromObject(Object obj) {
             return Types.ARRAY;
         } else if (obj instanceof Struct) {
             return Types.STRUCT;
+        } else if (obj instanceof UUID) {
+            return Types.OTHER;
         } else {
             throw new IllegalStateException("Unexpected object type: " + obj.getClass().getName());
         }

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/api/RowStruct.java

@@ -20,11 +20,14 @@
 
 package com.apple.foundationdb.relational.api;
 
+import com.apple.foundationdb.record.TupleFieldsProto;
+import com.apple.foundationdb.record.metadata.expressions.TupleFieldsHelper;
 import com.apple.foundationdb.relational.api.exceptions.ErrorCode;
 import com.apple.foundationdb.relational.api.exceptions.InvalidColumnReferenceException;
 import com.apple.foundationdb.relational.api.exceptions.RelationalException;
 import com.apple.foundationdb.relational.api.exceptions.UncheckedRelationalException;
 import com.apple.foundationdb.relational.recordlayer.MessageTuple;
+import com.apple.foundationdb.relational.util.Assert;
 import com.apple.foundationdb.relational.util.NullableArrayUtils;
 import com.google.protobuf.ByteString;
 import com.google.protobuf.Descriptors;
@@ -36,6 +39,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Locale;
+import java.util.UUID;
 
 /**
  * Implementation of {@link RelationalStruct} that is backed by a {@link Row}.
@@ -186,6 +190,19 @@ public Object getObject(int oneBasedPosition) throws SQLException {
                 return getArray(oneBasedPosition);
             case Types.BINARY:
                 return getBytes(oneBasedPosition);
+            case Types.OTHER:
+                final var object = getObjectInternal(getZeroBasedPosition(oneBasedPosition));
+                // This is a temporary workaround to support UUID as a primitive type. The fix essentially involves
+                // delaying the conversion of a message field (of type UUID) in the messageTuple until now when we can
+                // (little bit) predict that the field is actually a pre-defined UUID message. If the UUID message
+                // field is of sql.Types.OTHER (rather than sql.Types.STRUCT), we can expect that the plan is baked with
+                // the future-supported UUID type, and hence the result expects a JAVA UUID object. This can be
+                // removed (and pushed to MessageTuple) once we have proper and complete support for UUID.
+                if (object instanceof TupleFieldsProto.UUID) {
+                    return TupleFieldsHelper.fromProto((TupleFieldsProto.UUID) object);
+                } else  {
+                    return object;
+                }
             default:
                 return getObjectInternal(getZeroBasedPosition(oneBasedPosition));
         }
@@ -295,6 +312,24 @@ public RelationalStruct getStruct(int oneBasedColumn) throws SQLException {
         }
     }
 
+    @Override
+    public UUID getUUID(String columnLabel) throws SQLException {
+        return getUUID(getOneBasedPosition(columnLabel));
+    }
+
+    @Override
+    public UUID getUUID(int oneBasedColumn) throws SQLException {
+        if (metaData.getColumnType(oneBasedColumn) != Types.OTHER) {
+            throw new SQLException("Expected UUID should have type OTHER", ErrorCode.CANNOT_CONVERT_TYPE.getErrorCode());
+        }
+        Object obj = getObjectInternal(getZeroBasedPosition(oneBasedColumn));
+        if (obj == null) {
+            return null;
+        }
+        Assert.thatUnchecked(obj instanceof UUID, ErrorCode.CANNOT_CONVERT_TYPE, "Expected UUID, got {}", obj.getClass().getName());
+        return (UUID) obj;
+    }
+
     @Override
     public RelationalStruct getStruct(String columnLabel) throws SQLException {
         return getStruct(getOneBasedPosition(columnLabel));

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/api/SqlTypeSupport.java

@@ -98,7 +98,8 @@ public static int recordTypeToSqlType(Type.TypeCode typeCode) {
             case VERSION:
                 return Types.BINARY;
             case ENUM:
-                //TODO(bfines) should be string?
+            case UUID:
+                // There are no specific JDBC types for ENUM and UUID, hence, defaulting to Types.OTHER.
                 return Types.OTHER;
             case RECORD:
                 return Types.STRUCT;
@@ -185,7 +186,7 @@ private static Type.Record.Field descriptionToField(@Nonnull FieldDescription de
     @Nonnull
     private static FieldDescription fieldToDescription(@Nonnull Type.Record.Field field) throws RelationalException {
         final Type fieldType = field.getFieldType();
-        if (fieldType.isPrimitive() || fieldType instanceof Type.Enum) {
+        if (fieldType.isPrimitive() || fieldType instanceof Type.Enum || fieldType instanceof Type.Uuid) {
             return FieldDescription.primitive(field.getFieldName(),
                     SqlTypeSupport.recordTypeToSqlType(fieldType.getTypeCode()),
                     fieldType.isNullable() ? DatabaseMetaData.columnNullable : DatabaseMetaData.columnNoNulls,

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/AbstractRecordLayerResultSet.java

@@ -32,6 +32,7 @@
 import com.apple.foundationdb.relational.api.exceptions.RelationalException;
 
 import java.sql.SQLException;
+import java.util.UUID;
 
 public abstract class AbstractRecordLayerResultSet implements RelationalResultSet {
 
@@ -208,6 +209,22 @@ public RelationalArray getArray(String columnLabel) throws SQLException {
         return currentRow.getArray(columnLabel);
     }
 
+    @Override
+    public UUID getUUID(int oneBasedPosition) throws SQLException {
+        if (!currentRow.hasRow()) {
+            throw new SQLException("ResultSet exhausted", ErrorCode.INVALID_CURSOR_STATE.getErrorCode());
+        }
+        return currentRow.getUUID(oneBasedPosition);
+    }
+
+    @Override
+    public UUID getUUID(String columnLabel) throws SQLException {
+        if (!currentRow.hasRow()) {
+            throw new SQLException("ResultSet exhausted", ErrorCode.INVALID_CURSOR_STATE.getErrorCode());
+        }
+        return currentRow.getUUID(columnLabel);
+    }
+
     @Override
     public RelationalStruct getStruct(int oneBasedColumn) throws SQLException {
         if (!currentRow.hasRow()) {

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/EmbeddedRelationalPreparedStatement.java

@@ -38,6 +38,7 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.TreeMap;
+import java.util.UUID;
 
 @API(API.Status.EXPERIMENTAL)
 public class EmbeddedRelationalPreparedStatement extends AbstractEmbeddedStatement implements RelationalPreparedStatement {
@@ -189,6 +190,18 @@ public void setObject(String parameterName, Object x) throws SQLException {
         namedParameters.put(parameterName, x);
     }
 
+    @Override
+    public void setUUID(final int parameterIndex, final UUID x) throws SQLException {
+        checkOpen();
+        parameters.put(parameterIndex, x);
+    }
+
+    @Override
+    public void setUUID(final String parameterName, final UUID x) throws SQLException {
+        checkOpen();
+        namedParameters.put(parameterName, x);
+    }
+
     @Override
     public void setNull(int parameterIndex, int sqlType) throws SQLException {
         checkOpen();

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/ErrorCapturingResultSet.java

@@ -30,6 +30,7 @@
 
 import javax.annotation.Nonnull;
 import java.sql.SQLException;
+import java.util.UUID;
 
 @API(API.Status.EXPERIMENTAL)
 public class ErrorCapturingResultSet implements RelationalResultSet {
@@ -233,6 +234,24 @@ public RelationalArray getArray(String columnLabel) throws SQLException {
         }
     }
 
+    @Override
+    public UUID getUUID(final int oneBasedPosition) throws SQLException {
+        try {
+            return delegate.getUUID(oneBasedPosition);
+        } catch (RuntimeException re) {
+            throw ExceptionUtil.toRelationalException(re).toSqlException();
+        }
+    }
+
+    @Override
+    public UUID getUUID(final String fieldName) throws SQLException {
+        try {
+            return delegate.getUUID(fieldName);
+        } catch (RuntimeException re) {
+            throw ExceptionUtil.toRelationalException(re).toSqlException();
+        }
+    }
+
     @Override
     public boolean isClosed() throws SQLException {
         return delegate.isClosed();

fdb-relational-core/src/test/java/com/apple/foundationdb/relational/compare/JDBCDatabaseMetaData.java

@@ -25,15 +25,14 @@
 
 import javax.annotation.Nonnull;
 import java.sql.Connection;
-import java.sql.DatabaseMetaData;
 import java.sql.ResultSet;
 import java.sql.RowIdLifetime;
 import java.sql.SQLException;
 
 public class JDBCDatabaseMetaData implements RelationalDatabaseMetaData {
-    private final DatabaseMetaData metaData;
+    private final RelationalDatabaseMetaData metaData;
 
-    public JDBCDatabaseMetaData(DatabaseMetaData metaData) {
+    public JDBCDatabaseMetaData(RelationalDatabaseMetaData metaData) {
         this.metaData = metaData;
     }
 

fdb-relational-core/src/test/java/com/apple/foundationdb/relational/compare/JDBCRelationalResultSet.java

@@ -37,7 +37,6 @@
 import java.sql.Date;
 import java.sql.NClob;
 import java.sql.Ref;
-import java.sql.ResultSet;
 import java.sql.RowId;
 import java.sql.SQLException;
 import java.sql.SQLFeatureNotSupportedException;
@@ -49,11 +48,12 @@
 import java.sql.Timestamp;
 import java.util.Calendar;
 import java.util.Map;
+import java.util.UUID;
 
 public class JDBCRelationalResultSet implements RelationalResultSet {
-    private final ResultSet delegate;
+    private final RelationalResultSet delegate;
 
-    public JDBCRelationalResultSet(ResultSet resultSet) {
+    public JDBCRelationalResultSet(RelationalResultSet resultSet) {
         delegate = resultSet;
     }
 
@@ -576,7 +576,7 @@ public Clob getClob(int columnIndex) throws SQLException {
     @Override
     public RelationalArray getArray(int columnIndex) throws SQLException {
         //TODO(bfines) this almost certainly won't work
-        return (RelationalArray) delegate.getArray(columnIndex);
+        return delegate.getArray(columnIndex);
     }
 
     @Override
@@ -601,8 +601,17 @@ public Clob getClob(String columnLabel) throws SQLException {
 
     @Override
     public RelationalArray getArray(String columnLabel) throws SQLException {
-        //TODO(bfines) this almost certainly won't work
-        return (RelationalArray) delegate.getArray(columnLabel);
+        return delegate.getArray(columnLabel);
+    }
+
+    @Override
+    public UUID getUUID(final int oneBasedPosition) throws SQLException {
+        return delegate.getUUID(oneBasedPosition);
+    }
+
+    @Override
+    public UUID getUUID(final String fieldName) throws SQLException {
+        return delegate.getUUID(fieldName);
     }
 
     @Override