Function parse_query

src/ast/ast.c:711–779

}

cypher_parse_result_t *parse_query
(
	const char *query  // query to parse
) {
	FILE *f = fmemopen((char *)query, strlen(query), "r");
	cypher_parse_result_t *result = cypher_fparse(f, NULL, NULL, CYPHER_PARSE_SINGLE);
	fclose(f);

	if(!result) {
		return NULL;
	}

	// check that the parser parsed the entire query
	if(!cypher_parse_result_eof(result)) {
		ErrorCtx_SetError("Error: query with more than one statement is not supported.");
		parse_result_free(result);
		return NULL;
	}

	// in case ast contains any errors, report them and return
	if(AST_ContainsErrors(result)) {
		AST_ReportErrors(result);
		parse_result_free(result);
		return NULL;
	}

	// get the index of a valid root (of type CYPHER_AST_STATEMENT)
	int index;
	if(AST_Validate_ParseResultRoot(result, &index) == AST_INVALID) {
		parse_result_free(result);
		return NULL;
	}

	const cypher_astnode_t *root = cypher_parse_result_get_root(result, index);

	// validate the query
	if(AST_Validate_Query(root) != AST_VALID) {
		parse_result_free(result);
		return NULL;
	}

	// compress clauses
	// e.g. MATCH (a:N) MATCH (b:N) RETURN a,b
	// will be rewritten as:
	// MATCH (a:N), (b:N) RETURN a,b
	bool rerun_validation = AST_RewriteSameClauses(root);

	// rewrite eager & resulting Call {} clauses
	// e.g. MATCH (m) CALL { CREATE (n:N) RETURN n } RETURN n, m
	// will be rewritten as:
	// MATCH (m) CALL { WITH m AS @m CREATE (n:N) RETURN n, @m AS m } RETURN n, m
	// note: we rewrite the ast for sure here, so we need to re-validate it
	rerun_validation |= AST_RewriteCallSubquery(root);

	// rewrite '*' projections
	// e.g. MATCH (a), (b) RETURN *
	// will be rewritten as:
	//  MATCH (a), (b) RETURN a, b