Call subquery validate return

src/ast/ast.c

@@ -580,6 +580,34 @@ bool AST_ClauseContainsAggregation
 	return aggregated;
 }
 
+const char *AST_GetProjectionAlias
+(
+	const cypher_astnode_t* projection
+) {
+	ASSERT(cypher_astnode_type(projection) == CYPHER_AST_PROJECTION);
+
+	const char *alias = NULL;
+	const cypher_astnode_t *ast_alias =
+		cypher_ast_projection_get_alias(projection);
+
+	if(ast_alias != NULL) {
+		alias = cypher_ast_identifier_get_name(ast_alias);
+	} else {
+		// if the projection was not aliased:
+		// a) if it is an identifier, the alias will be its name
+		// b) if it is not an identifier, the alias will be NULL
+		// the second case occurs when unaliased literals are returned by a
+		// call subquery: CALL {RETURN 1}
+		const cypher_astnode_t *exp =
+			cypher_ast_projection_get_expression(projection);
+		cypher_astnode_type_t type = cypher_astnode_type(exp);
+		if(type == CYPHER_AST_IDENTIFIER) {
+			alias = cypher_ast_identifier_get_name(exp);
+		}
+	}
+	return alias;
+}
+
 const char **AST_BuildReturnColumnNames
 (
 	const cypher_astnode_t *return_clause
@@ -591,12 +619,14 @@ const char **AST_BuildReturnColumnNames
 	uint projection_count = cypher_ast_return_nprojections(return_clause);
 	const char **columns = array_new(const char *, projection_count);
 	for(uint i = 0; i < projection_count; i++) {
-		const cypher_astnode_t *projection = cypher_ast_return_get_projection(return_clause, i);
-		const cypher_astnode_t *ast_alias = cypher_ast_projection_get_alias(projection);
-		// If the projection was not aliased, the projection itself is an identifier.
-		if(ast_alias == NULL) ast_alias = cypher_ast_projection_get_expression(projection);
-		const char *alias = cypher_ast_identifier_get_name(ast_alias);
-		array_append(columns, alias);
+		const cypher_astnode_t *projection =
+			cypher_ast_return_get_projection(return_clause, i);
+		const cypher_astnode_t *ast_alias =
+			cypher_ast_projection_get_alias(projection);
+		const char *alias = AST_GetProjectionAlias(projection);
+		if(alias != NULL) {
+			array_append(columns, alias);
+		}
 	}
 
 	return columns;

src/ast/ast.h

@@ -212,6 +212,14 @@ bool AST_ClauseContainsAggregation
 	const cypher_astnode_t *clause
 );
 
