Java enum Row/Tuple support for PostgreSQL - fixes #612

Author: vietj

vertx-pg-client/src/main/asciidoc/index.adoc

@@ -348,6 +348,33 @@ Text search is handling using java `String`
 {@link examples.PgClientExamples#tsQuery02Example}
 ----
 
+== Handling enumerated types
+
+PostgreSQL https://www.postgresql.org/docs/9.1/datatype-enum.html[enumerated types] are mapped to java strings.
+
+[source,$lang]
+----
+{@link examples.PgClientExamples#enumeratedType01Example}
+----
+
+== Using Java enum types
+
+You can map Java https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html[enum types] to these column
+types:
+
+- Strings (VARCHAR, TEXT)
+- PosgreSQL enumerated types
+- Numbers (INT2, INT4, INT8)
+
+[source,$lang]
+----
+{@link examples.PgClientExamples#enumType01Example}
+----
+
+String and PostgreSQL enumerated types are matched with the Java enum's name returned by the `name()` method.
+
+Numbers types are matched with the Java enum's ordinal returned by the `ordinal()` method.
+
 == Collector queries
 
 You can use Java collectors with the query API:

vertx-pg-client/src/main/java/examples/PgClientExamples.java

@@ -537,6 +537,36 @@ public void tsQuery02Example(SqlClient client) {
     });
   }
 
+  public void enumeratedType01Example(SqlClient client) {
+    client
+      .preparedQuery("INSERT INTO colors VALUES ($2)")
+      .execute(Tuple.of("red"),  res -> {
+        // ...
+      });
+  }
+
+  enum Color {
+    red
+  }
+
+  public void enumType01Example(SqlClient client) {
+    client
+      .preparedQuery("INSERT INTO colors VALUES ($1)")
+      .execute(Tuple.of(Color.red))
+      .flatMap(res ->
+        client
+          .preparedQuery("SELECT color FROM colors")
+          .execute()
+      ).onComplete(res -> {
+        if (res.succeeded()) {
+          RowSet<Row> rows = res.result();
+          for (Row row : rows) {
+            System.out.println(row.get(Color.class, "color"));
+          }
+        }
+    });
+  }
+
   public void collector01Example(SqlClient client) {
 
     // Create a collector projecting a row set to a map

vertx-pg-client/src/main/java/io/vertx/pgclient/impl/RowImpl.java

@@ -33,6 +33,7 @@
 import io.vertx.sqlclient.impl.RowDesc;
 import io.vertx.core.buffer.Buffer;
 
+import java.lang.reflect.Array;
 import java.time.*;
 import java.util.List;
 import java.util.UUID;
@@ -121,6 +122,8 @@ public <T> T get(Class<T> type, int pos) {
       return type.cast(getJson(pos));
     } else if (type == Object.class) {
       return type.cast(getValue(pos));
+    } else if (type.isEnum()) {
+      return type.cast(getEnum(type, pos));
     }
     throw new UnsupportedOperationException("Unsupported type " + type.getName());
   }
@@ -179,6 +182,8 @@ public <T> T[] getValues(Class<T> type, int pos) {
       return (T[]) getBoxArray(pos);
     } else if (type == Object.class) {
       return (T[]) getJsonArray_(pos);
+    } else if (type.isEnum()) {
+      return (T[]) getEnumArray(type, pos);
     }
     throw new UnsupportedOperationException("Unsupported type " + type.getName());
   }
@@ -278,6 +283,52 @@ public Character[] getCharArray(String name) {
     return pos == -1 ? null : getCharArray(pos);
   }
 
