Australian National University

Wenyi Pi

#### Neo4j APOC Library Use Case

<figure>
<img src="https://cdn-images-1.medium.com/max/978/0*rIcW439yt0M1I_TQ" />
<figcaption>Image created in <a
href="https://www.canva.com/">https://www.canva.com/</a></figcaption>
</figure>

### **Author**

- Wenyi Pi (**ORCID:**
 [0009--0002--2884--277](https://orcid.org/0009-0002-2884-2771))

### **Introduction**

In the realm of Neo4j, the APOC (Awesome Procedures on Cypher) library
stands as a powerful tool. Previously, We have talked about the
importance of APOC in optimising Cypher queries and improving query
efficiency in our article [Exploring Methods of Cypher Query
Optimisations](https://medium.com/@researchgraph/exploring-methods-of-cypher-query-optimisations-7b03e08b24c4).
This article delves deeper into some important functions available
within the APOC library.

Developed as a core library supported by Neo4j, APOC serves as a
standard utility library, offering access to various common procedures
and functions. Beyond simply improving query efficiency, APOC extends
Cypher queries' scope into broader areas such as data integration, graph
algorithms, and data conversion.

### **Installation**

1. Neo4j Desktop

after creating a Project and a DBMS(Database Management System), click
on the DBMS and you will find the **Plugins** tab. Look for the
**APOC **tab

<figure>
<img
src="https://cdn-images-1.medium.com/max/1000/0*B0JC1RggnURFLJnO" />
</figure>

Then click on APOC to expand more and click the install button

<figure>
<img src="https://cdn-images-1.medium.com/max/692/0*VZazDX5Y7UllMOQ4" />
</figure>

2\. Neo4j Server

APOC depends on the internal API for Neo4j. In Neo4j, you need to use
the **matching APOC version** to ensure that the first two version
numbers between Neo4j and APOC match.

<figure>
<img src="https://cdn-images-1.medium.com/max/924/0*GXKgOzgnfw1uE_kG" />
</figure>

Choose the right version and install.

For more details, please check the [APOC
Installation](https://neo4j.com/labs/apoc/4.1/installation/?utm_source=Google&utm_medium=PaidSearch&utm_campaign=Evergreenutm_content=APAC-Search-SEMCE-DSA-None-SEM-SEM-NonABM&utm_term=&utm_adgroup=DSA-use-cases&gad_source=1&gclid=Cj0KCQjwqdqvBhCPARIsANrmZhNexhzMDuQzOnqxnhd9EluIJm1SCZsVDgw1UCTZTHPeU8_uA63GVpcaAgQDEALw_wcB)
documentation.

### **Common features**

With over 450 standard procedures, APOC provides rich functionality
covering utilities, conversions, graph updates, and more. These
procedures are well-supported and highly deployable, whether used as
separate functions or integrated into Cypher queries.

You can find an introduction guide in [APOC User
Guide](https://neo4j.com/docs/apoc/current/) documentation

#### **Import and export**

The APOC library supports importing various data formats including JSON,
HTML, XML, CSV, and XLS to the Neo4j database. It also supports
exporting data into various data formats, including JSON, CSV, GraphML,
Excel, Gephi, and Cypher script.

#### **Data integration**

The APOC library supports integration with other databases, including
relational databases (via JDBC ***apoc.load.jdbc***), MongoDB, Elastic,
and Couchbase. It also supports importing data from LDAP directories
(via ***apoc.load.ldap***) and executing queries against other Neo4j
databases such as bolt procedures via bolt protocol. It also allows for
database modelling (via ***apoc.model.jdbc***) to extract metadata
information by any JDBC compatible database.

#### **Data structure**

The APOC library provides functions and procedures for operating data
structures, which are mainly divided into three types, namely Conversion
Functions, Map Functions, and Collection Functions. The conversion
function is used to cast the "Any" value to a specific type, it is
mainly located under the ***apoc.convert*** package.

The mapping function is used to operate the map type, it mainly resides
in the ***apoc.map*** package. The collection function is used to
operate collections and lists, mainly under the ***apoc.coll*** package.

#### **Temporal (Date Time)**

APOC library adds support for formatting time types, timestamps, and
date string values, mainly under the ***apoc.temporal*** and
***apoc.date*** packages.

#### **Mathematical**

APOC provides functions and procedures for mathematical operations,
including math functions (including rounding, maximum and minimum
values, etc.), exact math, number format conversion functions, and
bitwise operation functions. The mathematical operation function is
mainly located in the ***apoc.math*** package, the exact math
calculation function is located in the ***apoc.number.exact*** package,
the number format conversion function is located in the
***apoc.number*** package, and the bitwise operation is located in the
***apoc.bitwise*** package

#### **Advanced Graph Querying**

The advanced graph query provided by APOC library includes: path
expander (***apoc.path****)*, neighbour function (***apoc.neighbors***),
path manipulation (***apoc.path****)*, relationship querying
(***apoc.rel****)*, node querying (***apoc.nodes***), parallel node
search (***apoc.search****)*, etc.

#### **Cypher Execution**

- **Running Cypher fragments**: provide a safe, graph-aware, partially
 compiled scripting Cypher language within APOC (***apoc.cypher***)
- **Conditional Cypher Execution**: simulate an if / else structure.
- **Timeboxed Cypher statements**: terminate a cypher statement with a
 given threshold.
- **Run multiple Statements**: run each semicolon separated statement
- **Run Cypher Script Files**: run each statement in the file / each
 file, separated by semicolons
- **Parallel Cypher Execution**: provide parallel execution of Cypher
 statements

### **Examples**

The APOC library showcases its adaptability and effectiveness in real
world application. From node and relationship creation to batch
transactions, APOC offers indispensable functionalities for optimising
workflows and maximising efficiency.

#### **Help Command**

To access the APOC supported procedures and functions：

 call apoc.help('apoc')

#### **Create Nodes and Relationships**

1. Use ***apoc.create*** to create nodes.

- Create a node with dynamic labels:

**apoc.create.node**(\['Label'\], {key:value,...​})

- For example:



 CALL apoc.create.node(["Person", "Actor"], {name: "Tom Hanks"});

<figure>
<img src="https://cdn-images-1.medium.com/max/610/0*Z00M16_STJWDA15s" />
<figcaption>Create a Node Result</figcaption>
</figure>

This will create a **Node** with **Label** "*Person*" and "*Actor*",
**Attribute** "*name*" : "*Tom Hanks*".

- Create multiple node with dynamic labels:

**apoc.create.nodes**(\['Label'\],
\[{key:value,...​},{key:value,...}...\])

2\. Use ***apoc.create.relationship*** to create relationships.

- Create relationship with dynamic rel-type:

**apoc.create.relationship**(person1,'KNOWS',{key:value,...​}, person2)

- For example:



 MATCH (p:Person {name: "Tom Hanks"})
 MATCH (m:Movie {title:"You've Got Mail"})
 CALL apoc.create.relationship(p, "ACTED_IN", {roles:['Joe Fox']}, m)
 YIELD rel
 RETURN rel;

<figure>
<img src="https://cdn-images-1.medium.com/max/692/0*X7y8TtzArKlpjnPU" />
<figcaption>Create Relationship Result</figcaption>
</figure>

This will create a relationship of type "**ACTED_IN**" between the node
representing Tom Hanks (matched as a **Person** node with the name "*Tom
Hanks*") and the movie "*You've Got Mail*" (matched as a **Movie** node
with the title "*You've Got Mail"*). This relationship means that *Tom
Hanks* acted in the movie "*You've Got Mail*" and played the role of
"*Joe Fox*".

#### **Merge Nodes and Relationships**

1. Use ***apoc.merge*** to create nodes.

- Merge nodes with dynamic labels:

**apoc.merge.node**(\['Label'\], identProps:{key:value, ...​},
onCreateProps:{key:value,...​}, onMatchProps:{key:value,...​}})

- For example:



 CALL apoc.merge.node(
 ["Person", "Actor"],
 {name: "Tom Hanks"},
 {created: datetime()},
 {lastSeen: datetime()}
 );

<figure>
<img
src="https://cdn-images-1.medium.com/max/1000/0*Nqo_IDU3GnMsPkX2" />
<figcaption>Merge Result to Create node</figcaption>
</figure>

This will merge an existing node labelled as "*Person*" and "*Actor*"
with the name "*Tom Hanks*" and add properties created and lastseen time
or create a new node with these labels and properties if one does not
already exist.

2\. Use ***apoc.create.relationship*** to merge relationships.

- Create relationship with dynamic rel-type:

**apoc.merge.relationship**(startNode, relType,
identProps:{key:value, ...​}, onCreateProps:{key:value, ...​}, endNode,
onMatchProps:{key:value, ...​})

- For example:



 MATCH (p:Person {name: "Tom Hanks"})
 MATCH (m:Movie {title:"You've Got Mail"})
 CALL apoc.merge.relationship(p, "ACTED_IN",
 {roles:['Joe Fox']},
 {created: datetime()},
 m,
 {lastSeen: datetime()}
 )
 YIELD rel
 RETURN rel;

<figure>
<img src="https://cdn-images-1.medium.com/max/888/0*Uod7ExxBNvpqMfnE" />
</figure>

<figure>
<img src="https://cdn-images-1.medium.com/max/570/0*Mt_1DFB0GdmCFVBi" />
<figcaption>Merge Result with added properties</figcaption>
</figure>

This will merge a relationship between the node representing *Tom Hanks*
and the movie "*You've Got Mail*" with the relationship type
"**ACTED_IN**'' and the role "*Joe Fox* '', adding properties created
and lastseen time.

3\. Use ***apoc.refactor.mergeNodes***

- Merge nodes and relationships together:

**apoc.refactor.mergeNodes**(nodes LIST\<NODE\>, config MAP\<STRING,
ANY\>)

\- Merges the given **LIST\<NODE\>** onto the first **NODE** in the
**LIST\<NODE\>**. All **RELATIONSHIP** values are merged onto that
**NODE** as well.

Supported config properties:

- **Discard**: If a node's property is already set, no changes are made.
 If the node's property is not set yet, the first property in the list
 is written.
- **Override / Overwrite**: The last property in the list is written
 regardless of whether the node's property is already set, overriding
 any existing value.
- **Combine**: If there is only one property in the list, it is set as
 the node's property. If there are multiple properties in the list, an
 array is created, and an attempt is made to combine these values
 together. This may involve value transformation or type coercion.
- **mergeRels**: This parameter controls whether to allow merging
 relationships with the same type and direction. If set to true,
 relationships with the same type and direction will be merged. If set
 to false, these relationships will not be merged.
- **produceSelfRel:** If set to true (default value), any new
 self-relationship will be inserted into the target node. If set to
 false, no new self-relationship will be inserted. Note that this
 parameter is independent of the **mergeRels** configuration and does
 not affect existing self-relationships.
- **preserveExistingSelfRels**: This parameter is only effective when
 mergeRels is set to true. If set to true (default value), existing
 self-relationships in the target node will be preserved; otherwise,
 they will be deleted.
- **singleElementAsArray**: If set to false (default value) and the type
 is combine, setting to true ensures that the result remains as an
 array when merging two arrays, while setting to false makes the result
 a single value when the array size is 1.

#### **Batch Transactions**

1. Use ***apoc.periodic*** to perform periodic or batch operations.

- Run the second statement for each item returned by the first
 statement:

**apoc.periodic.iterate**('statement returning items', 'statement per
item',
{batchSize:1000,iterateList:true,parallel:false,params:{},concurrency:50,retries:0})
YIELD batches, total

- For example:



 CALL apoc.periodic.iterate(
 "MATCH (p:Person) WHERE (p)-[:ACTED_IN]->() RETURN p",
 "SET p:Actor",
 {batchSize:10000, parallel:true})

This will iterate over batches of nodes labelled as "*Person*" who have
acted in any movie, adding the label "*Actor*" to each node in batches
of 10,000 nodes and processing them in parallel.

2\. Use ***apoc.periodic.commit*** to execute a write operation.

- runs the given statement in separate transactions until it returns 0:

**apoc.periodic.commit**(statement,params)

- For example:



 CALL apoc.periodic.commit(
 "MATCH (person:Person)
 WHERE exists(person.city)
 WHERE person limit $limit
 MERGE (person:City {name:person.city})
 MERGE (person)-[:LIVES_IN]->(city)
 REMOVE person.city
 RETURN count(*)",
 {limit:1000});

This will merge a **City** node for each **Person** node with a city
property, create a **LIVES_IN** relationship, remove the city property
from each **Person** node, and return the count of processed nodes,
executed in batches of 1000 nodes until completion.

### **Practical Use Case**

I will use the APOC library to merge duplicate nodes.

Firstly create nodes and relationships:

 CALL apoc.create.nodes(["Dataset"], [{doi:'10.1001/965111',key:'orcid/001',title:'Environmental Impact on Agriculture',source:'orcid.org'},{doi:'10.1001/965111',key:'orcid/002',title:'Environmental Impact on Agriculture',source:'orcid.org'},{doi:'10.1001/965111',key:'orcid/003',title:'Environmental Impact on Agriculture',source:'orcid.org'}]);
 CALL apoc.create.node(["Researcher"], {name: "Amy Jamison"});
 CALL apoc.create.node(["Publication"], {title: "Environment"});
 CALL apoc.create.node(["Grant"], {title: "Research Institution"});

 MATCH (d1:Dataset {key:'orcid/001'})
 MATCH (g:Grant {title: "Research Institution"})
 CALL apoc.create.relationship(d1, "HAS", null, g)
 YIELD rel
 RETURN rel;

 MATCH (d2:Dataset {key:'orcid/002'})
 MATCH (g:Grant {title: "Research Institution"})
 CALL apoc.create.relationship(d2, "HAS", null, g)
 YIELD rel
 RETURN rel;

 MATCH (d3:Dataset {key:'orcid/003'})
 MATCH (g:Grant {title: "Research Institution"})
 CALL apoc.create.relationship(d3, "HAS", null, g)
 YIELD rel
 RETURN rel;

 MATCH (p:Publication {title: "Environment"})
 MATCH (d1:Dataset {key:'orcid/001'})
 CALL apoc.create.relationship(p, "PUBLICATED", null, d1)
 YIELD rel
 RETURN rel;

 MATCH (p:Publication {title: "Environment"})
 MATCH (d2:Dataset {key:'orcid/002'})
 CALL apoc.create.relationship(p, "PUBLICATED", null, d2)
 YIELD rel
 RETURN rel;

 MATCH (p:Publication {title: "Environment"})
 MATCH (d3:Dataset {key:'orcid/003'})
 CALL apoc.create.relationship(p, "PUBLICATED", null, d3)
 YIELD rel
 RETURN rel;

 MATCH (r:Researcher {name: "Amy Jamison"})
 MATCH (d1:Dataset {key:'orcid/001'})
 CALL apoc.create.relationship(r, "OWNED", null, d1)
 YIELD rel
 RETURN rel;

 MATCH (r:Researcher {name: "Amy Jamison"})
 MATCH (d2:Dataset {key:'orcid/002'})
 CALL apoc.create.relationship(r, "OWNED", null, d2)
 YIELD rel
 RETURN rel;

 MATCH (r:Researcher {name: "Amy Jamison"})
 MATCH (d3:Dataset {key:'orcid/003'})
 CALL apoc.create.relationship(r, "OWNED", null, d3)
 YIELD rel
 RETURN rel;

This creates six nodes with three **Dataset** nodes having the same
**doi**, title, and source but different key, along with one
**Researcher**, one **Publication**, and one **Grant** node, and
establishes nine relationships between them.

<figure>
<img
src="https://cdn-images-1.medium.com/max/1000/0*o8xNhjMjJ_des8og" />
<figcaption>Create Node and Relationship</figcaption>
</figure>

Then use the ***apoc.refactor.mergeNodes*** to merge the duplicate
nodes:

 MATCH (n:Dataset)
 WITH n.doi AS doi, collect(n) as nodes
 CALL apoc.refactor.mergeNodes(nodes, {properties: {
 title:'combine',
 source:'combine',
 key:'combine',
 `.*`: 'discard'
 },mergeRels:TRUE})
 YIELD node
 RETURN node

This merges nodes based on their **doi** property while combining
specified properties and discarding all other properties. Any
relationships associated with the merged nodes will also be merged

<figure>
<img
src="https://cdn-images-1.medium.com/max/1000/0*fcozFqWDrTlWJHy2" />
<figcaption>Merge Node and Relationship</figcaption>
</figure>

<figure>
<img
src="https://cdn-images-1.medium.com/max/1000/0*YCa-tZ6IjqgnrsI2" />
<figcaption>Merge table</figcaption>
</figure>

Since I set the key attribute property as combine, that if multiple
nodes being merged have different values for the key property, those
values will be combined into an array and as set **mergeRels** to true
that relationships of the same type and direction will be merged.

If **mergeRels** not set to *True*, the result is like this:

<figure>
<img
src="https://cdn-images-1.medium.com/max/1000/0*0_uNfqOYUD_rbUtZ" />
<figcaption>Merge Result without mergeRels</figcaption>
</figure>

### **Conclusion**

In summary, the APOC library is the cornerstone of Neo4j users, whether
optimising queries, integrating data sources, or performing advanced
graphical analysis. APOC is an important asset in every Neo4j
practitioner's toolkit. It greatly simplifies the development process
and saves a lot of time and effort, providing users with more
flexibility and scalability.

### **References**

- APOC User Guide for neo4j 5 --- APOC documentation (2024) Neo4j Graph
 Data Platform. Available at: <https://neo4j.com/docs/apoc/current/>
- Introduction --- APOC documentation (2024) Neo4j Graph Data Platform.
 Available at: <https://neo4j.com/docs/apoc/current/introduction/>
- Neo4j-contrib (2024) NEO4J-contrib/NEO4J-APOC-procedures: Awesome
 procedures on Cypher for Neo4j --- codenamed 'APOC' . Available at:
 <https://github.com/neo4j-contrib/neo4j-apoc-procedures>.
- Merge nodes --- APOC documentation (2024) Neo4j Graph Data Platform.
 Available at:
 <https://neo4j.com/docs/apoc/current/graph-refactoring/merge-nodes/#_examples> .

![](https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dab999c490b8){width="1"
height="1"}

Neo4j APOC Library Use Case

 Author

Wenyi Pi (

 ORCID:

0009–0002–2884–277)

 Introduction

In the realm of Neo4j, the APOC (Awesome Procedures on Cypher) library stands as a powerful tool. Previously, We have talked about the importance of APOC in optimising Cypher queries and improving query efficiency in our article Exploring Methods of Cypher Query Optimisations.

Introduction to APOC: Enhancing Neo4j Capabilities

Boosting Performance for Knowledge Graphs with Neo4j APOC Library

<figure>
<img
src="https://cdn-images-1.medium.com/max/1000/0*_E8Qac9I9JtIk2bX" />
<figcaption>Image created in <a
href="https://www.canva.com/">https://www.canva.com/</a></figcaption>
</figure>

#### **Author**

- Wenyi Pi (ORCID:
 [0009--0002--2884--2771](https://orcid.org/0009-0002-2884-2771))

### Introduction

A **knowledge graph** (graph database) captures information about main
entities in a domain and the relationships between them. It was an
augmented feature store for connected data which gave access to compute,
access and operationalise structure features. Unlike traditional
databases that use tabular structures, knowledge graph utilise graphs to
organise data into nodes and edges, creating a flexible model. **Neo4j**
is a graph database management system. It embraces a graph-based model,
organising data base nodes, properties and relationships. **Cypher** is
Neo4j's declarative query language to extract useful information from
the knowledge graph. It is like SQL for graphs and was inspired by SQL
so it allows you to focus on what data you want out of the graph.

<figure>
<img
src="https://cdn-images-1.medium.com/max/1000/0*aKhXBjOAOai2mKo_" />
<figcaption>Neo4j graph database. image from
Neo4j website.</figcaption>
</figure>

**Query optimisation** refers to the process of using optimised query
execution to improve database query performance. Simply put, it involves
finding the most efficient way to retrieve data from a database. The
optimisation process includes analysing the query, identifying the most
efficient query and executing the query to retrieve data, therefore
maximising database performance.

Query optimisation is important which has a significant impact on the
database application especially when you have lots of nodes and
relationships in the database. If the query is poor, it can take a long
time to get the data which leads to poor application performance and bad
user experience.

This article aims to explore various ways in which query can be
optimised to perform on the database effectively. It will particularly
focus on the APOC methods and delve into its relevant use case.

### **Background**

#### The lifecycle of a Cypher query

<figure>
<img src="https://cdn-images-1.medium.com/max/976/0*lcjHldBz3D2JbIPh" />
<figcaption>Cypher Query lifecycle. Image from Neo4j,2024 <a
href="https://neo4j.com/docs/cypher-manual/current/planning-and-tuning/execution-plans/">https://neo4j.com/docs/cypher-manual/current/planning-and-tuning/execution-plans/</a></figcaption>
</figure>

A Cypher query starts as a declarative query string which describes the
graph pattern to match in the database. The query string goes through
parsing and rewriting processes. During parsing, the query is broken
down into its constituent parts and validated syntactically. Rewriting
involves optimisations or transformations to the query for efficiency or
correctness. Then the parsed and rewritten query string passes through
the query optimizer (planner) which will produce an optimal plan
(logical plan) in the given current database state. Finally, the logical
plan is turned into a physical plan which specifies the actual
operations and steps that will be executed by the database to retrieve
the data and get the results.

Three things to help understanding Cypher execution:

1. Neo4j database maps the data files from disk to the Page Cache. When
 you execute a query and the data is not in Cache the data will be
 loaded from disk. Query in page cache is faster compared to query
 in disk.
2. When Cypher receives a query, it will compile an execution plan that
 is stored in the Query Cache which will be reused when the same
 query is executed again. However, if the cache exceeds its limits or
 if the data in the database has changed significantly, the plan will
 be removed from the cache.
3. Query runned the first time will be slower than the second time.

Four factors that may slow down query performance:

1. Big results sets: when a query returns a lot of data, it will take
 longer time to finish.
2. Locking: database places locks on nodes and relationships when
 change node values or relationships. when queries writing on the
 same node/relationship, they need to wait for other writes to
 complete.
3. Query load: query load may also be slow if the server has too many
 queries to process at the same time because they have to wait for
 cpu-resources execution.
4. Turning queries: Queries may be slow because the Cypher statement is
 not optimal. The goal of query tuning is to get the lowest possible
 amount of db hits.

#### **Ways to optimise the query**

1. **Using parameters:** Constructing a Cypher query for each request
 every time can lead to suboptimal performance. The problem is the
 Neo4j desktop app crashing after around 1500 requests. When a new
 query is sent to the Neo4j database, it needs to be transformed into
 an execution plan. But Neo4j caches the last 1000 queries for reuse
 so if sending a query that is cached, the optimization can be
 skipped. To solve this problem is to make one query with parameters
 and reuse it for multiple requests. Instead of using the Python for
 loop, this method uses Cypher Unwind and the Python f-string with
 Cypher parameters. The new method does not need to empty the
 database or restart it. This means only the first time the query
 needs to be optimised, after that the cached query could be used.
 This method represents a significant improvement. Constructing a new
 query per request proved to be inefficient and problematic. Using
 the backend function in conjunction with the new method, we can
 successfully process more than 5000 requests that previously crashed
 with the old method.
2. **Not have errors in variable names**: If a Cypher query references
 a variable that has not been properly initialised or defined, it can
 lead to unexpected behaviour like scanning the entire node space,
 searching for matches. This can severely impact query performance,
 especially in large databases.
3. **Try to reduce query working set as soon as possible**: The main
 idea involves using queries that are small enough and constant in
 their shape for caching. Thereby, each query can update from a
 single property to a whole subgraph. Some of this methods are
 described here:

- One method is to use the UNWIND method that turns a batch of data into
 individual rows to achieve this. We can use it to create nodes with
 properties, to merge nodes with properties and lookup relationships.
 For the lookup, we can lookup by id and use a map format to put in the
 id where keys are nodes or relationship-ids. This is more compact and
 faster for id lookup.
- We can also use FOREACH which is used to iterate over all items and
 execute updates for each of them. This can help create data
 dynamically based on inputs.
- Another method is utilising the APOC procedures. The APOC procedure
 library has lots of useful applications, including creating nodes or
 relationships with dynamic labels and properties, batched transactions
 or iteration of updates, functions for creating and manipulating maps
 to be set as properties.

### **Use case of using APOC**

#### Introduction to APOC

APOC library consists of about 450 procedures and it is widely used in
various areas like data integration, graph algorithms or data
conversion.

For apoc library installation: [APOC
Installation](https://neo4j.com/labs/apoc/4.1/installation/?utm_source=Google&utm_medium=PaidSearch&utm_campaign=Evergreenutm_content=APAC-Search-SEMCE-DSA-None-SEM-SEM-NonABM&utm_term=&utm_adgroup=DSA-use-cases&gad_source=1&gclid=Cj0KCQjwqdqvBhCPARIsANrmZhNexhzMDuQzOnqxnhd9EluIJm1SCZsVDgw1UCTZTHPeU8_uA63GVpcaAgQDEALw_wcB)

An introduction guide to: [APOC
User Guide](https://neo4j.com/docs/apoc/current/)

There are some built in procedures in APOC:

<figure>
<img
src="https://cdn-images-1.medium.com/max/1000/0*iBGBeK9wvFr3PNuQ" />
<figcaption>APOC Built in procedures. Source APOC
documentation.</figcaption>
</figure>

I will focus on the periodic method of APOC, built in periodic
procedures of APOC:

<figure>
<img
src="https://cdn-images-1.medium.com/max/1000/0*--BzyROb9Y6nPOvd" />
<figcaption>APOC Built in Periodic procedures. Source APOC
documentation.</figcaption>
</figure>

#### Efficiently Updating and Inserting Data With apoc.periodic.iterate {#efficiently-updating-and-inserting-data-with-apoc.periodic.iterate}

Understand the Cypher query (create 100000 person node)

*Cypher query to create Person:*

 CALL apoc.periodic.iterate(
 "UNWIND range(1,100000) as id RETURN id",
 "CREATE(p:Person{id:id})",
 {batchSize:10000, iterateList:true,parallel:true})

The first statement is the input that is worked on in the second
statement, the second statement is doing the work like updating the
graph, changing the graph or removing things from the graph. "Batch
size" means size of transactions, "iterate list" indicates whether each
batch is executed as a single Cypher transaction or not, "parallel"
means whether to enable parallel execution of batches or not.

To analyse the query result, I will use the PROFILE method which will
execute the query and return results. This can help keep track of how
many rows pass through each operator, and how much each operator needs
to interact with the storage layer and retrieve the necessary data. To
use the PROFILE method in Cypher, simply put a PROFILE word in front of
the query.

Compare the execute time using original method and apoc procedure:

We can find the execution time of APOC is less compared with
old methods.

<figure>
<img
src="https://cdn-images-1.medium.com/max/1000/0*PcAvZNG8pGVkvzYQ" />
<figcaption>Cypher query result with unwind.</figcaption>
</figure>

<figure>
<img
src="https://cdn-images-1.medium.com/max/1000/0*qjOtanFc206ZxFHc" />
<figcaption>Cypher query result with APOC
and Unwind.</figcaption>
</figure>

<figure>
<img
src="https://cdn-images-1.medium.com/max/887/1*3iyOX-SFTICEK2KrpP73pQ.png" />
<figcaption>Execution plan</figcaption>
</figure>

<figure>
<img
src="https://cdn-images-1.medium.com/max/1000/0*LUGSKhfUr_ToJhx0" />
<figcaption>Cypher query result with APOC
and match.</figcaption>
</figure>

<figure>
<img src="https://cdn-images-1.medium.com/max/410/0*jRJAxNb3B9wHLS_s" />
<figcaption>Cypher query result with match.</figcaption>
</figure>

<figure>
<img
src="https://cdn-images-1.medium.com/max/1024/1*skIXdiwKru48d1kKHYPI6g.png" />
<figcaption>Execution plan.</figcaption>
</figure>

The Estimated Rows column details the number of rows that are expected
to be produced by each operator. They are calculated or estimated from
graph statistics and are usually important for the query planner when
formulating and comparing plans. DB hits stand for the work of storage
when trying to get data from the Neo4j database.The main metric
considered is db hits. Execution time is important but that is generally
a result of administrative factors, like bandwidth, memory, and traffic
volume. From these examples, We can see that the APOC method is better
as it has less db hits.

### **Conclusion**

In conclusion, optimising Cypher queries is crucial for improving
database performance, especially in scenarios with large datasets.
Through careful analysis and implementation of optimisation techniques,
we can enhance the efficiency of database applications.

#### **References**

- Apoc.periodic.iterate --- APOC extended documentation (no date) Neo4j
 Graph Data Platform. Available at:
 <https://neo4j.com/labs/apoc/4.3/overview/apoc.periodic/apoc.periodic.iterate/>
- *Basic query tuning example --- cypher manual* (no date) *Neo4j Graph
 Data Platform*. Available at:
 <https://neo4j.com/docs/cypher-manual/current/appendix/tutorials/basic-query-tuning/>
- *Execution plans and query tuning --- cypher manual* (2024) *Neo4j
 Graph Data Platform*. Available at:
 <https://neo4j.com/docs/cypher-manual/current/planning-and-tuning/>
- Hunger, M. (2020) *5 tips & tricks for fast batched updates of graph
 structures with neo4j and cypher*, *Medium*. Available at:
 <https://medium.com/neo4j/5-tips-tricks-for-fast-batched-updates-of-graph-structures-with-neo4j-and-cypher-73c7f693c8cc>
- Shoukat , M. (2024) *Graph data modeling: Building knowledge graph
 from unstructured data using neo4j*, *LinkedIn*. Available at:
 <https://www.linkedin.com/pulse/graph-data-modeling-building-knowledge-from-unstructured-using-tve0f/?trk=article-ssr-frontend-pulse_more-articles_related-content-card>
- Tom, N*.* (2023) *Optimising cypher query using parameters*, *Graph
 Database & Analytics*. Available at:
 <https://neo4j.com/developer-blog/optimize-cypher-query-parameters/>
- Vegter, K. (2018) *Cypher query optimisations*, *Medium*. Available
 at: <https://medium.com/neo4j/cypher-query-optimisations-fe0539ce2e5c>

![](https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7b03e08b24c4){width="1"
height="1"}

Boosting Performance for Knowledge Graphs with Neo4j APOC Library

 Author

Wenyi Pi (ORCID: 0009–0002–2884–2771) Introduction A

 knowledge graph

(graph database) captures information about main entities in a domain and the relationships between them. It was an augmented feature store for connected data which gave access to compute, access and operationalise structure features.

Rogue Scholar Posts

Introduction to APOC: Enhancing Neo4j Capabilities

Exploring Methods of Cypher Query Optimisations