Neo4j

cypher-shell -u <username: neo4j> -p <password> [-d <database_name>]

:exit

SHOW DATABASES

CREATE DATABASE <database_name>

DROP DATABASE <database_name>

:use <database_name>

CREATE (n:<Node: Book>)
RETURN n

CREATE (n:<Node> {<property1> <value1>, <property2> <value2>})
RETURN n

CREATE
    (a:<Node1> {<property>: <value>}),
    (b:<Node2> {<property>: <value>})
RETURN a, b

MATCH (n:<Node>)
WHERE n.<property> = <value>
SET n.<property> = <new_value>
RETURN n

MATCH (n:<Node>)
WHERE n.<property> = <value>
DELETE n

MATCH (n:<Node>)
WHERE n.<property> = <value>
RETURN n
LIMIT <limit: 10>

MATCH (a:<Node1>), (b:<Node2>)
CREATE (a)-[r:<REL_TYPE>]->(b)
RETURN r

MATCH (a:<Node1> {<property>: <value>}), (b:<Node2> {<property>: <value>})
CREATE (a)-[r:<REL_TYPE> {<property>: <value>}]->(b)
RETURN r

MATCH (a:<Node1>)-[r:<REL_TYPE>]->(b:<Node2>)
SET r.<property> = <new_value>
RETURN r

MATCH (a:<Node1>)-[r:<REL_TYPE>]->(b:<Node2>)
DELETE r

MATCH (a:<Node1>)-[r:<REL_TYPE> {property: <value>}]->(b:<Node2>)
RETURN a, r, b

# Matches paths of length 1 to 3
MATCH (a:<Node1>)-[r:<REL_TYPE>*1..3]->(b:<Node2>)
RETURN a, b

# Matches any length
MATCH (a:<Node1>)-[r:<REL_TYPE>*]->(b:<Node2>)
RETURN a, b

MATCH (a:<Node1>), (b:<Node2>)
WHERE a.name = <value> AND b.name = <value>
MATCH path = shortestPath((a)-[*]->(b))
RETURN path

MATCH (a:<Node1>), (b:<Node2>)
WHERE a.name = <value> AND b.name = <value>
MATCH path = allShortestPaths((a)-[*]->(b))
RETURN path

SHOW CONSTRAINTS

CREATE CONSTRAINT <constraint_name> FOR (n:<Node>) REQUIRE n.<property> IS UNIQUE

CREATE CONSTRAINT <constraint_name> FOR (n:<Node>) REQUIRE n.<property> IS NODE KEY

CREATE CONSTRAINT <constraint_name> FOR (n:<Node>) REQUIRE n.<property> IS NOT NULL

DROP CONSTRAINT <constraint_name>

SHOW INDEXES

CREATE INDEX <index_name> FOR (n:<Node>) ON (n.<property>)

CREATE INDEX <index_name> FOR (n:<Node>) ON (n.<property1>, n.<property2>)

DROP INDEX <index_name>

MATCH (n:<Node>)
WHERE n.<property1> = <value1> AND n.<property2> > <value2>
RETURN n

MATCH (n:<Node>)
WHERE n.<property> IN [<value1>, <value2>, <value3>]
RETURN n

MATCH (n:<Node>)
WHERE n.<property> STARTS WITH "<prefix>"
RETURN n

MATCH (n:<Node>)
WHERE n.<property> CONTAINS "<substring>"
RETURN n

MATCH (n:<Node>)
WHERE EXISTS(n.<property>)
RETURN n

MATCH (n:<Node>)
RETURN COUNT(n) AS count

MATCH (n:<Node>)
RETURN n
ORDER BY n.<property> <ASC or DESC>
LIMIT <limit: 10>

MATCH (n:<Node>)
RETURN n.<property>, COUNT(*), AVG(n.<property>), MAX(n.<property>), MIN(n.<property>)

MATCH (n:<Node>)
RETURN DISTINCT n.<property>

MATCH (n:<Node>)
RETURN n.<property>, COUNT(*) AS count