openCypher Query Reference

Overview#

Atlas executes a read subset of openCypher against the compiled World - the in-memory graph built by PUT /api/v1/branches/{branch}/domains/{domain}/world. The engine is purpose-built for that graph, so its supported set is defined here rather than by any other Cypher implementation.

This article is the complete language reference: every clause, operator, literal form, built-in function and pattern feature. If you want to know where to run a query and which patterns solve common modelling questions, read Querying with Cypher instead. This one answers "is X supported, what is its arity, and what does it return".

Two things to know before reading further:

1. Atlas Cypher is a read language. CREATE, MERGE, DELETE, SET and REMOVE return an error at parse time.
2. A few constructs parse and are not applied, so the query returns rows that are wider than you intended. Those are listed first.

Conventions that shape your results#

Each item below parses cleanly and returns HTTP 200. Read this section before you write a query.

Finding nodes with no outgoing relationship#

Return the full OPTIONAL MATCH result and select the empty rows in your consumer:

MATCH (n:Pump)
OPTIONAL MATCH (n)-[:contains]->(child)
RETURN n.Label AS Pump, child.Label AS Child

A WHERE following an OPTIONAL MATCH is folded inside the optional, so a WHERE r IS NULL test inside the query is not a supported form and returns HTTP 500.

The query endpoint#

POST /api/v1/branches/{branch}/domains/{domain}/queries

Atlas serves its single-page application for any URL outside the API surface, so a mistyped route returns 200 with an HTML body rather than a 404. If a response body starts with <!doctype html>, check the route and the access token before you check the query.

Request body#

{
  "cypher": "MATCH (n:Pump) WHERE n.FlowRate.Value > $minFlow RETURN n.Label, n.FlowRate.Value",
  "parameters": { "minFlow": 100.0 }
}

Sending {"query": …} returns 400 invalid-request with detail Cypher query string is required.

Response#

Default shape:

{
  "columns": ["n.Label", "n.FlowRate.Value"],
  "data": [["North CT-01", 142.5], ["North CT-02", 138.0]]
}

columns are derived from the RETURN item text when no AS alias is given: a variable yields its name, a property access yields var.Prop, a function call yields fn(arg) with DISTINCT prefixed inside the parens when present, and count(*) yields count(*).

With "projections": true:

{
  "columns": ["n"],
  "data": [[ … ]],
  "classesTouched": ["urn:atlas:ontology:lonestar-plant:Plant"],
  "instanceIdsByClass": {
    "urn:atlas:ontology:lonestar-plant:Plant": ["Lonestar-Plant"]
  }
}

• classesTouched is an array of full type URNs.
• instanceIdsByClass maps type URN to durable instance id strings, not integers. The field name is retained for wire compatibility.
• Enrichment applies to entity-valued columns only. A scalar projection such as RETURN n.Label returns classesTouched: [] and instanceIdsByClass: {}.

Authentication#

/api/v1 requires a Pulse bearer whose aud includes Atlas. An unauthenticated call does not return a clean 401 - it returns 302 to the Pulse OIDC endpoint and ultimately an HTML sign-in page. A client that follows redirects receives HTML where it expected JSON.

The /app twin#

POST /app/branches/{branch}/domains/{domain}/queries exists with an identical body shape with an identical body shape. It is the cookie-authenticated route the Atlas interface uses for its own queries, is not published in the OpenAPI documents, and is not an integration surface. It is listed here so it can be identified in a browser network trace.

Lexical structure#

Supported clauses#

Expressions outside the supported set#

Each of these returns the message shown.

Patterns#

Node patterns#

MATCH (n)                    -- every node
MATCH (n:Pump)               -- nodes whose archetype is Pump or a subclass of Pump
MATCH (:Pump)                -- anonymous, still filtered
MATCH (n:Machine:Active)     -- both labels must hold; same as (n:Machine) WHERE n:Active
MATCH (n:Pump {Label: 'P-001'})  -- same as (n:Pump) WHERE n.Label = 'P-001'
MATCH (n:Pump WHERE n.Speed.Value > 1500)  -- any predicate, inside the brackets

