Traversal Steps

Graph Traversal Fundamentals

Graph traversal is the process of visiting nodes and edges in a graph. Helix QL provides a rich set of operations to navigate your graph data efficiently.

Selection Operations

These operations serve as starting points for your graph traversals.

Node Selection (`N`)

Select nodes from your graph to begin traversal.

Syntax	Description
`N`	Select all nodes in the graph
`N<Type>`	Select all nodes of a specific type
`N<Type>("id")`	Select a node by its ID
`N<Type>("id1", "id2")`	Select nodes of a specific with given IDs and define its type for correctness

QUERY GetUsers(userID: String) {
    // Select all nodes
    nodes <- N
    
    // Select all User nodes
    users <- N<Users>
    
    // Select a specific User by ID
    user <- N<User>(userID)
    
    // Select multiple Users by IDs
    other_users <- N<Users>(userID, "other_uuid")
    
    RETURN nodes, users, user, other_users
}

Edge Selection (`E`)

Select edges from your graph to begin traversal.

Syntax	Description
`E`	Select all edges in the graph
`E<Type>`	Select all edges of a specific type
`E<Type>("id")`	Select an edge by its ID
`E<Type>("id1", "id2")`	Select edges of a specific type with given IDs

QUERY GetFollowers(edgeID: String) {
    // Select all edges
    edges <- E
    
    // Select all Follows edges
    specific_edges <- E<Follows>
    
    // Select a specific Follows edge by ID
    follow_edge <- E<Follows>(edgeID)
    
    // Select multiple Follows edges by IDs
    other_edges <- E<Follows>(edgeID, "other_edge_id")
    
    RETURN edges, specific_edges, follow_edge, other_edges
}

Anonymous Traveral (`_`)

Continue a traversal without breaking the overall traversal flow. Useful for an inner traversal where you don’t want it to affect the overall traversal.

Traversal Operations

Once you’ve selected your starting points, these operations allow you to navigate through the graph.

Move from nodes to their connected nodes.

Operation	Description
`::Out<EdgeType>`	Traverse to nodes connected by outgoing edges of specific type
`::In<EdgeType>`	Traverse to nodes connected by incoming edges of specific type
`::Both<EdgeType>`	Traverse to nodes connected by edges of specific type in either direction

QUERY GetFriendsAndFollowers(userID: String) {
    // Find user by ID
    user <- N<User>(userID)
    
    // Get users that this user follows (outgoing direction)
    following <- user::Out<Follows>
    
    // Get users that follow this user (incoming direction)
    followers <- user::In<Follows>
    
    // Get all connections in both directions
    connections <- user::Both<Follows>
    
    RETURN following, followers, connections
}

Move from nodes to their connected edges.

Operation	Description
`::OutE<EdgeType>`	Get outgoing edges of specific type
`::InE<EdgeType>`	Get incoming edges of specific type
`::BothE<EdgeType>`	Get edges of specific type in either direction

QUERY GetUserRelationships(userID: String) {
    // Find user by ID
    user <- N<User>(userID)
    
    // Get only outgoing "Follows" edges
    follows_edges <- user::OutE<Follows>
    
    // Get incoming "Follows" edges
    followed_by_edges <- user::InE<Follows>

    // Get all edges in both directions
    all_edges <- user::BothE<Follows>
    
    RETURN follows_edges, followed_by_edges, all_edges
}

Move from edges to their connected nodes.

Operation	Description
`::OutN`	Get source node (where edge starts)
`::InN`	Get target node (where edge ends)

QUERY GetFollowRelationshipDetails(relationshipID: String) {
    // Find a specific Follows relationship by ID
    relationship <- E<Follows>(relationshipID)
    
    // Get the user who initiated the follow (source)
    follower <- relationship::OutN
    
    // Get the user being followed (target)
    followed <- relationship::InN
    
    RETURN follower, followed, both_users
}

Combining Traversal Steps

Helix QL allows you to chain traversal operations to create complex graph queries.

QUERY GetFriendsOfFriends(userID: String) {
    // Find user by ID
    user <- N<User>(userID)
    
    // Get users that this user follows and then users they follow (friends of friends)
    friends_of_friends <- user::Out<Follows>::Out<Follows>
    
    RETURN friends_of_friends
}

Introduction

What is HelixDB?

Get Started

HelixQL

Graph Traversal Fundamentals

Selection Operations

Node Selection (`N`)

Edge Selection (`E`)

Anonymous Traveral (`_`)

Traversal Operations

Node-to-Node Navigation

Node-to-Edge Navigation

Edge-to-Node Navigation

Combining Traversal Steps

Introduction

What is HelixDB?

Get Started

HelixQL

​Graph Traversal Fundamentals

​Selection Operations

​Node Selection (N)

​Edge Selection (E)

​Anonymous Traveral (_)

​Traversal Operations

​Node-to-Node Navigation

​Node-to-Edge Navigation

​Edge-to-Node Navigation

​Combining Traversal Steps

Graph Traversal Fundamentals

Selection Operations

Node Selection (`N`)

Edge Selection (`E`)

Anonymous Traveral (`_`)

Traversal Operations

Node-to-Node Navigation

Node-to-Edge Navigation

Edge-to-Node Navigation

Combining Traversal Steps