Function _query

src/commands/cmd_query.c:463–551

}

void _query
(
	bool profile,
	void *args
) {
	CommandCtx     *command_ctx = (CommandCtx *)args;
	QueryCtx       *query_ctx   = QueryCtx_GetQueryCtx();
	RedisModuleCtx *ctx         = CommandCtx_GetRedisCtx(command_ctx);
	GraphContext   *gc          = CommandCtx_GetGraphContext(command_ctx);
	ExecutionCtx   *exec_ctx    = NULL;

	Globals_TrackCommandCtx(command_ctx);
	QueryCtx_SetGlobalExecutionCtx(command_ctx);

	// transition the query from waiting to executing
	QueryCtx_AdvanceStage(query_ctx);

	// parse query parameters and build an execution plan
	// or retrieve it from the cache
	exec_ctx = ExecutionCtx_FromQuery(command_ctx->query);
	if(exec_ctx == NULL) goto cleanup;

	// update cached flag
	QueryCtx_SetUtilizedCache(query_ctx, exec_ctx->cached);

	ExecutionType exec_type = exec_ctx->exec_type;
	bool readonly = AST_ReadOnly(exec_ctx->ast->root);
	bool index_op = (exec_type == EXECUTION_TYPE_INDEX_CREATE ||
	     exec_type == EXECUTION_TYPE_INDEX_DROP);

	if(profile && index_op) {
		RedisModule_ReplyWithError(ctx, "Can't profile index operations.");
		goto cleanup;
	}

	// write query executing via GRAPH.RO_QUERY isn't allowed
	if(!profile && !readonly && _readonly_cmd_mode(command_ctx)) {
		ErrorCtx_SetError("graph.RO_QUERY is to be executed only on read-only queries");
		goto cleanup;
	}

	CronTaskHandle timeout_task = 0;

	// enforce specified timeout when query is readonly
	// or timeout applies to both read and write
	bool enforce_timeout = command_ctx->timeout != 0 && !index_op &&
		(readonly || command_ctx->timeout_rw) &&
		!command_ctx->replicated_command;
	if(enforce_timeout) {
		timeout_task = Query_SetTimeOut(command_ctx->timeout, exec_ctx->plan);
	}

	// populate the container struct for invoking _ExecuteQuery.
	QueryExecutionTypeFlag flags = QueryExecutionTypeFlag_READ;
	if (!readonly) {
		flags |= QueryExecutionTypeFlag_WRITE;
	}
	if (profile) {