• Label matching is OWL-inheritance aware. MATCH (n:Equipment) also returns Pumps and Tanks when they are declared subclasses.
• A label that resolves to no archetype is refused: HTTP 400, Query.SemanticError, Unknown label 'Pumps': no class in the compiled model matches it by URI or local name. A type that exists but has no instances is still a known label and returns an empty result. Earlier 2.0 builds returned an empty result, 200, for an unknown label; if you see that, you are on one of them.
• Every label on a node pattern filters, and all of them must hold. Property short names on that variable resolve against the first label's type hierarchy.
• An inline property map is an equality on each key, combined with the WHERE that follows the MATCH; {Label: 'X', Area: $a} means n.Label = 'X' AND n.Area = $a. Anything other than equality goes in WHERE. A bound property is a compound, so a map compares the whole three-part value; a dotted key names a part, {Speed.Value: 42}, the same as WHERE n.Speed.Value = 42. A whole map passed as a parameter, (n $props), and a map on a variable-length relationship are refused with Query.Unsupported. Earlier 2.0 builds dropped inline maps and returned the unfiltered rows; if a map has no effect, you are on one of them.

Label names in MATCH are either the short local name (the segment after the final colon of the type URN) or the full URN in backticks: MATCH (n:`urn:atlas:ontology:plant:Pump`). labels() and keys() return full URNs, so either strip the prefix before feeding one back into a pattern or backtick the whole value.

Relationship patterns#

MATCH (a)-[:contains]->(b)      -- outgoing
MATCH (a)<-[:feeds]-(b)         -- incoming
MATCH (a)-[:connectsTo]-(b)     -- either direction
MATCH (a)--(b)                  -- any type, either direction
MATCH (a)-[r]->(b)              -- bind the edge to r
MATCH (a)-[:A|:B]->(b)          -- type A or type B
MATCH (a)-[:A|B]->(b)           -- the second colon is optional
MATCH (a)-[r:feeds {Medium: 'steam'}]->(b)        -- equality on an edge property
MATCH (a)-[r:feeds WHERE r.Diameter > 50]->(b)    -- any predicate, inside the brackets

Direction is derived from the presence of < and >. Each relationship type token expands to its inheritance subtree. A token is the short local name or the full URN in backticks ([:`urn:atlas:ontology:atlas-common:contains`]). A token that matches no relationship type is refused: HTTP 400, Query.SemanticError, Unknown relationship type 'feeds': no relationship type in the compiled model matches it by URI, local name or inverse name.

A type written on any node of a pattern filters that node, and the match is inheritance aware, exactly as it is on the start node. MATCH (line:Line)-[:contains]->(p:Pump) returns only the pumps of each line, and MATCH (line:Line)-[:contains]->(p) WHERE p:Pump is an equivalent form. Earlier 2.0 builds applied only the type on the start node; if a type on the far end of an arrow is ignored, you are on one of them.

Variable-length paths#

Those are the five forms the parser accepts. Execution is a bounded depth-first search with trail semantics: the same relationship is never traversed twice within one path.

100 hops is the engine ceiling, and an open-ended form now walks all of it rather than stopping at a lower hidden default. Expansion visits each edge at most once per source row, so depth costs you traversal work rather than compounding it.

A bound above the ceiling is refused at analysis time with a 400, rather than being quietly reduced to something you did not ask for:

Variable-length upper bound 250 exceeds the engine maximum of 100 hops.
Variable-length lower bound 250 exceeds the engine maximum of 100 hops - no path can satisfy it.

State the depth you need in the pattern anyway. A query that says what it means is cheaper to read than one relying on the ceiling, and it does not change behaviour if the ceiling ever moves.

A relationship variable on a variable-length pattern is a list of the edges on the path, in traversal order, as in Cypher. Read a property per edge with a list comprehension, or constrain the hops with a list predicate:

MATCH (a:Plant)-[r:contains*1..3]->(b)
WHERE all(x IN r WHERE x.Active.Value = true)
RETURN b.Label, [x IN r | x.Diameter] AS Diameters, size(r) AS Hops

r.Diameter on such a variable is refused at analysis time, because a list has no properties; the message names the two forms above. A property map or a bracket WHERE on a variable-length relationship is refused for the same reason: write the predicate over the list. Earlier 2.0 builds bound the variable to the last edge only; if r.Diameter returns a value on a variable-length pattern, you are on one of them.

Relationship properties#

A relationship variable's properties are read the same way a node's are, and they work in WHERE, ORDER BY and aggregation:

MATCH (a:Pump)-[r:feedsInto]->(b:Tank)
WHERE r.Diameter > 50
RETURN b.Label, r.Diameter
ORDER BY r.Diameter DESC

