Difference between revisions of "Neo4j:Basics - Introduction"

Working With the greek_gods Family Tree Graph

This tutorial introduces NoSQL using Neo4j. We will be using the RETURN, MATCH, and WHERE clauses on the greek_gods collection which contains a family tree of around 130 individuals with varying roles and significance in Greek mythology.

For anyone wishing to use this data-set on their own machines, the Cypher file will be available here at a later date.

Introduction to Graphs and the 'Graph Property Model'

You've likely heard of graphs before. In mathematics a graph is the term for a set of vertices and edges, here it is a collection of nodes and relationships respectively.

In Neo4j graphs follow the "Property Graph Model". A property is just a key-value pair, such as name: 'Alice', age: 27, pet_dogs. Users who have used document-oriented databases such as MongoDB or who have used JavaScript Object Notation (JSON) will be familiar with this concept already.

A node is a simple entity that contains any amount of properties. A node representing a person might include things like their name, date of birth, or hometown etc. As well as containing properties, nodes can be labeled as belonging to a certain group for query purposes. For example, in a database of celebrities Barry Manilow could be labeled as an :Musician. There's no limit to the amount of labels that can apply to a node, the celebrity Hugh Laurie could be simultaneously labeled as an :Actor, :Musician, and :Author.

In the property graph model, a relationship is a connection between exactly two nodes, though there's not limit to the amount of relationships a node made have. A relationship always has both a name and a direction (start node and end node), and like a node it can also have properties. Bidirectional relationships are a little trickier, and are out-width the scope of this tutorial: Modelling Bidirectional Relationships

This remainder of this tutorial will use the Cypher query language (CQL) to introduce some basic concepts.

RETURN

RETURN 2 + 2, "A" + "B", [1, 2, 3] + [4];

MATCH

The MATCH clause is used to search for data that meets a pattern you define.
Pattern matching forms the basis of most queries in Neo4j. Patterns are ASCII descriptions of "shapes" that can be found in a graph, nodes are represented by pairs of parenthesis: ().
Relations represented by hyphens, chevrons, and square brackets: --, <--, --> -[]-, <-[]-, -[]->. Neo4j also allows you to name patterns, e.g. (a) so that you may refer to them later.

These exercises will introduce you to pattern matching, but those interested can also view the official documentation here.

MATCH Everything

MATCH (n)
RETURN n;

WHERE

MATCH (n)
WHERE n:God AND n.name = 'Zeus'
RETURN n;

MATCH (g) WHERE g:God AND g.name = 'Zeus' RETURN g; 

Combining MATCH and WHERE

MATCH (g:God {name: 'Zeus'})
RETURN g;

Query by ID

MATCH (n)
WHERE id(n) = 2
RETURN n;

Query by Atributes

MATCH (g:God {name: "Zeus"}) 
RETURN g.name, g.greek;

MATCH (g:God {name: "Zeus"}) RETURN g.name, g.greek;

IN

MATCH (g:God) 
WHERE g.name IN ['Hera', 'Demeter'] 
RETURN g.name, g.greek;

MATCH (g:God) WHERE g.name IN ['Zeus', 'Poseidon', 'Hades'] RETURN g.name, g.greek;

NOT _ IN

MATCH (o:Olympian)
RETURN o.name;

MATCH (o:Olympian) WHERE NOT o.name IN ['Apollo', 'Hestia'] RETURN o.name;

ORDER BY

MATCH (o:Olympian)
RETURN o.name
ORDER BY o.name;

LIMIT

The 'LIMIT clause is used to set a maximum number of results.

First n Results.

MATCH (n)
RETURN n
LIMIT 2;

Last n Results.

MATCH (n)
RETURN n
ORDER BY n DESC
LIMIT 2;

SKIP

Skip n Results. / Find nth Result.

MATCH (n)
RETURN n.name
SKIP 10
LIMIT 4;

Further examples can be found here: MATCH Examples.
Once comfortable with these questions, move onto MATCH Basics - Relationships.