Intermediate Neo4j & Graph Databases test (Intermediate)

Sample questions

5 sample questions from the Intermediate Neo4j & Graph Databases test, with the answers. Samples are taken out of the live test, so you will not meet these when you sit it.

1. What is the correct statement regarding the performance impact of an index on node properties in Neo4j?

   1. Index on node properties speeds up finding starting points (lookups by label + property), but does not speed up traversals.
   2. Index on node properties has no impact on query performance.
   3. Index on node properties speeds up both finding starting points and traversals.
   4. Index on node properties does not speed up finding starting points, but it improves traversals.

   Answer: A. Index on node properties speeds up finding starting points (lookups by label + property), but does not speed up traversals.

   Neo4j indexes are designed to optimize lookups by label and property, which are used as starting points for queries. However, they do not improve the performance of traversals, which are handled by the index-free adjacency model. This distinction is important because indexes are not a substitute for proper graph modeling and relationship management.

2. You are modeling a graph where each 'Employee' can work on multiple 'Projects', and each 'Project' can have multiple 'Employees' working on it. Which of the following is the best way to represent this relationship in the graph?

   1. Create multiple relationships between 'Employee' and 'Project' with the same type.
   2. Store the project IDs as a list property on the 'Employee' node.
   3. Use an intermediate node to represent the 'works on' relationship and link it to the 'Project' node.
   4. Create a single relationship between 'Employee' and 'Project' with a 'works on' type.

   Answer: C. Use an intermediate node to represent the 'works on' relationship and link it to the 'Project' node.

   When a relationship has high cardinality and needs to be traversed efficiently, using an intermediate node helps avoid supernodes and improves query performance. In this scenario, creating an intermediate node (e.g., 'Assignment') that connects the 'Employee' node to the 'Project' node ensures that the relationship is properly modeled and avoids potential performance issues.

3. Which of the following statements accurately describes the behavior of relationship types in Neo4j?

   1. Relationship types are undirected when stored, but queries can enforce direction with -[]-.
   2. Relationship types are directed when stored, but queries can enforce direction with -[]-.
   3. Relationship types are directed when stored, but queries can ignore direction with -[]-.
   4. Relationship types are undirected when stored, but queries can ignore direction with -[]-.

   Answer: C. Relationship types are directed when stored, but queries can ignore direction with -[]-.

   In Neo4j, relationships are stored as directed pointers, meaning they have a specific direction (from one node to another). However, when querying, the direction can be ignored using the `-[]-` syntax. This allows for more flexible querying without needing to explicitly model both directions of a relationship. Other options are incorrect because they either misrepresent the behavior of relationship types or describe unrelated concepts.

4. What is the most likely issue with a query that filters based on a relationship property without using an index on that property?

   1. The query uses a constraint on the relationship property, so it is efficient.
   2. The query does not use a constraint on the relationship property, leading to inefficient traversal.
   3. The query does not use an index on the relationship property, leading to inefficient traversal.
   4. The query uses an index on the relationship property, so it is efficient.

   Answer: C. The query does not use an index on the relationship property, leading to inefficient traversal.

   Neo4j indexes are used to speed up lookups by label and property, but they are not applied to relationship properties by default. If a query filters or traverses based on a relationship property without an index, it can lead to inefficient performance. Creating an index on the relationship property would improve query performance in this case.

5. You are modeling a scenario where a customer places an order for multiple products. Which of the following approaches best handles the cardinality of the relationship between the 'Customer' and 'Product' nodes?

   1. Create a direct relationship between 'Customer' and 'Product' with a type like 'RELATED_TO'.
   2. Create a direct relationship between 'Customer' and 'Product' with a type like 'PURCHASED'.
   3. Use an intermediate node to represent the 'Order' and connect it to both 'Customer' and 'Product' nodes.
   4. Store the list of product IDs as a property on the 'Customer' node.

   Answer: C. Use an intermediate node to represent the 'Order' and connect it to both 'Customer' and 'Product' nodes.

   When a customer places an order for multiple products, using an intermediate node (like 'Order') allows for a many-to-many relationship between 'Customer' and 'Product' through the 'Order' node. This avoids creating a supernode with excessive relationships and ensures proper cardinality modeling.