Neo4J

Question 1

CREATE (n:Person {name: ‘Alice’})

Answer 1

Creates a node with label “Person”, called n during the operation and assigns the property “name” with string value ‘Alice’.

Question 2

MATCH (a:Person {name: ‘Alice’}), (b:Person {name: ‘Bob’})
CREATE (a)-[:KNOWS]->(b)

Answer 2

Finds nodes with the label “Person” where the name is ‘Alice’ and ‘Bob’, and creates a “KNOWS” relationship from ‘Alice’ to ‘Bob’.

Question 3

MATCH (n:Person)
RETURN n

Answer 3

Matches all nodes with the label “Person” and returns them.

Question 4

MATCH (a:Person)-[:KNOWS]->(b:Person)
RETURN a, b

Answer 4

Finds all pairs of “Person” nodes where one knows the other and returns both persons.

Question 5

MATCH (n:Person {name: ‘Alice’})
SET n.age = 31

Answer 5

Matches the “Person” node where the name is ‘Alice’ and sets the property “age” to 31.

Question 6

MATCH (n:Person {name: ‘Alice’})
DELETE n

Answer 6

Deletes the “Person” node where the name is ‘Alice’. Note: This will fail if the node has any relationships.

Question 7

MATCH (n:Person {name: ‘Alice’})-[r]-()
DELETE r, n

Answer 7

Deletes the “Person” node where the name is ‘Alice’ along with all its relationships.

Question 8

MATCH (a:Person {name: ‘Alice’})-[:KNOWS*]->(b)
RETURN b

Answer 8

Finds all nodes that ‘Alice’ knows directly or indirectly and returns those nodes.

Question 9

MATCH (a:Person {name: ‘Alice’}), (b:Person {name: ‘Bob’})
MATCH p = shortestPath((a)-[*]-(b))
RETURN p

Answer 9

Finds the shortest path between ‘Alice’ and ‘Bob’ and returns the path.

Question 10

CALL algo.pageRank(‘Person’, ‘KNOWS’)
YIELD node, score
RETURN node, score
ORDER BY score DESC

Answer 10

Runs the PageRank algorithm on the “Person” nodes connected by “KNOWS” relationships, yielding each node with its PageRank score, and returns them ordered by score in descending order.

Question 11

CALL algo.louvain(‘Person’, ‘KNOWS’)
YIELD nodeId, community
RETURN algo.asNode(nodeId).name AS name, community
ORDER BY community

Answer 11

Runs the Louvain community detection algorithm on the “Person” nodes connected by “KNOWS” relationships, yielding the node IDs and their respective communities, and returns the names and communities ordered by community.

Question 12

CREATE FULLTEXT INDEX person_name_fulltext FOR (n:Person) ON EACH [n.name];

Answer 12

This command creates a full-text index named person_name_fulltext on the name property of nodes labeled Person, allowing efficient text-based searches in Neo4j

Question 13

CALL db.index.fulltext.queryNodes(“PersonIndex”, “Alice”)
YIELD node
RETURN node

Answer 13

Performs a full-text search query for “Alice” on the “PersonIndex” and returns the matching nodes.

Question 14

MATCH (n:Person)
RETURN count(n) AS totalPeople, avg(n.age) AS averageAge

Answer 14

Counts the total number of “Person” nodes and calculates the average age of the “Person” nodes.

Question 15

LOAD CSV WITH HEADERS FROM ‘file:///persons.csv’ AS row
CREATE (p:Person {name: row.name, age: toInteger(row.age)})

Answer 15

Loads data from a CSV file named ‘persons.csv’, and for each row, creates a “Person” node with the name and age properties from the CSV.

Question 16

CALL apoc.export.csv.query(“MATCH (n:Person) RETURN n”, “persons_export.csv”, {})

Answer 16

Exports the result of the query matching all “Person” nodes to a CSV file named ‘persons_export.csv’.

