CREATE

The CREATE clause is used to create nodes and relationships in the graph.

Create Nodes#

Basic Node Creation#

CREATE (n:User)
RETURN n

Node with Properties#

CREATE (u:User {name: 'Alice', age: 28, email: '[email protected]'})
RETURN u

Multiple Labels#

CREATE (p:Person:Employee {name: 'Bob', employeeId: '12345'})
RETURN p

Multiple Nodes#

CREATE (u1:User {name: 'Alice'}),
       (u2:User {name: 'Bob'}),
       (u3:User {name: 'Charlie'})
RETURN u1, u2, u3

Create Relationships#

Basic Relationship#

MATCH (a:User {name: 'Alice'}),
      (b:User {name: 'Bob'})
CREATE (a)-[:KNOWS]->(b)
RETURN a, b

Relationship with Properties#

MATCH (a:User {name: 'Alice'}),
      (b:User {name: 'Bob'})
CREATE (a)-[:KNOWS {since: '2020-01-15', strength: 0.8}]->(b)
RETURN a, b

Bidirectional Relationships#

MATCH (a:User {name: 'Alice'}),
      (b:User {name: 'Bob'})
CREATE (a)-[:KNOWS]->(b),
       (b)-[:KNOWS]->(a)

Create Nodes and Relationships Together#

Create Path#

CREATE (a:User {name: 'Alice'})-[:KNOWS]->(b:User {name: 'Bob'})
RETURN a, b

Create Complex Pattern#

CREATE (u:User {name: 'Alice'})-[:POSTED]->(p:Post {title: 'Hello World'}),
       (u)-[:LIVES_IN]->(c:City {name: 'New York'})
RETURN u, p, c

Create Chain#

CREATE (a:User {name: 'Alice'})-[:KNOWS]->(b:User {name: 'Bob'})-[:KNOWS]->(c:User {name: 'Charlie'})
RETURN a, b, c

Create with RETURN#

Return created elements:

CREATE (u:User {name: 'Alice', created: datetime()})
RETURN u.name, u.created, id(u) AS userId

Create from Parameters#

Use parameters for dynamic data:

CREATE (u:User {
  name: $name,
  age: $age,
  email: $email
})
RETURN u

Python example:

graph.query("""
    CREATE (u:User {name: $name, age: $age})
    RETURN u
""", {
    'name': 'Alice',
    'age': 28
})

Bulk Creation#

Create Multiple Nodes with UNWIND#

UNWIND [
  {name: 'Alice', age: 28},
  {name: 'Bob', age: 32},
  {name: 'Charlie', age: 25}
] AS userData
CREATE (u:User {name: userData.name, age: userData.age})
RETURN count(u) AS created

Batch Create from List#

WITH [
  ['Alice', 'Bob'],
  ['Bob', 'Charlie'],
  ['Alice', 'Charlie']
] AS friendships
UNWIND friendships AS friendship
MATCH (a:User {name: friendship[0]}),
      (b:User {name: friendship[1]})
CREATE (a)-[:KNOWS]->(b)

CREATE vs MERGE#

CREATE always creates new elements:

-- Creates duplicate even if exists
CREATE (u:User {name: 'Alice'})

Use MERGE to avoid duplicates:

-- Only creates if doesn't exist
MERGE (u:User {name: 'Alice'})

Create with Match#

Create based on existing data:

MATCH (u:User)
WHERE u.age > 25
CREATE (u)-[:MEMBER_OF]->(g:Group {name: 'Adults'})

Set Timestamps on Creation#

CREATE (u:User {
  name: 'Alice',
  created: datetime(),
  updated: datetime()
})
RETURN u

Create Unique IDs#

CREATE (u:User {
  id: randomUUID(),
  name: 'Alice'
})
RETURN u

Common Patterns#

Create User Profile#

CREATE (u:User {name: 'Alice'})-[:HAS_PROFILE]->(p:Profile {
  bio: 'Software Engineer',
  location: 'San Francisco',
  website: 'https://alice.dev'
})
RETURN u, p

MATCH (a:User {name: 'Alice'}),
      (b:User {name: 'Bob'})
CREATE (a)-[r:KNOWS {
  since: datetime(),
  type: 'friend',
  strength: 1.0
}]->(b)
RETURN a, r, b

Create Hierarchical Data#

CREATE (company:Company {name: 'TechCorp'})
CREATE (dept1:Department {name: 'Engineering'})-[:PART_OF]->(company)
CREATE (dept2:Department {name: 'Sales'})-[:PART_OF]->(company)
CREATE (emp1:Employee {name: 'Alice'})-[:WORKS_IN]->(dept1)
CREATE (emp2:Employee {name: 'Bob'})-[:WORKS_IN]->(dept1)
RETURN company, dept1, dept2, emp1, emp2

Create Time-Series Events#

UNWIND range(1, 10) AS i
CREATE (e:Event {
  id: i,
  timestamp: datetime() + duration({days: i}),
  type: 'measurement',
  value: rand() * 100
})

Performance Tips#

Batch Creates ```cypher -- Good: Single query with UNWIND UNWIND $users AS user CREATE (u:User {name: user.name, age: user.age})

-- Bad: Multiple individual CREATE queries CREATE (u:User {name: 'Alice', age: 28}) CREATE (u:User {name: 'Bob', age: 32}) ```

Use Transactions python with graph.transaction() as tx: for user in users: tx.execute("CREATE (u:User {name: $name})", {'name': user})
Set Indexes Before Bulk Loads cypher CREATE INDEX ON :User(email) -- Then bulk create users
Avoid Creating Duplicates cypher -- Check first with MERGE MERGE (u:User {email: $email}) ON CREATE SET u.name = $name, u.created = datetime() ON MATCH SET u.updated = datetime()

Error Handling#

Avoid Constraint Violations#

-- Create constraint
CREATE CONSTRAINT ON (u:User) ASSERT u.email IS UNIQUE

-- This will fail if email exists
CREATE (u:User {email: '[email protected]'})

-- Use MERGE to handle existing data
MERGE (u:User {email: '[email protected]'})
ON CREATE SET u.name = 'Alice', u.created = datetime()

Next Steps#

Update data with SET
Delete data with DELETE
Match patterns with MATCH
Read Cypher Introduction

Edit this page on GitHub