Nodes, Relationships, and Properties

Welcome to Cypher Fundamentals! To query a graph database like Neo4j, you first need to understand its core components.

Think of graphs as powerful ways to model real-world connections. They are built from three main elements:

• Nodes: Your entities or 'things'
• Relationships: How those 'things' are connected
• Properties: Descriptors for nodes and relationships

Nodes are the fundamental entities in your graph. They represent real-world objects, people, places, or concepts.

For example, in a social network, 'Alice' or 'New York' would be nodes. In an e-commerce graph, 'Product A' or 'Customer B' would be nodes.

Nodes can have labels to categorize them, like 'Person' or 'City'.

Labels classify nodes into groups. A node can have one or more labels. This helps you organize and query your graph efficiently.

For example, a node representing 'Alice' might have the label :Person. A node for 'Neo4j' might have the label :Database.

Let's create a simple node with a label:

Properties are key-value pairs that describe nodes or relationships. They store specific details about an entity or connection.

For a :Person node, properties could be name: 'Alice', age: 30, or city: 'London'. For a :Product node, properties might be price: 19.99 or category: 'Electronics'.

Here's how to create a node with multiple properties:

Relationships define how nodes are connected to each other. They are the 'verbs' of your graph, showing interactions or associations.

Unlike relational tables where connections are implicit via foreign keys, graph relationships are explicit, first-class citizens.

Relationships always have a type and a direction.

Every relationship has a type, which describes the nature of the connection. For instance, 'FRIENDS_WITH', 'ACTED_IN', or 'OWNS'.

Relationship types are crucial for understanding and querying your graph. They help you specify exactly what kind of connection you're looking for.

Let's create two nodes and connect them with a relationship:

Relationships are directional, meaning they flow from one node to another. This direction is important for understanding the context of the connection.

• (Alice)-[:LIKES]->(Bob): Alice likes Bob
• (Bob)-[:LIKES]->(Alice): Bob likes Alice

The arrows --> and <-- indicate direction. If direction isn't specified (--), the relationship is considered undirected in a query, but it's always stored with a direction.

Just like nodes, relationships can also have properties. These properties describe the relationship itself, not the connected nodes.

For example, a [:WORKS_FOR] relationship might have a startDate: '2020-01-15' property. A [:RATED] relationship could have a score: 5 property.

Here's an example of adding properties to a relationship:

Let's see how these components look together in a simple graph structure. Imagine a person reviewing a movie:

(Person)-[:REVIEWED {rating: 4}]->(Movie)

Here:

• (Person) and (Movie) are nodes, with their respective labels.
• [:REVIEWED] is the relationship type, showing direction.
• {rating: 4} is a property on the REVIEWED relationship.

This structure is incredibly flexible for modeling complex domains!

What are the three fundamental building blocks of a graph database like Neo4j?

Great job! In this lesson, you learned about the foundational elements of a graph database:

• Nodes are your entities, categorized by labels.
• Relationships connect nodes, defined by a type and direction.
• Properties are key-value pairs that add descriptive details to both nodes and relationships.

Understanding these concepts is key to building and querying powerful graph models. Next, we'll dive deeper into creating actual data using Cypher's CREATE clause!