What is Cypher? What is a Cypher
I’m not a cypher
Cypher is a graph query language that is used to query the Neo4j Database. Just like you use SQL to query a MySQL database, you would use Cypher to query the Neo4j Database.
Cypher is a graph query language used to query Neo4j databases. Just as you query a MySQL database with SQL, you can also query a Neo4j database with Cypher.
A simple example of a CYPher query:
Match (m:Movie) where m.released > 2000 RETURN m limit 5
Copy the code
Nodes and Relationships Nodes and Relationships
Nodes and relationships are the basic structure of a graph database.
Nodes Nodes
Nodes represent entities, and nodes in a graph database are similar to rows in a relational database. In the image below, we can see two types of nodes: Person and Movie. When writing cypher queries, the nodes are enclosed in parentheses – similar to (P :Person) p is a variable and Person is the type of node it represents.
Relationship between the Relationship
Two nodes can be connected by relationship. In the figure above, ACTED_IN, REVIEWED, PRODUCED, WROTE, DIRECTED are all the relationships that have been added to the corresponding type of nodes. When cypHER queries are written, relationships are enclosed in square brackets, such as [w:WORKS_FOR], where w is a variable and WORKS_FOR is the type of relationship to which W refers. Two nodes can have multiple relationships.
MATCH (p:Person)-[d:DIRECTED]-(m:Movie) where m.released > 2010 RETURN p,d,m
This query returns all Movie nodes with release dates after 2010 as well as the director Person node.
Labels tag
A label is the name or identifier of a node or relationship. In the figure below, Movie and Person are node tags, while ACTED_IN and VAT tags are relational tags.
When writing CYPher queries, tags are prefixed with colons, such as :Person or :ACTED_IN.
Node labels can be assigned to variables by prefixing the colon with the variable name.
For example, (p:Person) indicates that the p variable refers to the node of the Person tag. Similar to the relationship between variables and classes in object orientation.
MATCH (p:Person) RETURN p limit 20
Query only nodes of type Person (limiting to 20 items)
MATCH (n) RETURN n limit 20
Querying a Node of any type (Limiting to 20 items)
The Properties attribute
Properties are key-value pairs used to add properties to nodes and relationships. To query and return the specified attributes of a node, write:
MATCH (m:Movie) return m.title, m.released
Query the Movie node, but only return the title and released properties.
Create a Node Creates a Node
The Create statement can be used to Create new nodes or relationships.
Create (p:Person {name: 'John Doe'}) RETURN p
The above statement creates a new Person node with the name attribute ‘John Doe’.
throughMatch 和 WhereStatement query node
The Match statement is used to find nodes that Match a particular pattern. This is the primary way to get data from the Neo4j database.
In most cases, Match is used to narrow the range of results for specific conditions.
Match (p:Person {name: 'Tom Hanks'}) RETURN p
Filtering based on basic string matches can only be done in this way (without using the WHERE statement).
For more complex filtering, including >, <, Starts With, Ends With, and so on, you can combine the WHERE statement.
MATCH (p:Person) where p.name = "Tom Hanks" RETURN p
Both statements return the same result.
For more information about where: neo4j.com/docs/cypher…
Merge Clause specifies the Merge Clause
The Merge is used to
- Matches existing nodes and binds them or
- Create new nodes and bind them
It is a combination of Match and Create, and allows you to specify additional actions if data is matched or created.
MERGE (p:Person {name: 'John Doe'}) ON MATCH SET p.lastLoggedInAt = timestamp() ON CREATE SET p.createdAt = timestamp() Return p
If the staff node does not exist, the above statement creates it. If the node already exists, it sets the attribute lastLoggedInAt = current timestamp. If the node does not exist and is newly created, it sets the property createdAt = current timestamp.
Create a Relationship
The relationship connects two nodes.
MATCH (p:Person), (m:Movie) WHERE p.name = "Tom Hanks" and m.title = "Cloud Atlas" CREATE (p)-[w:WATCHED]->(m) RETURN type(w)
The above statement creates a WATCHED relationship between the Peron and Movie nodes and returns the type of the relationship (WATCHED).
Relationship Types
In Neo4j, there are two kinds of relationships – incoming and outgoing
In the figure above, the Tom Hanks node is said to have an outgoing relationship, while the Cloud Atlas node is said to have an incoming relationship.
Relationships always have a direction. However, you just need to pay attention to where it’s useful.
To express efferent or afferent relationships in CYPher, we use → or ←.
Example –
MATCH (p:Person)-[r:ACTED_IN]->(m:Movie) RETURN p,r,m
In the above query, Person has an outgoing relationship and Movie has an incoming relationship.
Although in the case of the movie dataset, the direction of the relationship is not so important, it will return the same result even if no direction is indicated in the query.
MATCH (p:Person)-[r:ACTED_IN]-(m:Movie) RETURN p,r,m
So the query above that is not an arrow will return the same result.
The Clean up Clean up
After the experiment/test /demo is complete, you can delete the movie dataset.
Note:
- If a relationship exists, the node cannot be deleted
- Delete nodes and relationships together
Delete all Movie and Person nodes and their relationships
MATCH (n) DETACH DELETE n
Confirm the deletion result:
MATCH (n) RETURN n
Complex query example
Multi-hop query example:
Query nodes and relationships that have a 4-hop relationship with Person Kevin Bacon
MATCH (bacon:Person {name:"Kevin Bacon"})-[*0..4]-(hollywood) RETURN DISTINCT hollywood
Shortest path query example:
Query the shortest path between Kevin Bacon and Meg Ryan
MATCH p=shortestPath( (bacon:Person {name:"Kevin Bacon"})-[*]-(meg:Person {name:"Meg Ryan"}) ) RETURN p
Extend Tom Hanks co-actors, to find co-co-actors who haven’t worked with Tom Hanks…
Expand Tom Hanks costars to find costars who haven’t worked with Tom Hanks…
MATCH (tom:Person {name:"Tom Hanks"})-[:ACTED_IN]->(m)<-[:ACTED_IN]-(coActors), (coActors)-[:ACTED_IN]->(m2)<-[:ACTED_IN]-(cocoActors) WHERE NOT (tom)-[:ACTED_IN]->()<-[:ACTED_IN]-(cocoActors) AND tom <> cocoActors RETURN cocoActors.name AS Recommended, count(*) AS Strength ORDER BY Strength DESCCopy the code
Find someone to introduce Tom Hanks to Tom Cruise
Get someone to introduce Tom Hanks to Tom Cruise
MATCH (tom:Person {name:"Tom Hanks"})-[:ACTED_IN]->(m)<-[:ACTED_IN]-(coActors),
(coActors)-[:ACTED_IN]->(m2)<-[:ACTED_IN]-(cruise:Person {name:"Tom Cruise"})
RETURN tom, m, coActors, m2, cruise
Copy the code