Your First Queries

Learn basic Cypher queries to create, read, update, and delete graph data.

Prerequisites

• NornicDB installed and running (see Installation)
• Connected to database (HTTP or Bolt)

What You'll Learn

1. Creating nodes and relationships
2. Querying graph data
3. Updating properties
4. Deleting data
5. Basic graph patterns

1⃣ Creating Your First Node

Let's create a person node:

CREATE (alice:Person {
  name: "Alice Johnson",
  age: 30,
  email: "alice@example.com"
})
RETURN alice

What this does:

• CREATE - Creates a new node
• (alice:Person ...) - Variable name alice, label Person
• {name: ..., age: ...} - Properties (see Property Data Types for all supported types)
• RETURN alice - Returns the created node

2⃣ Creating Multiple Nodes

CREATE 
  (bob:Person {name: "Bob Smith", age: 35}),
  (carol:Person {name: "Carol White", age: 28}),
  (company:Company {name: "TechCorp", founded: 2010})
RETURN bob, carol, company

3⃣ Creating Relationships

Connect Alice to the company:

MATCH 
  (alice:Person {name: "Alice Johnson"}),
  (company:Company {name: "TechCorp"})
CREATE (alice)-[r:WORKS_AT {since: 2020, role: "Engineer"}]->(company)
RETURN alice, r, company

Relationship syntax:

• (alice)-[r:WORKS_AT {...}]->(company) - Directed relationship
• r:WORKS_AT - Relationship type
• {since: 2020, role: "Engineer"} - Relationship properties

4⃣ Querying Data

Find all people

MATCH (p:Person)
RETURN p.name, p.age
ORDER BY p.age DESC

Find relationships

MATCH (p:Person)-[r:WORKS_AT]->(c:Company)
RETURN p.name, r.role, c.name

Filter with WHERE

MATCH (p:Person)
WHERE p.age > 30
RETURN p.name, p.age

Pattern matching

// Find people who work at the same company
MATCH (p1:Person)-[:WORKS_AT]->(c:Company)<-[:WORKS_AT]-(p2:Person)
WHERE p1.name < p2.name  // Avoid duplicates
RETURN p1.name, p2.name, c.name

5⃣ Updating Data

Update properties

MATCH (alice:Person {name: "Alice Johnson"})
SET alice.age = 31, alice.city = "San Francisco"
RETURN alice

Add labels

MATCH (alice:Person {name: "Alice Johnson"})
SET alice:Employee:Manager
RETURN labels(alice)

Remove properties

MATCH (alice:Person {name: "Alice Johnson"})
REMOVE alice.email
RETURN alice

6⃣ Deleting Data

Delete a node (must delete relationships first)

MATCH (bob:Person {name: "Bob Smith"})
DETACH DELETE bob

Note: DETACH DELETE removes the node and all its relationships.

Delete specific relationships

MATCH (alice:Person)-[r:WORKS_AT]->()
DELETE r

Delete all data ( Use with caution!)

MATCH (n)
DETACH DELETE n

7⃣ Common Patterns

Create if not exists (MERGE)

MERGE (alice:Person {name: "Alice Johnson"})
ON CREATE SET alice.created = timestamp()
ON MATCH SET alice.accessed = timestamp()
RETURN alice

Count nodes

MATCH (p:Person)
RETURN count(p) as totalPeople

Aggregate data

MATCH (p:Person)
RETURN 
  count(p) as total,
  avg(p.age) as averageAge,
  min(p.age) as youngest,
  max(p.age) as oldest

Collect into list

MATCH (p:Person)
RETURN collect(p.name) as allNames

8⃣ Practical Example: Social Network

Let's build a small social network:

// Create people
CREATE 
  (alice:Person {name: "Alice", age: 30}),
  (bob:Person {name: "Bob", age: 35}),
  (carol:Person {name: "Carol", age: 28}),
  (dave:Person {name: "Dave", age: 32})

// Create friendships
CREATE
  (alice)-[:FRIENDS_WITH {since: 2020}]->(bob),
  (alice)-[:FRIENDS_WITH {since: 2019}]->(carol),
  (bob)-[:FRIENDS_WITH {since: 2021}]->(dave),
  (carol)-[:FRIENDS_WITH {since: 2020}]->(dave)

RETURN *

Find friends of friends

MATCH (alice:Person {name: "Alice"})-[:FRIENDS_WITH*2]-(fof:Person)
WHERE alice <> fof
RETURN DISTINCT fof.name as friendOfFriend

Find shortest path

MATCH path = shortestPath(
  (alice:Person {name: "Alice"})-[:FRIENDS_WITH*]-(dave:Person {name: "Dave"})
)
RETURN path

9⃣ Working with Properties

JSON-like properties

CREATE (doc:Document {
  title: "README",
  metadata: {
    author: "Alice",
    version: "1.0",
    tags: ["documentation", "guide"]
  }
})
RETURN doc

List properties

CREATE (person:Person {
  name: "Alice",
  skills: ["Python", "Go", "JavaScript"],
  languages: ["English", "Spanish"]
})
RETURN person

Access nested properties

MATCH (doc:Document)
RETURN doc.metadata.author, doc.metadata.tags

Tips & Best Practices

1. Use parameters for dynamic values

// Instead of:
MATCH (p:Person {name: "Alice"})

// Use parameters:
MATCH (p:Person {name: $name})

2. Create indexes for better performance

CREATE INDEX person_name FOR (p:Person) ON (p.name)

3. Use EXPLAIN to understand query plans

EXPLAIN MATCH (p:Person) WHERE p.age > 30 RETURN p

4. Use PROFILE for performance analysis

PROFILE MATCH (p:Person)-[:WORKS_AT]->(c:Company) RETURN p, c

5. Limit results for large datasets

MATCH (p:Person)
RETURN p
LIMIT 10

Common Functions

String functions

MATCH (p:Person)
RETURN 
  toLower(p.name) as lowercase,
  toUpper(p.name) as uppercase,
  substring(p.name, 0, 3) as first3chars

Math functions

RETURN 
  abs(-5) as absolute,
  round(3.14159, 2) as rounded,
  sqrt(16) as squareRoot

List functions

RETURN 
  size([1,2,3,4,5]) as listSize,
  head([1,2,3]) as firstElement,
  tail([1,2,3]) as restOfList

Next Steps

Now that you know the basics:

1. Vector Search Guide - Semantic search
2. Complete Examples - Full applications
3. Cypher Functions Reference - All functions
4. Advanced Topics - K-Means clustering, embeddings, custom functions

Common Issues

"Node not found"

• Make sure you created the node first
• Check spelling of labels and properties

"Cannot delete node with relationships"

• Use DETACH DELETE instead of DELETE

"Query too slow"

• Create indexes on frequently queried properties
• Use EXPLAIN to analyze query plan
• Limit result sets with LIMIT

---

Need more examples? → Complete ExamplesReady for advanced features? → User Guides