图数据库中‘将关系数据作为一等实体存储’的含义及示例问询

Great question—this is one of the core superpowers that sets graph databases apart from traditional relational systems. Let’s break it down with plain language and concrete examples.

First, What’s a "First-Class Entity"? #

In database terms, a first-class entity is something that:

• Has its own distinct identity (you can reference it directly)
• Can hold its own properties (metadata that describes the relationship itself)
• Can be queried, updated, or deleted independently of the nodes it connects

Unlike relational databases where relationships are just implicit (via foreign keys) or hidden in junction tables, graph databases treat relationships (often called "edges") as equal to the nodes (like users, products, or locations) they link.

Let’s Compare to Relational Databases #

Suppose you want to model a "user favorites product" relationship in MySQL:

1. You’d have users and products tables with core data for each entity.
2. To track favorites, you’d create a junction table user_favorites with columns like user_id, product_id, favorite_date, and note.

Here, the "favorite" relationship isn’t a standalone thing—it’s just a row in a table that exists solely to link two other tables. To get details about the relationship, you have to join multiple tables, and you can’t directly query "all favorite relationships" without tying them to users or products first.

Graph Database Example (Using Neo4j & Cypher) #

In a graph database like Neo4j, that same relationship becomes a first-class entity. Let’s walk through it:

Step 1: Create Nodes #

First, we create our user and product nodes (the entities we want to connect):

CREATE (:User {name: 'Alice', age: 30})
CREATE (:Product {name: 'Wireless Headphones', price: 199})

Step 2: Create a First-Class Relationship #

Now we create the FAVORITED relationship between Alice and the headphones—and this relationship gets its own properties:

MATCH (u:User {name: 'Alice'}), (p:Product {name: 'Wireless Headphones'})
CREATE (u)-[:FAVORITED {date: '2024-05-20', note: 'Great for workouts'}]->(p)

Notice that the FAVORITED edge isn’t just a link—it has its own data (date and note) that adds context to the relationship.

Step 3: Query & Manipulate the Relationship Directly #

Since it’s a first-class entity, we can interact with it without messy joins:

• Query all favorite relationships:

  MATCH ()-[r:FAVORITED]->()
  RETURN startNode(r).name AS user, endNode(r).name AS product, r.date AS favorite_date, r.note AS note
  

  This returns every FAVORITED edge in the database, along with its properties and connected nodes—no joins required.

• Update the relationship’s properties:

  MATCH (u:User {name: 'Alice'})-[r:FAVORITED]->(p:Product {name: 'Wireless Headphones'})
  SET r.note = 'Great for workouts and commutes'
  

  We’re modifying the relationship directly, not a row in a junction table.

Why This Matters #

Treating relationships as first-class entities makes modeling and querying connected data trivial. For example:

• You can easily find all users who favorited the same product as Alice
• You can analyze patterns in relationship data (e.g., "how many favorites happened in May?")
• You can add context to relationships (like the reason someone favorited a product) without restructuring your entire schema

内容的提问来源于stack exchange，提问作者Pantea