The predicate can also sit inside the brackets, next to the edge it filters: MATCH (a:Pump)-[r:feedsInto WHERE r.Diameter > 50]->(b:Tank) is the same query. A node pattern takes a bracket WHERE too, (p:Pump WHERE p.Speed.Value > 1500). In both places it is combined with the clause's own WHERE, and under OPTIONAL MATCH a row whose match fails the predicate is still emitted with nulls.

Property names on a relationship resolve against that relationship type's own properties. Where a node type and a relationship type both carry a short name, each resolves within its own scope, and an ambiguous name is reported as a diagnostic rather than silently returning null.

Named paths#

MATCH p = (a:Plant)-[:contains*1..3]->(b)
RETURN length(p), nodes(p), relationships(p)

length, nodes and relationships return null when their argument is not a path.

Shortest paths#

MATCH p = shortestPath((a:Pump)-[*]->(b:Tank))
MATCH p = allShortestPaths((a:Pump)-[*]-(b:Tank))

Three constraints, all enforced by the analyzer. The first two carry these verbatim messages:

• shortestPath/allShortestPaths requires exactly one relationship pattern: (node)-[*]->(node)
• shortestPath/allShortestPaths requires a variable-length relationship [*]

The third is a minimum hop count above 1, which is rejected rather than applied. shortestPath((a)-[:NEXT*3..]->(b)) does not mean "the shortest path of at least three hops"; there is no such search, so asking for one is refused instead of quietly returning the plain one-hop answer. Only 0 and 1 are accepted as a minimum, and both mean the same thing here.

A floor in an ordinary variable-length match is unaffected: MATCH (a)-[:NEXT*3..]->(b) still honours it. The restriction is specific to shortest-path search.

shortestPath enforces the types on both endpoints, like every other pattern, whether or not an earlier clause bound the endpoint. allShortestPaths returns every joint-shortest route.

Operators#

Comparison#

(ComparisonHelper).

Boolean#

AND, OR, NOT. XOR parses and is rejected. There is no IS TRUE / IS FALSE.

Arithmetic#

(ArithmeticHelper). The integer-division rule is the most common source of a report that reads 0 on every row. Multiply by 100.0 before dividing.

Predicates#

String predicates: (StringHelper). Label predicate: FunctionHelper.HasLabels,. Kind predicates:, CompileIsKind.

CASE#

Both forms are supported, with or without ELSE. A generic CASE treats a non-boolean, non-null WHEN result as true; a missing ELSE yields null.

-- generic
CASE WHEN n.Speed.Value > 100 THEN 'high' WHEN n.Speed.Value > 50 THEN 'medium' ELSE 'low' END

-- simple
CASE n.Status WHEN 'Running' THEN 1 ELSE 0 END

CASE is the replacement for the non-existent coalesce() CASE WHEN x IS NULL THEN $default ELSE x END.

List comprehension#

[x IN range(1, 10) WHERE x % 2 = 0 | x * x]
[n IN nodes(p) | n.Label]
[r IN relationships(p) | type(r)]
[n IN nodes(p) | CASE WHEN n.Label STARTS WITH 'P-' THEN 'pump' ELSE 'other' END]

[x IN list], [x IN list WHERE p], [x IN list | expr] and the full form are all valid. The iteration variable can appear anywhere in the predicate or the projection: a property read, a function argument, a CASE, a nested comprehension. A non-enumerable list expression yields null. Pattern comprehension (a pattern instead of a variable) is rejected.

List predicates#

all(x IN list WHERE predicate)      -- every element satisfies it; true for an empty list
any(x IN list WHERE predicate)      -- at least one does; false for an empty list
none(x IN list WHERE predicate)     -- no element does; true for an empty list
single(x IN list WHERE predicate)   -- exactly one does

The WHERE is required. They work over any list: a literal, nodes(p), relationships(p), a variable-length relationship variable, or UNWIND output, in WHERE as well as RETURN. A null or non-list value yields null, which a WHERE treats as false. A predicate that evaluates to null counts as false for its element.

MATCH p = (a:Plant)-[:contains*1..3]->(b)
WHERE all(x IN relationships(p) WHERE x.Active.Value = true)
RETURN b.Label

Parameters#

Reference with $. Two spellings are accepted:

WHERE n.Area = $area      -- named
WHERE n.Area = $0         -- positional/numeric name

The numeric form is a name, not an index: the request body must contain a key literally called "0".

