What you'll learn

• APOC LibraryAn extension library providing hundreds of utility procedures and functions for Neo4j that handle tasks outside Cypher's core scope, such as advanced data import, string manipulation, and graph refactoring.
• Aggregation FunctionsCypher functions that compute a single summary value from a set of matched rows by collapsing many rows into one per group, producing counts, sums, averages, or collected lists.
• Bolt ProtocolThe binary, message-based network protocol that Neo4j uses for communication between clients and servers, featuring compact encoding, stateful sessions, and support for pipelining.
• CREATE ClauseCypher's primary mechanism for unconditionally inserting new nodes and relationships into the graph, executing fresh inserts each time it runs regardless of duplicates.
• ConstraintA schema rule that Neo4j automatically enforces to guarantee data integrity by rejecting write operations that would violate it.
• Cypher Query LanguageA declarative query language for Neo4j that uses ASCII-art syntax to express graph patterns and retrieve or modify data.
• DELETE and DETACH DELETECypher clauses that permanently remove nodes or relationships from the graph, with DELETE requiring isolated nodes and DETACH DELETE automatically removing connected relationships first.
• Directed vs Undirected RelationshipsEvery Neo4j relationship stores a permanent direction between a start and end node, but queries can ignore this direction at runtime to match relationships bidirectionally.
• Graph Algorithm ConceptsAnalytical techniques that operate on graph structure through the Graph Data Science library to extract insights using centrality, community detection, and pathfinding analysis.
• Graph Data ImportThe process of loading data into Neo4j from external sources using mechanisms like LOAD CSV, which reads files and uses MERGE or CREATE to build the graph.
• Graph Database ModelA storage system where data is organized as nodes and relationships, with meaning derived from both entity properties and the connections between them.
• Graph Schema DesignThe process of translating a real-world domain into nodes, relationships, and properties, driven by the specific queries the application needs to answer.
• IndexA data structure that maps property values to nodes, enabling fast lookups by jumping directly to matching nodes instead of scanning all nodes.
• MATCH ClauseThe primary Cypher command for reading data, which finds all subgraphs in the database that conform to a specified pattern of nodes and relationships.
• MERGE ClauseAn idempotent write operation that finds and returns an existing pattern if it exists, or creates it if it does not, with optional conditional actions for creation versus existing matches.
• Native Graph StorageA database storage design where nodes physically store pointers to adjacent relationships and relationships store pointers to their endpoint nodes, eliminating the need for index lookups or JOIN operations during traversal.
• Neo4j AuraA fully managed cloud database-as-a-service that runs Neo4j in the cloud and handles all infrastructure concerns including provisioning, patching, backups, scaling, and high availability.
• Neo4j BrowserA built-in web-based interface for writing and executing Cypher queries, exploring results as graph visualizations, and inspecting database metadata without installing external tools.
• Neo4j DesktopA local developer application that provides a graphical interface for creating, managing, and interacting with Neo4j database instances on your personal machine.
• Neo4j DriverAn official language-specific library that allows application code to connect to a Neo4j database, send Cypher queries, and process results over the Bolt protocol.
• NodeA fundamental unit of data in a Neo4j graph representing a discrete entity with an internal identity, optional labels, and key-value properties.
• Node LabelA named category tag attached to a node to indicate what kind of entity it represents, enabling efficient grouping and querying.
• Pattern MatchingThe core mechanism in Cypher that finds subgraphs by matching them against an ASCII-art-like structural template of nodes and relationships.
• PropertyA key-value pair stored directly on a node or relationship to describe attributes such as names, dates, or connection weights.
• Property Graph ModelThe foundational data structure of Neo4j that extends basic graphs by allowing both nodes and relationships to carry labels, properties, and types.
• RETURN ClauseThe output stage of a Cypher query that specifies what information is sent back, whether entire nodes, individual properties, computed expressions, or aggregated values.
• Relational vs Graph DatabaseRelational databases store relationships as foreign keys requiring JOIN operations at query time, while graph databases store relationships as first-class entities enabling efficient traversal of connected data.
• RelationshipA directed, named connection between exactly two nodes that includes a start node, end node, mandatory type, and optional properties.
• Relationship TypeA mandatory, immutable named label on every relationship that describes the semantic meaning of the connection between two nodes.
• SET ClauseA clause that modifies existing graph elements by adding or updating node and relationship properties, removing properties by setting them to null, or adding and removing labels on nodes.
• Shortest Path QueryA graph operation that finds the minimum-hop route between two nodes using Cypher's shortestPath() or allShortestPaths() functions, which perform unweighted breadth-first search.
• TransactionA logical bundle of one or more Cypher queries that either completes fully or rolls back entirely, ensuring ACID-compliant atomicity, consistency, isolation, and durability of database changes.
• UNWIND ClauseA Cypher clause that expands a list into individual rows so that per-element operations such as lookups, merges, or property updates can be applied to each item.
• Variable-Length PathA Cypher pattern that matches relationships repeated a specified number of times between two nodes, enabling queries like finding nodes reachable within a certain number of hops.
• WHERE ClauseA Cypher filter mechanism that narrows results from MATCH, OPTIONAL MATCH, or WITH clauses by imposing additional conditions on matched nodes and relationships.
• WITH ClauseA Cypher construct that chains query segments together by taking results from one stage, optionally filtering or transforming them, and passing them forward as input to the next stage.