+// returns the alias of the projection
+// the alias will be NULL in the case of unaliased non-identifiers expressions
+// returned by call subquery
+const char *AST_GetProjectionAlias
+(
+	const cypher_astnode_t* projection
+);
+
 // collect the aliases from a RETURN clause to populate ResultSet column names
 const char **AST_BuildReturnColumnNames
 (

src/ast/ast_validations.c

@@ -1015,14 +1015,9 @@ static AST_Validation _ValidateUnion_Clauses
 		const char *projections[proj_count];
 
 		for(uint j = 0; j < proj_count; j++) {
-			const cypher_astnode_t *proj = cypher_ast_return_get_projection(return_clause, j);
-			const cypher_astnode_t *alias_node = cypher_ast_projection_get_alias(proj);
-			if(alias_node == NULL)  {
-				// The projection was not aliased, so the projection itself must be an identifier.
-				alias_node = cypher_ast_projection_get_expression(proj);
-				ASSERT(cypher_astnode_type(alias_node) == CYPHER_AST_IDENTIFIER);
-			}
-			const char *alias = cypher_ast_identifier_get_name(alias_node);
+			const cypher_astnode_t *proj =
+				cypher_ast_return_get_projection(return_clause, j);
+			const char *alias = AST_GetProjectionAlias(proj);
 			projections[j] = alias;
 		}
 
@@ -1035,15 +1030,11 @@ static AST_Validation _ValidateUnion_Clauses
 			}
 
 			for(uint j = 0; j < proj_count; j++) {
-				const cypher_astnode_t *proj = cypher_ast_return_get_projection(return_clause, j);
-				const cypher_astnode_t *alias_node = cypher_ast_projection_get_alias(proj);
-				if(alias_node == NULL)  {
-					// The projection was not aliased, so the projection itself must be an identifier.
-					alias_node = cypher_ast_projection_get_expression(proj);
-					ASSERT(cypher_astnode_type(alias_node) == CYPHER_AST_IDENTIFIER);
-				}
-				const char *alias = cypher_ast_identifier_get_name(alias_node);
-				if(strcmp(projections[j], alias) != 0) {
+				const cypher_astnode_t *proj =
+					cypher_ast_return_get_projection(return_clause, j);
+				const char *alias = AST_GetProjectionAlias(proj);
+				if(alias == NULL || projections[j] == NULL ||
+					strcmp(projections[j], alias) != 0) {
 					ErrorCtx_SetError("All sub queries in a UNION must have the same column names.");
 					res = AST_INVALID;
 					goto cleanup;
@@ -1349,21 +1340,22 @@ references to outside variables");
 		for(uint i = 0; i < n_projections; i++) {
 			const cypher_astnode_t *proj =
 				cypher_ast_return_get_projection(return_clause, i);
-			const char *var_name;
-			const cypher_astnode_t *identifier =
+			const cypher_astnode_t *alias_node =
 				cypher_ast_projection_get_alias(proj);
 			const cypher_astnode_t *exp =
 					cypher_ast_projection_get_expression(proj);
-			if(identifier) {
-				var_name = cypher_ast_identifier_get_name(identifier);
+			const char *var_name = AST_GetProjectionAlias(proj);
+
+			if(var_name == NULL) {
+				ErrorCtx_SetError("Return projection in CALL {} must be aliased");
+				return VISITOR_BREAK;
+			} else {
 				if(exp &&
 				   cypher_astnode_type(exp) == CYPHER_AST_IDENTIFIER &&
 				   cypher_ast_identifier_get_name(exp)[0] == '@') {
 					// this is an artificial projection, skip it
 					continue;
 				}
-			} else {
-				var_name = cypher_ast_identifier_get_name(exp);
 			}
 
 			if(!raxTryInsert(vctx->defined_identifiers,
@@ -1747,13 +1739,12 @@ static VISITOR_STRATEGY _Validate_RETURN_Clause
 
 	// introduce bound vars
 	for(uint i = 0; i < num_return_projections; i ++) {
-		const cypher_astnode_t *child = cypher_ast_return_get_projection(n, i);
-		const cypher_astnode_t *alias_node = cypher_ast_projection_get_alias(child);
-		if(alias_node == NULL) {
-			continue;
+		const cypher_astnode_t *proj = cypher_ast_return_get_projection(n, i);
+		const char *alias = AST_GetProjectionAlias(proj);
+		if(alias != NULL) {
+			raxInsert(vctx->defined_identifiers, (unsigned char *)alias,
+				strlen(alias), NULL, NULL);
 		}
-		const char *alias = cypher_ast_identifier_get_name(alias_node);
-		raxInsert(vctx->defined_identifiers, (unsigned char *)alias, strlen(alias), NULL, NULL);
 	}
 
 	// visit ORDER BY clause

tests/flow/test_call_subquery.py

@@ -41,30 +41,87 @@ def expect_error(self, query, expected_err_msg):
     def test01_test_validations(self):
         """Make sure we fail on invalid queries"""
 
-        import_error = "WITH imports in CALL {} must consist of only simple references to outside variables"
-        match_after_updating = "A WITH clause is required to introduce MATCH after an updating clause"
-        union_column_name_error = "All sub queries in a UNION must have the same column names."
-        queries_errors = [
-            ("WITH 1 AS a CALL {WITH a+1 AS b RETURN b} RETURN b", import_error),
-            ("WITH {a: 1} AS map CALL {WITH map.a AS b RETURN b} RETURN b", import_error),
-            ("WITH [1, 2, 3] AS list CALL {WITH list[0] AS b RETURN b} RETURN b", import_error),
-            ("WITH 'RAZ' AS str CALL {WITH toUpper(str) AS b RETURN b} RETURN b", import_error),
-            ("WITH 1 AS a CALL {WITH a AS b RETURN b} RETURN b", import_error),
-            ("WITH 1 AS a CALL {WITH a LIMIT 5 RETURN a} RETURN a", import_error),
-            ("WITH 1 AS a CALL {WITH a ORDER BY a.v RETURN a} RETURN a", import_error),
-            ("WITH 1 AS a CALL {WITH a WHERE a > 5 RETURN a} RETURN a", import_error),
-            ("WITH 1 AS a CALL {WITH a SKIP 5 RETURN a} RETURN a", import_error),
-            ("WITH true AS a CALL {WITH NOT(a) AS b RETURN b} RETURN b", import_error),
-            ("CALL {CREATE (n:N) MATCH (n:N) RETURN n} RETURN 1", match_after_updating),
-            ("WITH 1 AS a CALL {WITH a CREATE (n:N) MATCH (n:N) RETURN n} RETURN a", match_after_updating),
-            ("CALL {MATCH (n:N) CREATE (n:N2)} RETURN 1 ", "The bound variable 'n' can't be redeclared in a CREATE clause"),
-            ("MATCH (n) CALL {WITH n AS n1 RETURN n1 UNION WITH n RETURN n1} RETURN n, n1", import_error),
-            ("MATCH (n) CALL {WITH n RETURN n AS n1 UNION WITH n AS n1 RETURN n1} RETURN n, n1", import_error),
-            ("CALL {RETURN 1 AS one UNION RETURN 2 AS two} RETURN 1", union_column_name_error),
-            ("MATCH (n) CALL {RETURN 1 AS one UNION RETURN 2 AS two} RETURN 1", union_column_name_error)
+        # invalid queries: imports that are not simple imports
+        queries = [
+            "WITH 1 AS a CALL {WITH a + 1 AS b RETURN b} RETURN b",
+            "WITH {a: 1} AS map CALL {WITH map.a AS b RETURN b} RETURN b",
+            "WITH [1, 2, 3] AS list CALL {WITH list[0] AS b RETURN b} RETURN b",
+            "WITH 'RAZ' AS str CALL {WITH toUpper(str) AS b RETURN b} RETURN b",
+            "WITH 1 AS a CALL {WITH a AS b RETURN b} RETURN b",
+            "WITH 1 AS a CALL {WITH a LIMIT 5 RETURN a} RETURN a",
+            "WITH 1 AS a CALL {WITH a ORDER BY a.v RETURN a} RETURN a",
+            "WITH 1 AS a CALL {WITH a WHERE a > 5 RETURN a} RETURN a",
+            "WITH 1 AS a CALL {WITH a SKIP 5 RETURN a} RETURN a",
+            "WITH true AS a CALL {WITH NOT(a) AS b RETURN b} RETURN b",
+            "MATCH (n) CALL {WITH n AS n1 RETURN n1 UNION WITH n RETURN n1} RETURN n, n1",
+            "MATCH (n) CALL {WITH n RETURN n AS n1 UNION WITH n AS n1 RETURN n1} RETURN n, n1",
+        ]
+        expected_error = "WITH imports in CALL {} must consist of only simple references to outside variables"
+        for query in queries:
+            self.expect_error(query, expected_error)
+
+        # invalid queries: MATCH without preceding WITH
+        queries = [
+            "CALL {CREATE (n:N) MATCH (n:N) RETURN n} RETURN 1",
+            "WITH 1 AS a CALL {WITH a CREATE (n:N) MATCH (n:N) RETURN n} RETURN a",
+        ]
+        expected_error = "A WITH clause is required to introduce MATCH after an updating clause"
+        for query in queries:
+            self.expect_error(query, expected_error)
+
+        # invalid queries: redeclaring variable in CREATE
+        queries = [
+            "CALL {MATCH (n:N) CREATE (n:N2)} RETURN 1 ",
+        ]
+        expected_error = "The bound variable 'n' can't be redeclared in a CREATE clause"
+        for query in queries:
+            self.expect_error(query, expected_error)
+
+        # invalid queries: UNION column names
+        queries = [
+            # different column names
+            """
+            CALL {
+                RETURN 1 AS one
+                UNION
+                RETURN 2 AS two
+            }
+            RETURN 1
+            """,
+            """
+            MATCH (n)
+            CALL {
+                RETURN 1 AS one
+                UNION
+                RETURN n
+            } RETURN 1
+            """,
+            # missing column names
+            """
+            CALL {
+                RETURN 1
+                UNION
+                RETURN 2 AS two
+            } RETURN 1
+            """,
         ]
-        for query, err in queries_errors:
-            self.expect_error(query, err)
+        expected_error = "All sub queries in a UNION must have the same column names"
+        for query in queries:
+            self.expect_error(query, expected_error)
+
+        # invalid queries: returning literals inside CALL{} must be aliased
+        queries = [
+            "CALL {RETURN 1} RETURN 0",
+            "CALL {RETURN 'a'} RETURN 0",
+            "CALL {RETURN 5.7} RETURN 0",
+            "CALL {RETURN 1+2} RETURN 0",
+            "CALL {RETURN true} RETURN 0",
+            "CALL {RETURN sum(0)} RETURN 0",
+            "CALL {MATCH (n) RETURN n.x} RETURN 0",
+            "CALL {MATCH p=(n) RETURN nodes(p)[0]} RETURN 0",
+        ]
+        for query in queries:
+            self.expect_error(query, "must be aliased")
 
         # invalid queries: import an undefined identifier
         queries = [