Accepted value types: string, number, boolean, list, object, null. JSON is unwrapped once, before planning, by NormalizeParameters: integral JSON numbers prefer long over double, arrays become List<object?>, objects become Dictionary<string, object?>, Null and Undefined both collapse to null. datetime(null) returns default(DateTime), which is 0001-01-01, not null - an inconsistency with the other temporal coercions.

Parameters are recommended for two reasons:

• Injection safety. Values never enter the query text.
• Plan-cache reuse. The plan cache is keyed by raw Cypher text, so a parameterised query is parsed and analysed once and then reused; string-interpolated queries miss the cache on every distinct value. The cache lives on the CypherEngine instance, which is discarded and rebuilt when the domain is recompiled.

There is no cost-based planner. Parameters do not let the planner "optimise independently of values" - in fact the opposite is true for pushdown, which runs per execution precisely so that parameter values can be folded into literal predicate operands.

Projection: RETURN, WITH, ORDER BY, SKIP, LIMIT#

projectionBody : DISTINCT? projectionItems orderSt? skipSt? limitSt?

ORDER BY, SKIP and LIMIT are part of the projection body, so they attach to a RETURN or a WITH, in that order, and cannot appear on their own.

RETURN n.Label                            -- single property
RETURN n.Label AS Pump, n.Speed.Value     -- alias
RETURN DISTINCT n.Area
RETURN n                                  -- the whole entity, see below
RETURN *                                  -- all in-scope variables

WITH is the pipeline stage. Use it to filter on an aggregate, since WHERE cannot be applied to count() directly:

MATCH (p:Pump)<-[:contains]-(line)
WITH line, count(p) AS Pumps
WHERE Pumps > 5
RETURN line.Label AS Line, Pumps
ORDER BY Pumps DESC
LIMIT 10

A WITH without aggregation preserves EntityRef / ArchetypeRef in the row so later clauses can still resolve properties through the strategy dispatch path. Only a terminal RETURN converts an entity reference into the dictionary shape below.

The shape of RETURN n#

An entity-valued column is projected into a dictionary:

A bound property's value is a three-part compound:

"PlantBoilerEfficiency": { "Timestamp": "2026-08-07T19:35:45.513939Z", "Value": 0.8905615918065714, "Quality": 192 }

Quality does bind today. Seven connectors emit an IntColumn("Quality"), and 192 is Good. Note the URI is atlas-common:Quality, and its datatype is now xsd:integer.

A type-valued column (from IS TYPE schema mode) projects as {typeId, label} (EnrichArchetypeRef,).

Virtual properties#

Resolved by GetVirtualProperty when the name matches no registered component.

Any other unmatched name returns null.

UNION#

MATCH (n:Pump)  RETURN n.Label AS Asset
UNION
MATCH (n:Tank)  RETURN n.Label AS Asset

Branches are planned independently and then stacked:

• All branches must return the same column count, or the query returns All UNION branches must return the same number of columns. Got: 2, 3
• Column names come from the first branch.
• ORDER BY, SKIP and LIMIT written after the last branch belong to that branch. Sort and page a combined result in the consumer.
• A historical range inside a branch (an UNWIND of a bound property with a WITH … WHERE time window, see Historical range queries) is pushed to the source per branch, exactly as it is outside a UNION. Earlier 2.0 builds skipped that pushdown inside a UNION and returned the source's default window or nothing; if a UNION of history returns far fewer rows than its branches do on their own, you are on one of them.

Aggregation#

Six aggregates are implemented.

avg and round are both available: avg(1.0) returns 1 and round(1.5) returns 2.

Grouping is implicit: every non-aggregated item in the same RETURN or WITH becomes a grouping key.

ORDER BY after an aggregating RETURN is resolved against the aggregated output column names, so sort by the alias (ORDER BY PumpCount DESC), not by a source expression.

The supported aggregates are the six above. stDev, stDevP, percentileDisc and percentileCont return Function 'stDev' is not supported.

CALL { } sub-queries#

MATCH (l:Line)
CALL {
  WITH l
  MATCH (l)-[:contains]->(p)
  WHERE p:Pump
  RETURN count(p) AS Pumps
}
RETURN l.Label AS Line, Pumps

Three constraints apply.

1. The block must end with a RETURN whose items are all named - either an explicit AS alias or a bare variable reference. Otherwise: CALL { ... } sub-query RETURN items must have explicit aliases (use 'RETURN expr AS name').
2. The export set must be non-empty: CALL { ... } sub-query must end with a RETURN projection whose items export back to the outer scope.
3. A leading WITH composed entirely of bare variables is the import specifier. Write it that way - a WITH carrying aliased or computed items imports nothing, and the sub-query then runs against an empty scope. An import naming a variable that does not exist returns CALL { ... } imports undefined variable 'l'.

