创建数据 #

一、CREATE语句概述 #

1.1 基本语法 #

cypher 
CREATE (节点模式)
CREATE (节点模式)-[关系模式]->(节点模式)

1.2 CREATE特点 #

text 
CREATE特点：
├── 总是创建新数据
├── 不检查是否已存在
├── 可以创建节点和关系
├── 支持批量创建
└── 返回创建的数据

二、创建节点 #

2.1 创建空节点 #

cypher 
CREATE ()

2.2 创建带标签的节点 #

cypher 
CREATE (:Person)
CREATE (:Person:Actor)

2.3 创建带属性的节点 #

cypher 
CREATE (:Person {name: 'Tom', age: 30})

2.4 创建完整节点并返回 #

cypher 
CREATE (p:Person:Actor {
    name: 'Tom Hanks',
    born: 1956,
    birthplace: 'California'
})
RETURN p

2.5 使用变量引用 #

cypher 
CREATE (p:Person {name: 'Tom'})
RETURN p

2.6 批量创建节点 #

cypher 
CREATE (:Person {name: 'Tom'}),
       (:Person {name: 'Jerry'}),
       (:Person {name: 'Mike'})

2.7 使用UNWIND批量创建 #

cypher 
UNWIND [
    {name: 'Tom', age: 30},
    {name: 'Jerry', age: 25},
    {name: 'Mike', age: 35}
] AS row
CREATE (p:Person)
SET p = row
RETURN p

2.8 使用参数创建 #

cypher 
:param person => {name: 'Tom', age: 30}
CREATE (p:Person $person)
RETURN p

2.9 使用参数列表批量创建 #

cypher 
:param persons => [
    {name: 'Tom', age: 30},
    {name: 'Jerry', age: 25},
    {name: 'Mike', age: 35}
]
UNWIND $persons AS person
CREATE (p:Person)
SET p = person
RETURN p

三、创建关系 #

3.1 创建节点同时创建关系 #

cypher 
CREATE (a:Person {name: 'Tom'})-[:KNOWS]->(b:Person {name: 'Jerry'})
RETURN a, b

3.2 基于已有节点创建关系 #

cypher 
MATCH (a:Person {name: 'Tom'})
MATCH (b:Person {name: 'Jerry'})
CREATE (a)-[:KNOWS]->(b)

3.3 创建带属性的关系 #

cypher 
MATCH (a:Person {name: 'Tom'})
MATCH (b:Person {name: 'Jerry'})
CREATE (a)-[:KNOWS {since: 2020, level: 'close'}]->(b)

3.4 创建双向关系 #

cypher 
MATCH (a:Person {name: 'Tom'})
MATCH (b:Person {name: 'Jerry'})
CREATE (a)-[:FRIEND_OF]->(b),
       (b)-[:FRIEND_OF]->(a)

3.5 创建多个关系 #

cypher 
MATCH (a:Person {name: 'Tom'})
MATCH (b:Person {name: 'Jerry'})
CREATE (a)-[:KNOWS]->(b),
       (a)-[:WORKS_WITH]->(b),
       (a)-[:LIVES_NEAR]->(b)

3.6 创建关系变量 #

cypher 
MATCH (a:Person {name: 'Tom'})
MATCH (b:Person {name: 'Jerry'})
CREATE (a)-[r:KNOWS {since: 2020}]->(b)
RETURN r

3.7 创建链式关系 #

cypher 
CREATE (a:Person {name: 'Tom'})-[:KNOWS]->(b:Person {name: 'Jerry'})-[:KNOWS]->(c:Person {name: 'Mike'})
RETURN a, b, c

3.8 创建复杂图结构 #

cypher 
CREATE 
    (tom:Person {name: 'Tom Hanks'}),
    (movie:Movie {title: 'Forrest Gump', year: 1994}),
    (robert:Person {name: 'Robert Zemeckis'}),
    (genre:Genre {name: 'Drama'}),
    (tom)-[:ACTED_IN {role: 'Forrest Gump'}]->(movie),
    (robert)-[:DIRECTED]->(movie),
    (movie)-[:HAS_GENRE]->(genre)
RETURN tom, movie, robert, genre

四、MERGE语句 #

4.1 MERGE概述 #

MERGE是"存在则匹配，不存在则创建"的操作。

text 
MERGE特点：
├── 检查数据是否存在
├── 存在则返回已有数据
├── 不存在则创建新数据
├── 支持ON CREATE和ON MATCH
└── 可用于节点和关系

