Neo4j Certified Professional key terms

A data record in the graph that represents an entity such as a person, product, or account. Nodes can carry labels and any number of key-value properties, and they connect to other nodes through relationships.

A directed, typed connection between two nodes that stores its own properties. Every relationship has exactly one start node and one end node, a single type, and a direction that matters for traversal even when queries ignore it.

A name used to group nodes into categories, such as :Person or :Movie. A node may have zero, one, or many labels, and labels are the primary hook for anchoring index lookups and constraining patterns.

The single name that classifies a relationship, written in upper snake case by convention, such as ACTED_IN. A relationship has exactly one type, and type names are not shared with node labels.

A named value attached to a node or relationship. Properties hold primitives, strings, or homogeneous lists of those, and the special value null means the property is absent rather than stored as empty.

The data model in which entities are nodes, connections are directed typed relationships, and both can hold properties. It favors expressing connections directly instead of resolving them through foreign keys at query time.

Walking the graph by following relationships from node to node, typically in a single Cypher pattern. Cost depends on the number of relationships touched, so starting from a small, well-chosen anchor set matters greatly.

The storage design in which each node holds direct references to its relationships, so moving to a neighbor costs constant time regardless of total graph size. It is why deep traversals stay fast compared with relational joins.

Neo4j's design of storing nodes, relationships, and properties in fixed-size records with pointer-based links between them, rather than as rows in external tables. This layout keeps traversal local and predictable.

Neo4j's declarative query language for matching graph patterns, filtering, projecting, and writing data. Queries describe what to find using ASCII-art patterns, and the planner chooses how to execute them.

The Cypher clause that specifies a pattern to find in the graph. It binds variables to matching nodes and relationships, and it produces no rows when nothing matches unless made optional.

A Cypher clause that behaves like MATCH but preserves rows when no pattern is found, binding the missing variables to null. It is the graph equivalent of an outer join and is often paired with collect.

The clause that filters rows using predicates such as comparisons, string checks, list membership, and pattern existence. It can follow MATCH or WITH, and predicates attached to a pattern are evaluated during matching.

The clause that projects values out of a query as the result set, optionally with DISTINCT, aliases, aggregation, and ORDER BY. A read query normally ends with RETURN, while write queries may omit it.

A clause that pipes results from one query part into the next, acting like a mid-query RETURN. It is required to filter on aggregates, to limit rows before continuing, and to scope variables.

The ASCII-art expression of nodes and relationships in Cypher, such as (a:Person)-[:KNOWS]->(b). Patterns describe shape and can be used to match existing data or to create new data.

A relationship pattern with a range such as [:KNOWS*1..3] that matches paths of one to three hops. Unbounded forms risk huge expansions, so bounds and relationship types should be stated explicitly.

The Cypher clause that adds new nodes and relationships from the described pattern. It always creates, even if an identical pattern already exists, so MERGE is preferred when uniqueness is required.

A clause that matches a pattern if present and creates it otherwise, combining MATCH and CREATE semantics. It locks on the whole pattern, so unique constraints and careful property placement prevent duplicates under concurrency.

The clause that updates properties or adds labels on matched entities. Assigning null removes a property, and SET can copy values between entities or apply arithmetic to existing values.

DELETE removes matched nodes or relationships but fails on nodes that still have relationships. DETACH DELETE first removes those relationships, deleting the node and its edges in one step.

A function that collapses many rows into one value, such as count, sum, avg, min, max, or collect. Non-aggregated expressions in the same projection become implicit grouping keys.

An aggregation function that gathers values from many rows into a single list, skipping nulls. It is commonly used to return a node together with its neighbors in one row.

A clause that turns a list into one row per element, the inverse of collect. It is the standard way to batch-create data from a parameter list and to expand values produced earlier in a query.

The marker for a missing or unknown value. Comparisons and arithmetic involving null yield null, which WHERE treats as not true, so existence must be tested with IS NULL or IS NOT NULL.

A placeholder such as $name supplied separately from the query text at execution time. Parameters enable plan caching, prevent injection, and let one query run with many value sets.

A Cypher function that finds the shortest path between two nodes within a pattern, optionally weighted by a relationship property. It requires bound endpoints and a relationship type to search efficiently.

A subquery introduced with EXISTS { } that tests whether a pattern or query returns any row. It allows correlated checks inside WHERE without changing the cardinality of the outer query.

Query prefixes that reveal the execution plan. EXPLAIN plans without running the query, while PROFILE runs it and reports actual rows and database hits per operator, exposing cardinality mistakes.

The tree of operators the planner chooses to execute a Cypher statement, such as NodeIndexSeek or Expand. Reading plans shows where filtering happens and whether an index is being used.

An auxiliary structure that speeds lookups of nodes by label and property, or of relationships by type and property. Neo4j uses these indexes only when a query provides the matching label and property.

A schema rule that enforces data integrity, such as uniqueness of a property, existence of a property, or a key combining both. Uniqueness constraints also create a backing index used for lookups.

A schema rule requiring that every node with a given label has a non-null value for a named property. It guards required fields but does not by itself make values unique.

A Lucene-backed index supporting tokenized text search with operators such as fuzzy matching and phrase queries, queried through a procedure rather than normal pattern matching. It suits searching names and descriptions.

The client library that manages connections to a Neo4j cluster, pools them, and routes queries to the right member. Applications create one long-lived driver per database and reuse it.

A lightweight, short-lived context obtained from a driver in which transactions run. Sessions are cheap to create, are not thread-safe, and should be closed after their work is done.

A unit of work grouping one or more Cypher statements that commit or roll back together. Drivers offer managed functions that retry transient failures automatically, plus explicit begin, commit, and rollback control.

A token representing a point in the transaction log that a client has observed. Passing bookmarks between sessions provides causal consistency when reading from followers in a cluster.

A Cypher clause that reads a CSV file, either from a file URL or over HTTP, row by row into the query. It is the standard bulk-import tool for moderate files and supports custom field terminators and headers.

An APOC procedure that streams CSV rows as maps and lists, supporting headers, delimiters, and batching. It is often faster and more flexible than LOAD CSV for larger or messier files.

An offline bulk loader that builds a database from prepared CSV files before the database is first started. It is the fastest option for very large initial loads but cannot run against a live database.

Designing labels, relationship types, directions, and property placement to answer the intended queries efficiently. Good models favor explicit relationships over duplicated foreign keys and avoid modeling every noun as a node.

A node introduced to represent a relationship that carries data or connects more than two entities, such as a shipment between warehouse and store. It replaces an overloaded edge with a small entity.

A clause that applies update operations to each element of a list within a single query part. Unlike UNWIND it cannot produce rows, so it is used for side effects such as creating many relationships.