HelixDB Docs

Guide

Every traversal starts from a source. Choose the narrowest source that matches the data you already know.

Source choices

Intent	Builder
One or more node IDs	`n(NodeRef…)`
Nodes with a label	`nWithLabel` / `n_with_label`
Nodes matching a source predicate	`nWhere` / `n_where`
One or more edge IDs	`e(EdgeRef…)`
Edges with a label	`eWithLabel` / `e_with_label`
Earlier named entry	`NodeRef.var(...)` / `NodeVar(...)`

Source predicates are eligible for index push-down. General .where(...) filters the current stream after its source.

Read active users

read_batch()
    .var_as(
        "users",
        g()
            .n_with_label("User")
            .where_(Predicate::eq("status", "active"))
            .limit(25)
            .value_map(Some(vec!["$id", "name"])),
    )
    .returning(["users"]);

readBatch()
  .varAs(
    "users",
    g()
      .nWithLabel("User")
      .where(Predicate.eq("status", "active"))
      .limit(25)
      .valueMap(["$id", "name"]),
  )
  .returning(["users"]);

helix.ReadQuery("active_users").
	VarAs(
		"users",
		helix.G().
			NWithLabel("User").
			Where(helix.PredEq("status", "active")).
			Limit(25).
			ValueMap("$id", "name"),
	).
	Returning("users")

(
    read_batch()
    .var_as(
        "users",
        g()
        .n_with_label("User")
        .where(Predicate.eq("status", "active"))
        .limit(25)
        .value_map(["$id", "name"]),
    )
    .returning(["users"])
)

{
  "request_type": "read",
  "query_name": "active_users",
  "query": {
    "read": {
      "entries": [{
        "query": {
          "name": "users",
          "root": {
            "value_map": {
              "input": {
                "limit": {
                  "input": {
                    "where": {
                      "input": {
                        "nodes_where": {
                          "predicate": {
                            "eq": {
                              "left": { "property": "$label" },
                              "right": { "constant": { "string": "User" } }
                            }
                          }
                        }
                      },
                      "predicate": {
                        "eq": {
                          "left": { "property": "status" },
                          "right": { "constant": { "string": "active" } }
                        }
                      }
                    }
                  },
                  "count": { "literal": 25 }
                }
              },
              "properties": ["$id", "name"]
            }
          }
        }
      }],
      "returns": ["users"]
    }
  }
}

Read by indexed property

Use a source predicate when the property has a compatible index:

g().n_where(SourcePredicate::eq("email", "alice@example.com"))

g().nWhere(SourcePredicate.eq("email", "alice@example.com"))

helix.G().NWhere(helix.SourceEq("email", "alice@example.com"))

g().n_where(SourcePredicate.eq("email", "alice@example.com"))

{
  "request_type": "read",
  "query_name": "user_by_email",
  "query": {
    "read": {
      "entries": [{
        "query": {
          "name": "user",
          "root": {
            "nodes_where": {
              "predicate": {
                "eq": {
                  "left": { "property": "email" },
                  "right": {
                    "constant": { "string": "alice@example.com" }
                  }
                }
              }
            }
          }
        }
      }],
      "returns": ["user"]
    }
  }
}

Read an earlier result

Use NodeRef.var("user") (or the equivalent SDK reference) as the source of a later entry. Named references are transaction-local; they do not create stored variables or routes.

Next steps

Traverse relationships

Follow outgoing and incoming edges.

Filter and order

Narrow and page the current stream.

⌘I