List of all notification codes

If a part of a query contains multiple disconnected patterns, this will build a cartesian product between all those parts. This may produce a large amount of data and slow down query processing. While occasionally intended, it may often be possible to reformulate the query that avoids the use of this cross product, perhaps by adding a relationship between the different parts or by using OPTIONAL MATCH (identifier is: (p))

In case a cartesian product is needed, nothing can be done to improve this query. In many cases, however, you might not need a combination of all children and parents, and that is when this query could be improved. If for example, you need the children and the children’s parents, you can improve this query by rewriting it to the following:

MATCH (c:Child)-[:ChildOf]->(p:Parent) RETURN c, p

Using shortest path with an unbounded pattern will likely result in long execution times. It is recommended to use an upper limit to the number of node hops in your pattern.

If you have a big graph, this query might be very slow. Consider adding an upper limit.

MATCH p=shortestPath((n)-[*..8]->(m)) RETURN p

Using shortest path with an exhaustive search fallback might cause query slow down since shortest path graph algorithms might not work for this use case. It is recommended to introduce a WITH to separate the MATCH containing the shortest path from the existential predicates on that path.

Separate the predicate by introducing a WITH after the MATCH clause.

MATCH p = shortestPath(()-[*..42]-())
WITH p
WHERE ANY(n in nodes(p) WHERE n:Label)
RETURN p

Using LOAD CSV followed by a MATCH or MERGE that matches a non-indexed label will most likely not perform well on large data sets. Please consider using a schema index.

Create an index on the label and property you match.

CREATE INDEX FOR (n:Person) ON (n.name)

Using LOAD CSV with a large data set in a query where the execution plan contains the Eager operator could potentially consume a lot of memory and is likely to not perform well. See the Neo4j Manual entry on the Eager operator for more information and hints on how problems could be avoided.

See the Cypher Manual → Eager operator for more information and hints on how to avoid problems. In this specific case, the query could be rewritten to the following:

LOAD CSV FROM 'file:///ignore/ignore.csv' AS line
CALL {
    WITH line
    MATCH (n:Person{name:line[0]}) DELETE n
}
RETURN line

Did not supply query with enough parameters. The produced query plan will not be cached and is not executable without EXPLAIN. (Missing parameters: prop)

If there is an index for (n:Person) ON (n.name), it will not be used for the above query because the query is using a dynamic property. Therefore, if there is an index, it is better to use the constant value. For example, if prop is equal to name, the following query would be able to use the index:

MATCH (n:Person) WHERE n.name IS NOT NULL RETURN n;

Did not supply query with enough parameters. The produced query plan will not be cached and is not executable without EXPLAIN. (Missing parameters: prop)

Similar to dynamic node properties, use a constant value if possible, especially when there is an index on the relationship property. For example, if $prop is equal to since, you can rewrite the query to:

MATCH ()-[r: KNOWS]->() WHERE r.since IS NOT NULL RETURN r

The hinted join was not planned. This could happen because no generated plan contained the join key, please try using a different join key or restructure your query. (hinted join key identifier is: a)

The join hint cannot be fulfilled because the given JOIN variable was introduced before the optional match and is therefore already bound. The only option for this query is to remove the hint or change the query so it is possible to use the hint.

The hinted index does not exist, please check the schema (index is: INDEX FOR (a:`Label`) ON (a.id))

The hinted index does not exist, make sure the label and property are spelled correctly. If the spelling is correct, either create the index or remove the hint from the query.

The hinted index does not exist, please check the schema (index is: INDEX FOR ()-[r:`Rel`]-() ON (r.id))

The hinted index does not exist, make sure the label and property are spelled correctly. If the spelling is correct, either create the index or remove the hint from the query.

The home database provided does not currently exist in the DBMS. This command will not take effect until this database is created. (HOME DATABASE: nonexistingdatabase)

Make sure the home database has not been misspelled.

One of the labels in your query is not available in the database, make sure you didn’t misspell it or that the label is available when you run this statement in your application (the missing label name is: Perso)

Make sure you didn’t misspell the label. If nodes with the given label will be created in the future, then no change is needed.

One of the relationship types in your query is not available in the database, make sure you didn’t misspell it or that the label is available when you run this statement in your application (the missing relationship type is: NonExistingType)

Make sure you did not misspell the relationship type. If relationships will be created, with the given relationship type, in the future, then no change to the query is needed.