Question 17

CREATE CONSTRAINT ON (p:Person) ASSERT p.name IS UNIQUE

Answer 17

Creates a constraint on the “Person” nodes to ensure that the “name” property is unique.

Question 18

CREATE INDEX city_name_index FOR (c:City) ON (c.name);

Answer 18

Creates an index on the “name” property of the “Person” nodes to improve query performance.

Question 19

CALL apoc.help(“text”)

Answer 19

Calls the APOC (A Package Of Components) help procedure to get information about available APOC functions related to “text”.

Question 20

@Procedure(value = “example.customProcedure”)
public Stream<Node> customProcedure() {
// Implementation
}</Node>

Answer 20

Defines a user-defined procedure in Java named “example.customProcedure” that can be deployed and called within Neo4j.

Question 21

What is the Louvain community detection algorithm?

Answer 21

The Louvain community detection algorithm is a method used to identify communities in large networks by maximizing modularity, which measures the strength of division of a network into clusters. It is an iterative algorithm that groups nodes into communities and then aggregates these communities into a new network, repeating the process until the modularity cannot be increased further.

Question 22

What is the PageRank algorithm?

Answer 22

The PageRank algorithm is a ranking algorithm used to determine the importance of nodes in a graph based on the structure of incoming links. It was originally developed by Google to rank web pages in search engine results. The algorithm assigns a probability distribution to each node, representing the likelihood of visiting that node, and iteratively updates these probabilities based on the links from other nodes. Nodes with higher incoming links from important nodes are ranked higher.

Question 23

Create a node with the label Person and set the properties name to ‘Alice’ and age to 30.

Answer 23

CREATE (n:Person {name: ‘Alice’, age: 30}) RETURN n

Question 24

Create a relationship APPEARS_IN between two existing nodes with labels Actor and Movie, where the actor’s name is ‘Tom Hanks’ and the movie’s title is ‘Forrest Gump’.

Answer 24

MATCH (a:Actor {name: ‘Tom Hanks’}), (m:Movie {title: ‘Forrest Gump’})
CREATE (a)-[:APPEARS_IN]->(m)

Question 25

Find all nodes with the label Person and return their names and ages.

Answer 25

MATCH (n:Person)
RETURN n.name, n.age

Question 26

Update the property age to 35 for a node with the label Person and the name ‘Bob’.

Answer 26

MATCH (n:Person {name: ‘Bob’})
SET n.age = 35

Question 27

Delete a relationship FRIENDS_WITH between two nodes with the label Person, where one person’s name is ‘Alice’ and the other’s name is ‘Bob’.

Answer 27

MATCH (a:Person {name: ‘Alice’})-[r:FRIENDS_WITH]->(b:Person {name: ‘Bob’})
DELETE r

Question 28

Return the shortest path between two nodes with the label Person, where one person’s name is ‘Alice’ and the other’s name is ‘Bob’.

Answer 28

MATCH (a:Person {name: ‘Alice’}), (b:Person {name: ‘Bob’})
MATCH p = shortestPath((a)-[*]-(b))
RETURN p

Question 29

Create a unique constraint on the email property for nodes with the label User.

Answer 29

CREATE CONSTRAINT FOR (u:User) REQUIRE u.email IS UNIQUE

Question 30

Load data from a CSV file named ‘movies.csv’ and create nodes with the label Movie using the data in the CSV file.

Answer 30

LOAD CSV WITH HEADERS FROM ‘file:///movies.csv’ AS row
CREATE (m:Movie {title: row.title, releaseYear: toInteger(row.releaseYear)})

Question 31

Remove the age property from nodes with the label Person and the name ‘Alice’.

Answer 31

MATCH (n:Person {name: ‘Alice’})
REMOVE n.age

Question 32

Create an index on the name property for nodes with the label City.

Answer 32

CREATE INDEX city_name_index FOR (c:City) ON (c.name);