UNION inside the block is rejected: CALL { ... } sub-queries must not contain UNION.

Built-in functions#

Function names are matched case-insensitively. Anything not in these tables returns Function '<name>' is not supported (400 Query.Unsupported).

Forty-nine names are dispatched, of which four are aliases (toInt, toBool, ceiling, toDateTime), giving 45 distinct scalar functions. Add the six aggregates above and the valueAt special form for 56 callable names in total.

Identity and entity#

FunctionHelper.

Type conversion#

Temporal#

This family is how you write a time window without hardcoding raw tick integers.

The relative() offset language

RelativeTimeParser. The offset is a string matched against:

^(?<clamp>[yMwdhm])?(?:(?<sign>[+\-])?(?<count>\d+)(?<unit>[yMdhms]))?$

At least one of the clamp or the count group must be present. now is a case-insensitive alias for "no-op" and returns the anchor unchanged.

A malformed offset returns null through the TryApply path. The throwing overload used by compile-time folding raises FormatException with the verbatim text:

Invalid relative-time expression: '<offset>'.

String#

Math#

There is no sqrt, log, exp, pow, or trigonometry, and ^ is rejected.

List#

There is no reduce, extract, filter, nodes-style list slicing, or index access. x[0] parses and is dropped.

Path#

Valid only on a named-path variable.

A bare nodes(p) returns internal references. Project the field you want: [n IN nodes(p) | n.Label].

Atlas extensions#

IS TYPE and schema mode#

IS TYPE is the only entry point into the type layer of the graph. It is both a runtime predicate and a planner directive.

MATCH (t:Equipment)-[:contains]->(child)
WHERE t IS TYPE
RETURN t.typeId, t.label, child.typeId

When a labelled node pattern's variable appears in a top-level IS TYPE predicate in the immediately following WHERE, the planner substitutes SchemaScanOperator for LabelScanOperator and SchemaExpandOperator for the instance expanders. The row then holds an ArchetypeRef instead of an EntityRef, which is why t.label and t.typeId work and t.entityId does not.

The trigger is narrow (IsTypeScan / ExpressionContainsIsType,): the predicate must be a direct IS TYPE on that variable, reachable through AND conjunctions only. Putting it behind an OR compiles to a plain runtime type test against an instance scan, which is always false.

IS INSTANCE is the runtime test for the default case and switches nothing. IS ANY compiles to the constant true.

valueAt(entity.property, timestamp)#

valueAt() is not a point-in-time lookup and it never calls a connector.

MATCH (v:Vessel)
RETURN v.Label, valueAt(v.Temperature, $ts).Value AS Temp

What it actually does: resolves the property's compound binding and materialises the compound from the current value populated by the subscription orchestrator. The timestamp argument is coerced to ticks and used only as part of the per-query cache key and to select the active strategy edge. The returned value is the current value regardless of the timestamp you pass.

There is no GetValue on the store contract. IExternalDataStore exposes only GetRangeAsync and GetRowsetAsync, and the interface doc states it outright: "Range/rowset only. Point-in-time scalar bound values come from the current value populated by the subscription orchestrator; no wire pull path remains.". The engine's own integration test is named ValueAt_Basic_PointInTime_ReturnsCurrentSoaCompoundValue and its comment reads "historical lookups are out of scope".

For genuine history, use UNWIND over the compound. That is the only path that reaches a connector.

Argument rules, enforced at parse time and analysis time:

Note the DISTINCT rule precisely: valueAt(DISTINCT …) is rejected. RETURN DISTINCT valueAt(…) is a ReturnClause DISTINCT and is unaffected.

The timestamp argument accepts long ticks, DateTime, DateTimeOffset or an ISO-8601 string; it is coerced by XsdCoercion.TicksFrom and a null or unparseable value makes the whole call return null.

Per-query coalescing still holds. Repeated valueAt calls with the same (entityId, componentId, timestamp) are served from one cache entry, so selecting .Value and .Timestamp from the same call costs one resolution.

Sub-field access uses the compound's declared field names. For the shipped atlas-common:TVQ type those are .Timestamp, .Value and .Quality. Accessing a field the compound does not declare raises Compound type '<uri>' has no field named '<name>'.

