Neo4j is the world’s leading Graph Database. It is a high-performance graph store with all the features expected of a mature and robust database, like a friendly query language and ACID transactions. The programmer works with a flexible network structure of nodes and relationships rather than static tables — yet enjoys all the benefits of the enterprise-quality database. For many applications, Neo4j offers orders of magnitude performance benefits compared to relational DBs.

Prerequisites

  • Kubernetes 1.6+ with Beta APIs enabled
  • PV provisioner support in the underlying infrastructure
  • Requires the following variables You must add accept license agreement in the values.yaml file and set it to yes or include –set acceptLicenseAgreement=yes in the command line of helm install to accept the license.

Using Neo4j

Neo4j is available both as a standalone server, or an embeddable component. You can download or try online.

Extending Neo4j

We encourage experimentation with Neo4j. You can build extensions to Neo4j, develop library or drivers atop the product, or make contributions directly to the product core. You’ll need to sign a Contributor License Agreement in order for us to accept your patches.

Note

This GitHub repository contains mixed GPL and AGPL code. Our Community edition (in the community/ directory) is GPLv3. Our Enterprise edition (enterprise/) is differently licensed under the AGPLv3.

Dependencies

Neo4j is built using Apache Maven version 3.3 and a recent version of supported VM. Bash and Make are also required. Note that maven needs more memory than the standard configuration, this can be achieved with export MAVEN_OPTS=”-Xmx512m”.

OS X users need to have Homebrew installed.

Building Neo4j

Before you start running the unit and integration tests in the Neo4j Maven project on a Linux-like system, you should ensure your limit on open files is set to a reasonable value. You can test it with limit -n. We recommend you have a limit of at least 40K.

  • A plain mvn clean install will only build the individual jar files.
  • Test execution is, of course, part of the build.
  • In case you just want the jars, without running tests, this is for you: mvn clean install -DskipTests.
  • To build product packages, do export PATH=” bin:$PATH” && make clean all in the packaging directory after building artifacts with Maven.
  • To build the documentation see the Neo4j documentation.
  • If you are running into problems building on Windows you can try building Neo4j in an Ubuntu virtual machine.
  • You may need to increase the memory available to Maven: export MAVEN_OPTS=”-Xmx512m”.

What is a Graph?

A graph is composed of two elements: a node and a relationship.

Each node represents an entity (a person, place, thing, category or another piece of data), and each relationship represents how two nodes are associated. This general-purpose structure allows you to model all kinds of scenarios – from a system of roads to a network of devices to a population’s medical history or anything else defined by relationships.

What is a Graph Database?

A graph database is an online database management system with Create, Read, Update and Delete (CRUD) operations working on a graph data model.

Unlike other databases, relationships take first priority in graph databases. This means your application doesn’t have to infer data connections using things like foreign keys or out-of-band processing, such as MapReduce.

The data model for a graph database is also significantly simpler and more expressive than those of relational or other NoSQL databases.

Graph databases are built for use with transactional (OLTP) systems and are engineered with transactional integrity and operational availability in mind.

  • There are two important properties of graph database technologies:icon-graph-storage Graph Storage
  • Some graph databases use native graph storage that is specifically designed to store and manage graphs, while others use relational or object-oriented databases instead. Non-native storage is often much more latent.
  • icon-graph-engine Graph Processing Engine
  • Native graph processing (a.k.a. “index-free adjacency”) is the most efficient means of processing graph data since connected nodes physically “point” to each other in the database. Non-native graph processing uses other means to process CRUD operations.

What Are the Advantages of Using a Graph Database?

Tech giants like Google, Facebook, LinkedIn, and PayPal all tapped into the power of graph databases to create booming businesses. Their secret? They each used graph database technology to harness the power of data connections.

A graph database is purpose-built to handle highly connected data, and the increase in the volume and connectedness of today’s data presents a tremendous opportunity for sustained competitive advantage.

Graph databases have three other key advantages:

Performance

For intensive data relationship handling, graph databases improve performance by several orders of magnitude. With traditional databases, relationship queries will come to a grinding halt as the number and depth of relationships increase. In contrast, graph database performance stays constant even as your data grows year after year.

Flexibility

With graph databases, IT and data architect teams move at the speed of business because the structure and schema of a graph model flex as applications and industries change. Rather than exhaustively modeling a domain ahead of time, data teams can add to the existing graph structure without endangering current functionality.

Agility

Developing with graph databases aligns perfectly with today’s agile, test-driven development practices, allowing your graph database to evolve in step with the rest of the application and any changing business requirements. Modern graph databases are equipped for frictionless development and graceful systems maintenance.

Tell us about a new Kubernetes application

Newsletter

Never miss a thing! Sign up for our newsletter to stay updated.

About

Discover and learn about everything Kubernetes

Navigation