+  public Object getEnum(Class enumType, int pos) {
+    Object val = getValue(pos);
+    if (val instanceof String) {
+      return Enum.valueOf(enumType, (String) val);
+    } else if (val instanceof Number) {
+      int ordinal = ((Number) val).intValue();
+      if (ordinal >= 0) {
+        Object[] constants = enumType.getEnumConstants();
+        if (ordinal < constants.length) {
+          return constants[ordinal];
+        }
+      }
+    }
+    return null;
+  }
+
+  public Object[] getEnumArray(Class enumType, int pos) {
+    Object val = getValue(pos);
+    if (val instanceof String[]) {
+      String[] array = (String[]) val;
+      Object[] ret = (Object[]) Array.newInstance(enumType, array.length);
+      for (int i = 0;i < array.length;i++) {
+        String string = array[i];
+        if (string != null) {
+          ret[i] = Enum.valueOf(enumType, string);
+        }
+      }
+      return ret;
+    } else if (val instanceof Number[]) {
+      Number[] array = (Number[]) val;
+      Object[] ret = (Object[]) Array.newInstance(enumType, array.length);
+      Object[] constants = enumType.getEnumConstants();
+      for (int i = 0;i < array.length;i++) {
+        Number number = array[i];
+        int ordinal = number.intValue();
+        if (ordinal >= 0) {
+          if (ordinal < constants.length) {
+            ret[i] = constants[ordinal];
+          }
+        }
+      }
+      return ret;
+    }
+    return null;
+  }
+
   public Character getChar(int pos) {
     Object val = getValue(pos);
     if (val instanceof Character) {

vertx-pg-client/src/main/java/io/vertx/pgclient/impl/codec/DataTypeCodec.java

@@ -606,16 +606,21 @@ public static Object decodeText(DataType id, int index, int len, ByteBuf buff) {
 
 
   public static Object prepare(DataType type, Object value) {
+    if (value instanceof Enum) {
+      value = prepare(type, (Enum<?>) value);
+    } else if (value instanceof Enum[]) {
+      value = prepare(type, (Enum<?>[]) value);
+    }
     switch (type) {
       case JSON:
       case JSONB:
         if (value == null ||
-            value == Tuple.JSON_NULL ||
-            value instanceof String ||
-            value instanceof Boolean ||
-            value instanceof Number ||
-            value instanceof JsonObject ||
-            value instanceof JsonArray) {
+          value == Tuple.JSON_NULL ||
+          value instanceof String ||
+          value instanceof Boolean ||
+          value instanceof Number ||
+          value instanceof JsonObject ||
+          value instanceof JsonArray) {
           return value;
         } else {
           return REFUSED_SENTINEL;
@@ -625,13 +630,53 @@ public static Object prepare(DataType type, Object value) {
           return Arrays.stream((String[]) value).collect(Collectors.joining(",", "{", "}"));
         } else if (value == null || value instanceof String) {
           return value;
-        } else {
-          return REFUSED_SENTINEL;
         }
-      default:
-        Class<?> javaType = type.decodingType;
-        return value == null || javaType.isInstance(value) ? value : REFUSED_SENTINEL;
+        break;
+    }
+    Class<?> javaType = type.decodingType;
+    if (value == null || javaType.isInstance(value)) {
+      return value;
+    }
+    return REFUSED_SENTINEL;
+  }
+
+  private static Object prepare(DataType type, Enum<?> value) {
+    switch (type) {
+      case INT2:
+      case INT4:
+      case INT8:
+        return value.ordinal();
+      case UNKNOWN:
+      case VARCHAR:
+      case TEXT:
+        return value.name();
     }
+    return value;
+  }
+
+  private static Object prepare(DataType type, Enum<?>[] value) {
+    int len = value.length;
+    switch (type) {
+      case INT2_ARRAY:
+      case INT4_ARRAY:
+      case INT8_ARRAY: {
+        Number[] ret = new Number[len];
+        for (int i = 0; i < len; i++) {
+          ret[i] = value[i].ordinal();
+        }
+        return ret;
+      }
+      case UNKNOWN:
+      case VARCHAR_ARRAY:
+      case TEXT_ARRAY: {
+        String[] ret = new String[len];
+        for (int i = 0; i < len; i++) {
+          ret[i] = value[i].name();
+        }
+        return ret;
+      }
+    }
+    return value;
   }
 
   private static Object defaultDecodeText(int index, int len, ByteBuf buff) {