Historical range queries#

Every temporal bound is expressed in Cypher. The request body carries only cypher, parameters and projections - there are no time-range fields on the API itself.

The UNWIND range shape#

UNWIND over a bound or calculated compound property dispatches a range call to the registered store and applies whatever the store could not satisfy locally.

MATCH (a:Agitator)
UNWIND a.Vibration AS v
WITH a, v
WHERE v.Timestamp >= datetime('2026-08-01T00:00:00Z')
  AND v.Timestamp <  relative('d')
RETURN a.Label AS Asset, v.Timestamp AS Time, v.Value AS Vibration
ORDER BY Time
LIMIT 10000

Two syntactic rules apply:

• UNWIND takes no WHERE of its own, so stage the window through a WITH as above.
• The window must therefore be a WITH … WHERE, which is also where a LIMIT that you want pushed down should sit relative to the projection.

The time axis is not hardcoded to Timestamp#

The axis field name comes from whichever compound field declares atlas:isTimeAxis. Timestamp is that field for the shipped atlas-common:TVQ type. A custom compound with a differently-named time field uses its own name, and a compound that declares no axis is not time-segmentable, so the window cannot be pushed down to the source.

What a range result contains#

Range resolution splits the window at any configuration change and stitches the segments back together on the time axis. Two results follow from that:

• A window spanning a strategy changeover returns segments from each strategy, with a synthesised boundary sample stamped at the changeover instant.
• A leading bounding sample earlier than your from can appear, so a value is defined at the start of the window. Trim it in the consumer if your calculation needs an exact boundary.

The pushdown contract, for connector authors#

public sealed record PushdownRequest(
    PushdownPredicate? Predicate,
    IReadOnlyList<PushdownSortKey> SortKeys,
    int? Limit,
    int? Skip);

public sealed record PushdownResidual(
    PushdownPredicate? Predicate,
    IReadOnlyList<PushdownSortKey> SortKeys,
    int? Limit,
    int? Skip);

• There is no TimeFrom, no TimeTo, no OrderByTime and no Predicates. The time window lives inside Predicate, as ComparePredicate nodes over the compound's time-axis FieldRefExpr.
• Ordering arrives as SortKeys, a list of PushdownSortKey(FieldRefExpr Field, SortDirection Direction), on any field, not only the timestamp.
• "I satisfied nothing" is PushdownResidual.From(request). "I satisfied everything" is PushdownResidual.Empty. Partial support is a residual with only the unsatisfied members set. PushdownResidual.All and PushdownResidual.Predicates do not exist.

The full connector-side contract is covered in Connector Range Queries. This section explains why a LIMIT sometimes reaches the source and sometimes does not.

Errors#

Every failure is RFC-9457 application/problem+json with a frozen type URI under https://atlas.timebase.io/errors/ and a traceId. There is no {"error": …} body anywhere.

An invalid-request failure additionally carries a stable code extension. Generic failures, including the 500, carry only type, title, status and detail. Branch on the type URI, then on code when it is present.

Two behaviours that are not errors:

• An unknown label in a WHERE predicate evaluates to false, 200. WHERE n:Pumps is a boolean test, so it filters every row out rather than failing. Only a label or relationship type written in a MATCH pattern is refused.
• Querying after a change without recompiling returns the previously compiled world, 200. Only the never-compiled case is Query.NotCompiled. Atlas also auto-recompiles every recorded (branch, domain) pair at startup, so a restart does not require a manual recompile.

Pins on a Defer property#

A property that is still open on the property itself (a union of types, or a data type with a union-typed field) can be pinned on each type that uses it. One property such as Running can then be a boolean on Pump and a double on Tank, and a compiled model keeps a typed column for each type.

A query that reads that property is refused when the types it can match disagree, because the value would have no single type:

MATCH (n) RETURN n.Running.Value

Property 'Running.Value' is pinned differently across the types this pattern matches: Pump pins boolean, Tank pins double. Add a label that selects one type.

This is Query.SemanticError, HTTP 400. It applies when the pattern is unlabelled, has several labels, or has a label whose subtypes pin the leaf differently. Add a label that selects one type and the same read works:

MATCH (n:Pump) RETURN n.Running.Value

A query on a single labelled type is unchanged, and so is a read of a property that every matched type pins the same way. A type that leaves the leaf open is not a competing type, though such a type cannot compile in the first place. To pin a leaf, see Pin a property's leaf on a type.