Optional match testing (#48)

Author: DvirDukhan

src/resultSet.js

@@ -10,7 +10,7 @@ const ResultSetColumnTypes = {
 	COLUMN_UNKNOWN: 0,
 	COLUMN_SCALAR: 1,
 	COLUMN_NODE: 2,
-	COLUMN_RELATION: 3
+	COLUMN_RELATION: 3,
 };
 
 const ResultSetValueTypes = {
@@ -23,29 +23,29 @@ const ResultSetValueTypes = {
 	VALUE_ARRAY: 6,
 	VALUE_EDGE: 7,
 	VALUE_NODE: 8,
-	VALUE_PATH: 9
+	VALUE_PATH: 9,
 };
 
 /**
  * Hold a query result
  */
 class ResultSet {
-    /**
-     * Builds an empty ResultSet object.
-     * @constructor
-     * @param {Graph} graph 
-     */
+	/**
+	 * Builds an empty ResultSet object.
+	 * @constructor
+	 * @param {Graph} graph
+	 */
 	constructor(graph) {
-		this._graph = graph;    //_graph is graph api
-		this._position = 0;     //allowing iterator like behevior
+		this._graph = graph; //_graph is graph api
+		this._position = 0; //allowing iterator like behevior
 		this._resultsCount = 0; //total number of records in this result set
-		this._header = [];      //reponse schema columns labels
-		this._results = [];     //result records
+		this._header = []; //reponse schema columns labels
+		this._results = []; //result records
 	}
 
 	/**
 	 * Parse raw response data to ResultSet object.
-     * @async
+	 * @async
 	 * @param {object[]} resp  - raw response representation - the raw representation of response is at most 3 lists of objects.
 	 *                    The last list is the statistics list.
 	 */
@@ -66,11 +66,11 @@ class ResultSet {
 		return this;
 	}
 
-    /**
-     * Parse a raw response body into header an records.
-     * @async
-     * @param {object[]} resp raw response
-     */
+	/**
+	 * Parse a raw response body into header an records.
+	 * @async
+	 * @param {object[]} resp raw response
+	 */
 	async parseResults(resp) {
 		this.parseHeader(resp[0]);
 		await this.parseRecords(resp);
@@ -95,7 +95,7 @@ class ResultSet {
 	/**
 	 * The raw representation of response is at most 3 lists of objects. rawResultSet[1] contains the data records.
 	 * Each entry in the record can be either a node, an edge or a scalar
-     * @async
+	 * @async
 	 * @param {object[]} rawResultSet raw result set representation
 	 */
 	async parseRecords(rawResultSet) {
@@ -127,12 +127,12 @@ class ResultSet {
 		}
 	}
 
-    /**
-     * Parse raw entity properties representation into a Map
-     * @async
-     * @param {object[]} props raw properties representation
-     * @returns {Map} Map with the parsed properties. 
-     */
+	/**
+	 * Parse raw entity properties representation into a Map
+	 * @async
+	 * @param {object[]} props raw properties representation
+	 * @returns {Map} Map with the parsed properties.
+	 */
 	async parseEntityProperties(props) {
 		// [[name, value, value type] X N]
 		let properties = {};
@@ -158,12 +158,12 @@ class ResultSet {
 		return properties;
 	}
 
-    /**
-     * Parse raw node representation into a Node object.
-     * @async
-     * @param {object[]} cell raw node representation.
-     * @returns {Node} Node object.
-     */
+	/**
+	 * Parse raw node representation into a Node object.
+	 * @async
+	 * @param {object[]} cell raw node representation.
+	 * @returns {Node} Node object.
+	 */
 	async parseNode(cell) {
 		// Node ID (integer),
 		// [label string offset (integer)],
@@ -188,12 +188,12 @@ class ResultSet {
 		return node;
 	}
 
-    /**
-     * Parse a raw edge representation into an Edge object.
-     * @async
-     * @param {object[]} cell raw edge representation
-     * @returns {Edge} Edge object.
-     */
+	/**
+	 * Parse a raw edge representation into an Edge object.
+	 * @async
+	 * @param {object[]} cell raw edge representation
+	 * @returns {Edge} Edge object.
+	 */
 	async parseEdge(cell) {
 		// Edge ID (integer),
 		// reltype string offset (integer),
@@ -223,37 +223,37 @@ class ResultSet {
 		return edge;
 	}
 
-    /**
-     * Parse and in-place replace raw array into an array of values or objects.
-     * @async
-     * @param {object[]} rawArray raw array representation
-     * @returns {object[]} Parsed array.
-     */
+	/**
+	 * Parse and in-place replace raw array into an array of values or objects.
+	 * @async
+	 * @param {object[]} rawArray raw array representation
+	 * @returns {object[]} Parsed array.
+	 */
 	async parseArray(rawArray) {
 		for (var i = 0; i < rawArray.length; i++) {
 			rawArray[i] = await this.parseScalar(rawArray[i]);
 		}
 		return rawArray;
 	}
 
-    /**
-     * Parse a raw path representation into Path object.
-     * @async
-     * @param {object[]} rawPath raw path representation
-     * @returns {Path} Path object.
-     */
+	/**
+	 * Parse a raw path representation into Path object.
+	 * @async
+	 * @param {object[]} rawPath raw path representation
+	 * @returns {Path} Path object.
+	 */
 	async parsePath(rawPath) {
 		let nodes = await this.parseScalar(rawPath[0]);
 		let edges = await this.parseScalar(rawPath[1]);
 		return new Path(nodes, edges);
 	}
 
-    /**
-     * Parse a raw value into its actual value.
-     * @async
-     * @param {object[]} cell raw value representation 
-     * @returns {object} Actual value - scalar, array, Node, Edge, Path
-     */
+	/**
+	 * Parse a raw value into its actual value.
+	 * @async
+	 * @param {object[]} cell raw value representation
+	 * @returns {object} Actual value - scalar, array, Node, Edge, Path
+	 */
 	async parseScalar(cell) {
 		let scalar_type = cell[0];
 		let value = cell[1];
@@ -298,40 +298,40 @@ class ResultSet {
 		return scalar;
 	}
 
-    /**
-     * @returns {string[] }ResultSet's header.
-     */
+	/**
+	 * @returns {string[] }ResultSet's header.
+	 */
 	getHeader() {
 		return this._typelessHeader;
 	}
 
-    /**
-     * @returns {boolean} If the ResultSet object can return additional records.
-     */
+	/**
+	 * @returns {boolean} If the ResultSet object can return additional records.
+	 */
 	hasNext() {
 		return this._position < this._resultsCount;
 	}
 
-    /**
-     * @returns {Record} The current record.
-     */
+	/**
+	 * @returns {Record} The current record.
+	 */
 	next() {
 		return this._results[this._position++];
 	}
 
-    /**
-     * @returns {Statistics} ResultsSet's statistics.
-     */
+	/**
+	 * @returns {Statistics} ResultsSet's statistics.
+	 */
 	getStatistics() {
 		return this._statistics;
-    }
-    
-    /**
-     * @returns {int} Result set size.
-     */
-    size() {
-        return this._resultsCount;
-    }
+	}
+
+	/**
+	 * @returns {int} Result set size.
+	 */
+	size() {
+		return this._resultsCount;
+	}
 }
 
 module.exports = ResultSet;

test/redisGraphAPITest.js

@@ -455,4 +455,57 @@ describe("RedisGraphAPI Test", () => {
 			);
 		}
 	});
+
+	it("testOptionalMatch", async () => {
+		await api.query("CREATE (:L {val:1})-[:E {val:2}]->(:L2 {val: 3})");
+		let resultSet = await api.query(
+			"OPTIONAL MATCH (a:NONEXISTENT)-[e]->(b) RETURN a.val, e.val, b.val"
+		);
+		assert.equal(resultSet.size(), 1);
+		assert.ok(resultSet.hasNext());
+		let record = resultSet.next();
+		assert.ok(!resultSet.hasNext());
+		assert.deepEqual(record.values(), [null, null, null]);
+
+		// Test a query that produces 2 records, with 2 null values in the second.
+		resultSet = await api.query(
+			"MATCH (a) OPTIONAL MATCH (a)-[e]->(b) RETURN a.val, e.val, b.val ORDER BY ID(a)"
+		);
+		assert.equal(resultSet.size(), 2);
+		record = resultSet.next();
+		assert.equal(record.size(), 3);
+		assert.equal(record.get(0), 1);
+		assert.equal(record.get(1), 2);
+		assert.equal(record.get(2), 3);
+		record = resultSet.next();
+		assert.equal(record.size(), 3);
+		assert.equal(record.get(0), 3);
+		assert.equal(record.get(1), null);
+		assert.equal(record.get(2), null);
+
+        // Test a query that produces 2 records, the first containing a path and the second containing a null value
+        let node0 = new Node("L", {val:1});
+		node0.setId(0);
+		let node1 = new Node("L2", {val:3});
+		node1.setId(1);
+		let edge01 = new Edge(0, "E", 1, {val:2});
+		edge01.setId(0);
+        let expectedPath = new PathBuilder()
+			.append(node0)
+			.append(edge01)
+			.append(node1)
+            .build();
+            
+		resultSet = await api.query(
+			"MATCH (a) OPTIONAL MATCH p = (a)-[e]->(b) RETURN p"
+        );
+        
+		assert.equal(resultSet.size(), 2);
+		record = resultSet.next();
+		assert.equal(record.size(), 1);
+		assert.deepEqual(record.get(0), expectedPath);
+		record = resultSet.next();
+		assert.equal(record.size(), 1);
+		assert.equal(record.get(0), null);
+	});
 });