4.2 MERGE基本用法 #

cypher 
MERGE (p:Person {name: 'Tom'})
RETURN p

4.3 MERGE与ON CREATE #

cypher 
MERGE (p:Person {name: 'Tom'})
ON CREATE SET p.created = timestamp(), p.source = 'import'
RETURN p

4.4 MERGE与ON MATCH #

cypher 
MERGE (p:Person {name: 'Tom'})
ON MATCH SET p.lastSeen = timestamp(), p.accessCount = coalesce(p.accessCount, 0) + 1
RETURN p

4.5 MERGE完整示例 #

cypher 
MERGE (p:Person {name: 'Tom'})
ON CREATE SET 
    p.created = timestamp(),
    p.age = 30
ON MATCH SET 
    p.lastSeen = timestamp(),
    p.visitCount = coalesce(p.visitCount, 0) + 1
RETURN p

4.6 MERGE多属性 #

cypher 
MERGE (p:Person {name: 'Tom', email: 'tom@example.com'})
ON CREATE SET p.created = timestamp()
ON MATCH SET p.updated = timestamp()
RETURN p

4.7 MERGE关系 #

cypher 
MATCH (a:Person {name: 'Tom'})
MATCH (b:Person {name: 'Jerry'})
MERGE (a)-[r:KNOWS]->(b)
ON CREATE SET r.since = 2020
ON MATCH SET r.lastSeen = timestamp()
RETURN r

4.8 MERGE带属性的关系 #

cypher 
MATCH (a:Person {name: 'Tom'})
MATCH (b:Person {name: 'Jerry'})
MERGE (a)-[r:KNOWS {since: 2020}]->(b)
RETURN r

五、CREATE与MERGE对比 #

5.1 功能对比 #

特性 CREATE MERGE
检查存在 否 是
重复创建 会重复 不会重复
性能 更快 需要查找
使用场景 确定不存在时 不确定是否存在

5.2 使用场景 #

text 
使用CREATE：
├── 确定数据不存在
├── 需要创建重复数据
├── 批量导入新数据
└── 性能要求高

使用MERGE：
├── 不确定数据是否存在
├── 需要幂等操作
├── 需要更新或创建
└── 数据同步场景

5.3 性能建议 #

cypher 
CREATE (p:Person {name: 'Tom'})

MERGE (p:Person {name: 'Tom'})

六、批量创建 #

6.1 使用UNWIND #

cypher 
UNWIND range(1, 100) AS id
CREATE (p:Person {id: id, name: 'Person ' + id})

6.2 使用UNWIND和参数 #

cypher 
:param data => [
    {id: 1, name: 'Tom', age: 30},
    {id: 2, name: 'Jerry', age: 25},
    {id: 3, name: 'Mike', age: 35}
]
UNWIND $data AS row
CREATE (p:Person)
SET p = row

6.3 批量创建节点和关系 #

cypher 
:param data => [
    {from: 'Tom', to: 'Jerry', since: 2020},
    {from: 'Jerry', to: 'Mike', since: 2021},
    {from: 'Tom', to: 'Mike', since: 2022}
]
UNWIND $data AS row
MERGE (a:Person {name: row.from})
MERGE (b:Person {name: row.to})
MERGE (a)-[:KNOWS {since: row.since}]->(b)

6.4 使用CALL批量处理 #

cypher 
CALL {
    UNWIND range(1, 1000) AS i
    CREATE (p:Person {id: i})
    RETURN p
} IN TRANSACTIONS OF 100 ROWS

七、从文件导入 #

7.1 使用LOAD CSV #

cypher 
LOAD CSV WITH HEADERS FROM 'file:///persons.csv' AS row
CREATE (p:Person {
    id: row.id,
    name: row.name,
    age: toInteger(row.age)
})

7.2 处理大型CSV #

cypher 
LOAD CSV WITH HEADERS FROM 'file:///persons.csv' AS row
CALL {
    WITH row
    CREATE (p:Person {
        id: row.id,
        name: row.name,
        age: toInteger(row.age)
    })
} IN TRANSACTIONS OF 1000 ROWS

7.3 导入并创建关系 #

cypher 
LOAD CSV WITH HEADERS FROM 'file:///relationships.csv' AS row
MATCH (a:Person {id: row.from_id})
MATCH (b:Person {id: row.to_id})
CREATE (a)-[:KNOWS {since: toInteger(row.since)}]->(b)