One of the property names in your query is not available in the database, make sure you didn’t misspell it or that the label is available when you run this statement in your application (the missing property name is: nonExistingProp)

Make sure you didn’t misspell the property key. If the property key will be created in the future, then no change is needed to the query.

Selected runtime is unsupported for this query, please use a different runtime instead or fallback to default. (Pipelined does not yet support the plans including ShowIndexes, use another runtime.)

Use a different runtime or remove the runtime option to run the query with the default runtime:

SHOW INDEXES YIELD *

You are using an experimental feature (The parallel runtime is experimental and might suffer from instability and potentially correctness issues.)

The parallel runtime should not be used in production. Choose another runtime or remove the option to use the default runtime:

MATCH (n) RETURN (n)

The semantics of using colon in the separation of alternative relationship types will change in a future version. (Please use ':A|B|C' instead)

Remove the colon inside the relationship type expression.

MATCH (a)-[:A|B|C]-() RETURN *

The use of nodes or relationships for setting properties is deprecated and will be removed in a future version. Please use properties() instead.

Use the properties() function to get all properties from b.

MATCH (a)-[]-(b)
SET a = properties(b)

The use of nodes or relationships for setting properties is deprecated and will be removed in a future version. Please use properties() instead.

Use the properties() function to get all properties from r

MATCH (a)-[r]-(b)
SET a += properties(r)

The use of shortestPath and allShortestPaths with fixed length relationships is deprecated and will be removed in a future version. Please use a path with a length of 1 [r*1..1] instead or a Match with a limit.

If the relationship length is fixed, there is no reason to search for the shortest path. Instead, you can rewrite it to the following:

MATCH (a: Start)-[r]->(b: End) RETURN b LIMIT 1

Databases and aliases with unescaped . are deprecated unless to indicate that they belong to a composite database. Names containing . should be escaped. (Name: foo.bar)

If not intended for a composite database, escape the name with the character `.

CREATE DATABASE `foo.bar`

The query used a deprecated procedure: 'unsupported.dbms.shutdown'.

Remove the use of the deprecated procedure. If there is a suggested replacement, update to use the replacement instead.

The query used a deprecated runtime option. ('runtime=interpreted' is deprecated, please use 'runtime=slotted' instead)

Runtime interpreted is deprecated, use another runtime or remove the runtime option to use the default runtime.

MATCH (n) RETURN n

The text-1.0 provider for text indexes is deprecated and will be removed in a future version. Please use text-2.0 instead.

Update the option indexProvider with the value text-2.0.

CREATE TEXT INDEX FOR (n:Label) ON (n.prop) OPTIONS {indexProvider : 'text-2.0'}

All subqueries in a UNION [ALL] should have the same ordering for the return columns. Using differently ordered return items in a UNION [ALL] clause is deprecated and will be removed in a future version.

Use the same order for the return columns in all subqueries combined by a UNION clause.

RETURN 'val' as one, 'val' as two
UNION
RETURN 'val' as one, 'val' as two

The query used a deprecated function: id.

Use the function elementId() instead.

MATCH (a)
RETURN elementId(a)

The Cypher query option connectComponentsPlanner is deprecated and will be removed without a replacement. The product’s default behavior of using a cost-based IDP search algorithm when combining sub-plans will be kept. For more information, see Cypher manual → Cypher planner.

Variable in subquery is shadowing a variable with the same name from the outer scope. If you want to use that variable instead, it must be imported into the subquery using importing WITH clause. (the shadowing variable is: n)

If the intended behavior of the query is for the variable in the subquery to be a new variable, then nothing needs to be done. If the intended behavior is to use the variable from the outer query, it needs to be imported to the subquery using the with clause.

MATCH (n)
CALL {
  WITH n
  MATCH (n)--(m)
  RETURN m
}
RETURN *

Did not supply query with enough parameters. The produced query plan will not be cached and is not executable without EXPLAIN. (Missing parameters: param)

Provide the parameter to be able to cache the plan.

Relationship type expression cannot possibly be satisfied. (R1&R2 can never be fulfilled by any relationship. Relationships must have exactly one type.)

A relationship is referenced more than once in the query, which leads to no results because relationships must not occur more than once in each result. (Relationship r was repeated)

Use one pattern to match all relationships that start with a node with the label A and end with a node with the label B:

MATCH (:A)-[r]->(:B) RETURN r

A variable-length relationship variable is bound more than once, which leads to no results because relationships must not occur more than once in each result. (Relationship r was repeated)