Skip to main content
HelixQL queries end with a RETURN clause. You can return bindings (variables), projected properties, aggregations, literals, or choose to return nothing at all.

​
Quick reference

Return TypeSyntaxReturn TypeSyntax
Return a bindingRETURN usersExclude fieldsRETURN users::!{ email }
Return multipleRETURN user, postsAggregation/scalarRETURN count
Project fieldsRETURN users::{ name, age }  LiteralRETURN "ok"
Only IDsRETURN users::ID  No payloadRETURN NONE
When using the Python SDK, the output values are wrapped in an array for multiple query calls, so you will need to access the first element of the array to get the result of the first call.

​
Returning bindings

Return any previously bound value from your traversal. 
QUERY GetAllUsers() =>
    users <- N<User>
    RETURN users
Returning multiple values creates multiple top-level fields in the response, named after the variables. 
QUERY GetUserAndPosts(user_id: ID) =>
    user <- N<User>(user_id)
    posts <- user::Out<User_to_Post>
    RETURN user, posts

​
Returning projections and properties

Use property projection to shape the returned data. 
QUERY FindUsers() =>
    users <- N<User>::RANGE(0, 10)
    RETURN users::{ name, age }
Return just the ID of each element: 
QUERY FindUserIDs() =>
    users <- N<User>::RANGE(0, 10)
    RETURN users::ID
Exclude specific properties: 
QUERY FindUsersNoPII() =>
    users <- N<User>::RANGE(0, 10)
    RETURN users::!{ email, location }
You can also create nested or remapped shapes in RETURN using nested mappings: 
QUERY FindFriends(user_id: ID) =>
    user <- N<User>(user_id)
    posts <- user::Out<User_to_Post>::RANGE(20)
    RETURN user::|u|{
        userID: u::ID,
        posts: posts::{
            postID: ID,
            creatorID: u::ID,
            ..
        }
    }
See property access, remappings, and exclusion for more details.

​
Returning scalars and literals

Aggregations and scalar bindings can be returned directly: 
QUERY CountUsers() =>
    user_count <- N<User>::COUNT
    RETURN user_count
You can also return literals (strings, numbers, booleans) when useful: 
QUERY DeleteCity(city_id: ID) =>
    DROP N<City>(city_id)
    RETURN "success"

​
Returning nothing

For mutations or maintenance operations where you do not want a response payload, use RETURN NONE. 
QUERY DeleteCityQuietly(city_id: ID) =>
    DROP N<City>(city_id)
    RETURN NONE
RETURN NONE signals that the query intentionally produces no output values. This is handy to avoid sending placeholder strings like “success” when a silent acknowledgement is preferred.