7.4 使用MERGE导入 #

cypher 
LOAD CSV WITH HEADERS FROM 'file:///persons.csv' AS row
MERGE (p:Person {id: row.id})
ON CREATE SET p.name = row.name, p.age = toInteger(row.age)
ON MATCH SET p.name = row.name, p.age = toInteger(row.age)

八、复制数据 #

8.1 复制节点 #

cypher 
MATCH (p:Person)
CREATE (p2:PersonCopy)
SET p2 = properties(p)

8.2 复制带标签 #

cypher 
MATCH (p:Person)
CREATE (p2:PersonBackup:Person)
SET p2 = properties(p)

8.3 复制子图 #

cypher 
MATCH (p:Person {name: 'Tom'})-[r:KNOWS]->(f:Person)
CREATE (p2:Person)
SET p2 = properties(p)
CREATE (f2:Person)
SET f2 = properties(f)
CREATE (p2)-[r2:KNOWS]->(f2)
SET r2 = properties(r)

九、创建数据最佳实践 #

9.1 使用唯一标识 #

cypher 
CREATE CONSTRAINT FOR (p:Person) REQUIRE p.id IS UNIQUE

CREATE (p:Person {id: 'person_001', name: 'Tom'})

9.2 使用MERGE避免重复 #

cypher 
MERGE (p:Person {id: 'person_001'})
ON CREATE SET p.name = 'Tom', p.created = timestamp()
ON MATCH SET p.updated = timestamp()

9.3 批量创建优化 #

cypher 
UNWIND $batch AS row
MERGE (p:Person {id: row.id})
SET p += {name: row.name, age: row.age}

9.4 时间戳管理 #

cypher 
CREATE (p:Person {
    name: 'Tom',
    createdAt: datetime(),
    updatedAt: datetime()
})

MERGE (p:Person {name: 'Tom'})
ON CREATE SET p.createdAt = datetime()
ON MATCH SET p.updatedAt = datetime()

9.5 避免反模式 #

text 
避免：
├── 不使用唯一标识直接CREATE
├── 大量单条CREATE语句
├── 不使用事务批量处理
├── MERGE时使用过多属性
└── 创建后不返回验证

十、实际应用示例 #

10.1 创建用户 #

cypher 
CREATE (u:User:Person {
    id: 'user_001',
    username: 'tom_hanks',
    email: 'tom@example.com',
    firstName: 'Tom',
    lastName: 'Hanks',
    isActive: true,
    roles: ['user', 'admin'],
    createdAt: datetime(),
    updatedAt: datetime()
})
RETURN u

10.2 创建社交关系 #

cypher 
MATCH (tom:User {username: 'tom_hanks'})
MATCH (jerry:User {username: 'jerry_mouse'})
CREATE (tom)-[:FOLLOWS {since: datetime(), status: 'active'}]->(jerry)

10.3 创建产品目录 #

cypher 
CREATE (category:Category {id: 'cat_001', name: 'Electronics'})
CREATE (product:Product {
    id: 'prod_001',
    name: 'iPhone 15',
    price: 999.99,
    stock: 100
})
CREATE (product)-[:BELONGS_TO]->(category)

10.4 创建订单 #

cypher 
MATCH (user:User {id: 'user_001'})
MATCH (product:Product {id: 'prod_001'})
CREATE (order:Order {
    id: 'order_001',
    orderNumber: 'ORD-2024-001',
    status: 'pending',
    totalAmount: 999.99,
    createdAt: datetime()
})
CREATE (user)-[:PLACED]->(order)
CREATE (order)-[:CONTAINS {quantity: 1, price: 999.99}]->(product)

十一、总结 #

创建数据要点：

操作 语法 说明
创建节点 CREATE (n:Label {prop: value}) 创建新节点
创建关系 CREATE (a)-[:TYPE]->(b) 创建关系
合并创建 MERGE (n:Label {prop: value}) 存在则匹配，不存在则创建
批量创建 UNWIND … CREATE 批量创建

最佳实践：

  1. 使用唯一标识避免重复
  2. 使用MERGE处理不确定数据
  3. 批量创建使用UNWIND
  4. 大数据量使用事务分批处理
  5. 创建后验证返回结果

下一步，让我们学习更新数据！

最后更新：2026-03-27