Support (Geo) Point datatype (#112)

* Support (Geo) Point datatype

* address equals review

* remove hashCode

* address toString review

* assert CREATE response

* Revert "remove hashCode"

This reverts commit 629500d.

* reorder

* Use IllegalArgumentException

Author: sazzad16

src/main/java/com/redislabs/redisgraph/graph_entities/Point.java

@@ -0,0 +1,62 @@
+package com.redislabs.redisgraph.graph_entities;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * This class represents a (geographical) point in the graph.
+ */
+public final class Point {
+
+    private static final double EPSILON = 1e-5;
+
+    private final double latitude;
+    private final double longitude;
+
+    /**
+     * @param latitude
+     * @param longitude 
+     */
+    public Point(double latitude, double longitude) {
+        this.latitude = latitude;
+        this.longitude = longitude;
+    }
+
+    /**
+     * @param values {@code [latitude, longitude]}
+     */
+    public Point(List<Double> values) {
+        if (values == null || values.size() != 2) {
+            throw new IllegalArgumentException("Point requires two doubles.");
+        }
+        this.latitude = values.get(0);
+        this.longitude = values.get(1);
+    }
+
+    public double getLatitude() {
+        return latitude;
+    }
+
+    public double getLongitude() {
+        return longitude;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof Point)) return false;
+        Point o = (Point) other;
+        return Math.abs(latitude - o.latitude) < EPSILON &&
+                Math.abs(longitude - o.longitude) < EPSILON;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(latitude, longitude);
+    }
+
+    @Override
+    public String toString() {
+        return "Point{latitude=" + latitude + ", longitude=" + longitude + "}";
+    }
+}

src/main/java/com/redislabs/redisgraph/impl/resultset/ResultSetImpl.java

@@ -8,6 +8,7 @@
 import com.redislabs.redisgraph.exceptions.JRedisGraphException;
 import com.redislabs.redisgraph.graph_entities.*;
 import com.redislabs.redisgraph.impl.graph_cache.GraphCache;
+import redis.clients.jedis.BuilderFactory;
 import redis.clients.jedis.util.SafeEncoder;
 import redis.clients.jedis.exceptions.JedisDataException;
 
@@ -239,12 +240,18 @@ private Object deserializeScalar(List<Object> rawScalarData) {
                 return deserializePath(obj);
             case VALUE_MAP:
                 return deserializeMap(obj);
+            case VALUE_POINT:
+                return deserializePoint(obj);
             case VALUE_UNKNOWN:
             default:
                 return obj;
         }
     }
 
+    private Object deserializePoint(Object rawScalarData) {
+        return new Point(BuilderFactory.DOUBLE_LIST.build(rawScalarData));
+    }
+
     private Map<String, Object> deserializeMap(Object rawScalarData) {
         List<Object> keyTypeValueEntries = (List<Object>) rawScalarData;
         Map<String, Object> map = new HashMap<>();

src/main/java/com/redislabs/redisgraph/impl/resultset/ResultSetScalarTypes.java

@@ -13,7 +13,8 @@ enum ResultSetScalarTypes {
     VALUE_EDGE,
     VALUE_NODE,
     VALUE_PATH,
-    VALUE_MAP;
+    VALUE_MAP,
+    VALUE_POINT;
 
     private static final ResultSetScalarTypes[] values = values();
 

src/test/java/com/redislabs/redisgraph/RedisGraphAPITest.java

@@ -4,9 +4,9 @@
 import com.redislabs.redisgraph.graph_entities.Edge;
 import com.redislabs.redisgraph.graph_entities.Node;
 import com.redislabs.redisgraph.graph_entities.Path;
+import com.redislabs.redisgraph.graph_entities.Point;
 import com.redislabs.redisgraph.graph_entities.Property;
 import com.redislabs.redisgraph.impl.api.RedisGraph;
-import com.redislabs.redisgraph.impl.resultset.RecordImpl;
 import com.redislabs.redisgraph.impl.resultset.ResultSetImpl;
 import com.redislabs.redisgraph.test.utils.PathBuilder;
 
@@ -874,6 +874,45 @@ public void testMapDataType() {
         Assert.assertEquals(expected, actual);
     }
 
+    @Test
+    public void testGeoPointLatLon() {
+        ResultSet rs = api.query("social", "CREATE (:restaurant"
+                + " {location: point({latitude:30.27822306, longitude:-97.75134723})})");
+        Assert.assertEquals(1, rs.getStatistics().nodesCreated());
+        Assert.assertEquals(1, rs.getStatistics().propertiesSet());
+
+        assertTestGeoPoint();
+    }
+
+    @Test
+    public void testGeoPointLonLat() {
+        ResultSet rs = api.query("social", "CREATE (:restaurant"
+                + " {location: point({longitude:-97.75134723, latitude:30.27822306})})");
+        Assert.assertEquals(1, rs.getStatistics().nodesCreated());
+        Assert.assertEquals(1, rs.getStatistics().propertiesSet());
+
+        assertTestGeoPoint();
+    }
+
+    private void assertTestGeoPoint() {
+        ResultSet results = api.query("social", "MATCH (restaurant) RETURN restaurant");
+        Assert.assertEquals(1, results.size());
+        Record record = results.next();
+        Assert.assertEquals(1, record.size());
+        Assert.assertEquals(Collections.singletonList("restaurant"), record.keys());
+        Node node = record.getValue(0);
+        Property property = node.getProperty("location");
+        Assert.assertEquals(new Point(30.27822306, -97.75134723), property.getValue());
+    }
+
+    @Test
+    public void timeoutArgument() {
+        ResultSet rs = api.query("social", "UNWIND range(0,100) AS x WITH x AS x WHERE x = 100 RETURN x", 1L);
+        Assert.assertEquals(1, rs.size());
+        Record r = rs.next();
+        Assert.assertEquals(Long.valueOf(100), r.getValue(0));
+    }
+
     @Test
     public void testCachedExecutionReadOnly() {
         api.query("social", "CREATE (:N {val:1}), (:N {val:2})");
@@ -898,14 +937,6 @@ public void testCachedExecutionReadOnly() {
         Assert.assertTrue(resultSet.getStatistics().cachedExecution());
     }
 
-    @Test
-    public void timeoutArgument() {
-        ResultSet rs = api.query("social", "UNWIND range(0,100) AS x WITH x AS x WHERE x = 100 RETURN x", 1L);
-        Assert.assertEquals(1, rs.size());
-        Record r = rs.next();
-        Assert.assertEquals(Long.valueOf(100), r.getValue(0));
-    }
-
     @Test
     public void testSimpleReadOnly() {
         api.query("social","CREATE (:person{name:'filipe',age:30})");