New DataTypes

modules/common/app/edu/berkeley/ground/common/model/version/GroundType.java

@@ -15,6 +15,9 @@
 import edu.berkeley.ground.common.exception.GroundException;
 import edu.berkeley.ground.common.exception.GroundException.ExceptionType;
 import java.sql.Types;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.Arrays;
 
 public enum GroundType {
   STRING(String.class, "string", Types.VARCHAR) {
@@ -40,6 +43,60 @@ public Object parse(String str) {
     public Object parse(String str) {
       return Long.parseLong(str);
     }
+  },
+  DOUBLE(Double.class, "double", Types.DOUBLE) {
+    @Override
+    public Object parse(String str) {
+      return Double.parseDouble(str);
+      //throw new java.lang.UnsupportedOperationException("Not supported yet.");
+    }
+  },
+  NULL(null, "null", Types.NULL) {
+    @Override
+    public Object parse(String str) {
+      return null;
+      //throw new java.lang.UnsupportedOperationException("Not supported yet.");
+    }
+  },
+  ARRAY(ArrayList.class, "array", Types.ARRAY) {
+    @Override
+    public Object parse(String str) {
+      //return new ArrayList<String>(Arrays.asList(str.split("\\s*,\\s*")));
+      //return str;
+      throw new java.lang.UnsupportedOperationException("Not supported yet.");
+    }
+  },
+  JSON(LinkedHashMap.class, "json", Types.VARCHAR) {
+    @Override
+    public Object parse(String str) {
+      /*
+      LinkedHashMap<String, String> myMap = new LinkedHashMap<String, String>();
+      String[] pairs = str.split(",");
+      for (int i=0;i<pairs.length;i++) {
+        String pair = pairs[i];
+        String[] keyValue = pair.split(":");
+        myMap.put(keyValue[0], keyValue[1]);
+
+      }
+      return myMap;
+      */
+      //return str;
+      throw new java.lang.UnsupportedOperationException("Not supported yet.");
+    }
+  },
+  SET(ArrayList.class, "set", Types.ARRAY){
+    @Override
+    public Object parse(String str) {
+      //return str;
+      throw new java.lang.UnsupportedOperationException("Not supported yet.");
+    }
+  //},
+  //SET(String.class, "set", Types.VARCHAR){
+  //  @Override
+  //  public Object parse(String str) {
+  //    //return str;
+  //    throw new java.lang.UnsupportedOperationException("Not supported yet.");
+  //  }
   };
 
   private final Class<?> klass;

modules/common/app/edu/berkeley/ground/common/model/version/Tag.java

@@ -16,6 +16,9 @@
 import edu.berkeley.ground.common.exception.GroundException;
 import edu.berkeley.ground.common.exception.GroundException.ExceptionType;
 import java.util.Objects;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
 
 public class Tag {
 
@@ -44,9 +47,14 @@ public Tag(@JsonProperty("item_id") long id, @JsonProperty("key") String key, @J
               @JsonProperty("type") GroundType valueType)
     throws edu.berkeley.ground.common.exception.GroundException {
 
-    if (!((value != null) == (valueType != null))
+    if (!((value != null) == (valueType != null && valueType.getSqlType() != Types.NULL))
           || (value != null && !(value.getClass().equals(valueType.getTypeClass())))) {
-
+      /*
+      System.out.println(value.getClass());
+      System.out.println(value);
+      System.out.println(valueType.getTypeClass());
+      System.out.println(valueType.getSqlType());
+      */
       throw new GroundException(ExceptionType.OTHER, "Mismatch between value (" + value + ") and given type (" + valueType.toString() + ").");
     }
 

modules/common/test/edu/berkeley/ground/common/model/core/NodeVersionTest.java

@@ -24,6 +24,8 @@
 import edu.berkeley.ground.common.model.version.Tag;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import org.junit.Test;
 
 public class NodeVersionTest {
@@ -94,4 +96,37 @@ public void testNodeVersionNotEquals() throws Exception {
       new HashMap<>(), 10);
     assertFalse(truth.equals(differentNodeId));
   }
+
+  @Test
+  public void testNodeVersionTags() throws Exception {
+    Map<String, Tag> tagsMap = new HashMap<>();
+    tagsMap.put("testtag1", new Tag(1, "testtag1", "tag", GroundType.STRING));
+    tagsMap.put("testtag2", new Tag(2, "testtag2", 2, GroundType.INTEGER));
+    tagsMap.put("testtag3", new Tag(3, "testtag3", true, GroundType.BOOLEAN));
+    tagsMap.put("testtag4", new Tag(4, "testtag4", 9999999999999, GroundType.LONG));
+
+    ArrayList array = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4));
+    LinkedHashMap json = new LinkedHashMap<String, Object>();
+    json.put("ting", "skrr");
+    json.put("maths", 3);
+
+    Map<String, Tag> tagsMapEqual = new HashMap<>();
+    tagsMapEqual.put("testtag1", new Tag(1, "testtag1", 45.6, GroundType.DOUBLE));
+    tagsMapEqual.put("testtag2", new Tag(2, "testtag2", array, GroundType.ARRAY));
+    tagsMapEqual.put("testtag3", new Tag(3, "testtag3", null, GroundType.NULL));
+    tagsMapEqual.put("testtag4", new Tag(4, "testtag4", json, GroundType.JSON));
+
+    Map<String, String> parametersMap = new HashMap<>();
+    parametersMap.put("http", "POST");
+
+    Map<String, String> parametersMapEqual = new HashMap<>();
+    parametersMapEqual.put("http", "POST");
+
+    NodeVersion nodeVersion = new NodeVersion(1, tagsMap, 2, "http://www.google.com", parametersMap, 3);
+
+    NodeVersion nodeVersionEqual = new NodeVersion(1, tagsMapEqual, 2, "http://www.google.com", parametersMapEqual, 3);
+
+    assertFalse(nodeVersion.equals(nodeVersionEqual));
+
+  }
 }

modules/common/test/edu/berkeley/ground/common/model/versions/GroundTypeTest.java

@@ -14,6 +14,11 @@ public void testGetTypeFromString() throws GroundException {
     assertEquals(GroundType.INTEGER, GroundType.fromString("integer"));
     assertEquals(GroundType.LONG, GroundType.fromString("long"));
     assertEquals(GroundType.STRING, GroundType.fromString("string"));
+    assertEquals(GroundType.DOUBLE, GroundType.fromString("double"));
+    assertEquals(GroundType.NULL, GroundType.fromString("null"));
+    assertEquals(GroundType.ARRAY, GroundType.fromString("array"));
+    assertEquals(GroundType.JSON, GroundType.fromString("null"));
+    assertEquals(GroundType.SET, GroundType.fromString("set"));
   }
 
   @Test(expected = GroundException.class)
@@ -29,5 +34,7 @@ public void testParse() throws GroundException {
     assertEquals(GroundType.LONG.parse("54321"), 54321L);
     assertEquals(GroundType.BOOLEAN.parse("true"), true);
     assertEquals(GroundType.BOOLEAN.parse("false"), false);
+    assertEquals(GroundType.DOUBLE.parse("123.45"), 123.45);
+    assertEquals(GroundType.NULL.parse("null"), null);
   }
 }

modules/postgres/app/edu/berkeley/ground/postgres/dao/version/PostgresTagDao.java

@@ -22,6 +22,7 @@
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
+import java.sql.Types;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -51,7 +52,7 @@ public PostgresStatements insertItemTag(final Tag tag) {
   @Override
   public PostgresStatements insertRichVersionTag(final Tag tag) {
     List<String> sqlList = new ArrayList<>();
-    if (tag.getValue() != null) {
+    if (tag.getValue() != null || (tag != null && tag.getValueType() == GroundType.NULL)) {
       sqlList.add(String.format(SqlConstants.INSERT_RICH_VERSION_TAG_WITH_VALUE, tag.getId(), tag.getKey(), tag.getValue(), tag.getValueType()));
     } else {
       sqlList.add(String.format(SqlConstants.INSERT_RICH_VERSION_TAG_NO_VALUE, tag.getId(), tag.getKey()));

modules/postgres/dist/db/postgres.sql

@@ -15,7 +15,7 @@
 -- limitations under the License.
 
 -- VERSIONS
-CREATE TYPE data_type as enum ('integer', 'string', 'boolean');
+CREATE TYPE data_type as enum ('integer', 'string', 'boolean', 'long', 'double', 'null', 'array', 'json', 'set');
 
 CREATE TABLE IF NOT EXISTS version (
     id bigint NOT NULL PRIMARY KEY