Who Inspected This Pump?

The pump points to an inspection record. That inspection points to the technician who performed it. Botie must keep those connections together: a technician attached to another pump’s inspection is not an answer.

A pattern describes the connected shape we want to find. Its variables remember which node filled each position, so the next relationship continues from the same inspection rather than starting an unrelated search.

A second pump’s technician must not enter the first pump’s result.

Bind a to the Asset whose stable ID is P7. The start is part of the question, not a detail to discard once expansion begins. A useful index can help locate it, but the query must still state the identity condition.

Our workshop binding keeps origin as P7 while current moves to the endpoint reached by each relationship. The path list is evidence of how that row was obtained.

A starting ID and a type condition prevent unrelated records from becoming candidates.

The first expansion binds i to an inspection connected to a. The second expansion uses that same i to find t. Several inspections can produce several valid binding rows.

If we instead collect every inspection and every technician independently, a cross-product can pair unrelated records. Reusing a variable expresses a shared entity, just as matching a key constrains a relational join.

Keep the connecting inspection ID visible while learning the pattern.

g = {"nodes": [{"id": "P7", "kind": "Asset"}, {"id": "P8", "kind": "Asset"}, {"id": "I1", "kind": "Inspection", "status": "closed"}, {"id": "I2", "kind": "Inspection", "status": "open"}, {"id": "T1", "kind": "Technician"}, {"id": "T2", "kind": "Technician"}], "edges": [{"id": "h1", "source": "P7", "target": "I1", "type": "HAS_INSPECTION"}, {"id": "h2", "source": "P8", "target": "I2", "type": "HAS_INSPECTION"}, {"id": "t1", "source": "I1", "target": "T1", "type": "CARRIED_OUT_BY"}, {"id": "t2", "source": "I2", "target": "T2", "type": "CARRIED_OUT_BY"}]}
print([e['target'] for e in g['edges'] if e['source']=='P7' and e['type']=='HAS_INSPECTION'])

['I1']

MATCH describes the required graph shape. Variables a, i and t name the bound nodes; relationship types describe which links may connect them. RETURN DISTINCT t.id changes the output from one row per matching route to one row per technician.

DISTINCT is appropriate because the question asks which technicians, rather than how many inspections they performed. For an audit of individual visits, retain the inspection identity instead.

Projection and duplicate policy determine the report’s grain.

MATCH (a:Asset {id:$asset})-[:HAS_INSPECTION]->(i:Inspection)
      -[:CARRIED_OUT_BY]->(t:Technician)
RETURN DISTINCT t.id AS technician
ORDER BY technician

User-controlled asset IDs belong in driver parameters such as $asset. Do not paste them into a Cypher string. Keep query structure under application control and use reviewed templates for supported questions.

Dynamic labels, property keys and relationship-type syntax depend on the database version. If an application lets a user choose a structural option, validate it against a deliberate allowlist or use the documented supported parameter mechanism. String escaping is not a general substitute for that boundary.

Parameter binding preserves query structure; it does not authorise the requested asset.

A tenant restriction on the returned technician is insufficient if the match traverses another tenant’s inspection to get there. Restrict the starting node and every relevant intermediate entity and relationship according to the application’s permissions.

Use least-privilege database roles and an application authorisation layer. Hop limits and result limits control work; they do not grant permission to read a node.

The Python exercise uses a fully permitted fixture so the matching mechanism remains clear. The retrieval lesson adds an explicit scope before traversal.

A two-hop pattern and a variable-length traversal have different scopes. Cypher has documented rules for reusing relationships in a match, and newer versions provide additional match modes. Do not assume an arbitrary Python loop exactly implements every Cypher mode.

Our workshop refuses to reuse a relationship already present in a binding’s route. It demonstrates this fixed connected pattern, with complete edge identities visible for inspection.

The lesson’s mechanism is a small specified subset, not a browser implementation of the query language.