Download the PHP package kitlabs/neo4j-php-client without Composer

Neo4j PHP Client and Driver

Control to worlds' most powerful graph database

• Pick and choose your drivers with easy configuration
• Intuitive API
• Extensible
• Designed, built and tested under close supervision with the official neo4j driver team
• Validated with testkit
• Fully typed with psalm
• Bolt, HTTP and auto routed drivers available

See the driver in action

• An implementation of the class movie database. It uses Slim and neo4j-php-client to build an API for the classic movie's example of neo4j.
• An complete implementation of the realworld example. It uses Laravel to implement the real world example project, the mother of all demo apps.
• The friends api for the world's most corny example project leveraging the power of Neo4j.

For some more detailed write-ups you can refer to these blogposts:

• How to build a JSON RESTful API with Neo4j, PHP and Open API
• Building a Web App with Neo4j, AuraDB and PHP
• Connect to Neo4j with PHP
• Enterprise level PHP and Neo4j

Or watch any of these videos.

Start your driving experience in three easy steps

Step 1: install via composer

Find more details here

Step 2: create a client

You have now created a client with bolt, HTTPS and neo4j drivers. The default driver that the client will use is bolt.

Read more about the URLs and how to use them to configure drivers here.

Step 3: run a transaction

Decide how to send your Cypher queries

You can control the driver using three different approaches:

• Auto committed queries (easiest and most intuitive)
• Transaction functions (most portable)
• Unmanaged transactions (for the highest degree of control)

Auto committed queries

Auto committed queries are the most straightforward and most intuitive but have many drawbacks when running complex business logic or within a high availability environment.

Run a simple cypher query

Run a statement object:

Running multiple queries at once

The runStatements method will run all the statements at once. This method is an essential tool to reduce the number of database calls, especially when using the HTTP protocol.

Transaction functions

Transaction functions are the de facto standard when using the driver. It is the most portable as it is resistant to a lot of the pitfalls when first developing with high availability solutions such as Neo4j aura or a cluster.

The driver manages transaction functions:

• It re-executes the function in case of a transient error.
• It commits the transaction on successful execution
• It rolls back the transaction in case of a timeout.
• It routes the execution to a relevant follower or leader server when the neo4j protocol is enabled.

ATTENTION: Because of the automatic retry functionality, the function should produce the same result on subsequent recalls, or in more technical terms: should be idempotent. Always remember this when designing the execution logic within the function.

Some examples:

Unmanaged transactions

If you need lower-level access to the drivers' capabilities, then you want unmanaged transactions. They allow for completely controllable commits and rollbacks.

Opening a transaction

The beginTransaction method will start a transaction with the relevant driver.

Note that beginTransaction only returns the transaction object, not the results of the provided statements.

Running statements within a transaction

The transaction can run statements just like the client object as long as it is still open.

Finish a transaction

Rollback a transaction:

Commit a transaction:

Accessing the results

Results are returned in a standard format of rows and columns:

Cypher values and types map to these php types and classes:

(*) These items can also be used as parameters in the bolt protocol and will automatically be converted by the driver, so they can be used in Cypher.

Besides these examples, \DateTimeInterface will map to DateTimeZoneId in Cypher. An empty or list-type array will be converted to a cypher List, and an associative array will be converted to a map.

(**) A point can be one of four types implementing PointInterface: \Laudis\Neo4j\Types\CartesianPoint \Laudis\Neo4j\Types\Cartesian3DPoint \Laudis\Neo4j\Types\WGS84Point \Laudis\Neo4j\Types\WGS843DPoint

Diving Deeper

Differentiating between parameter type

Cypher has lists and maps. This notion can be problematic as the standard php arrays encapsulate both. When you provide an empty array as a parameter, it will be impossible to determine an empty list or map.

The ParameterHelper class is the ideal companion for this:

Version compatibility matrix

Neo4j Feature Support

In-depth requirements

• PHP >= 7.4
• A Neo4j database (minimum version 3.5)
• ext-bcmath *
• ext-json **
• ext-sockets ***

(*) Needed to implement the bolt protocol

(**) Needed to implement the http protocol

(***) Can be installed for optimal bolt protocol performance

If you plan on using the HTTP drivers, make sure you have psr-7, psr-17 and psr-18 implementations included into the project. If you don't have any, you can install them via composer:

Result formats/hydration

In order to make the results of the bolt protocol and the http uniform, the driver provides result formatters (aka hydrators). The client is configurable with these formatters. You can even implement your own.

The default formatter is the \Laudis\Neo4j\Formatters\OGMFormatter, which is explained extensively in the result format section.

The driver provides three formatters by default, which are all found in the Formatter namespace:

• \Laudis\Neo4j\Formatter\BasicFormatter which erases all the Cypher types and simply returns every value in the resulting map as a scalar, null or array value.
• \Laudis\Neo4j\Formatter\OGMFormatter which maps the cypher types to php types as explained here.
• \Laudis\Neo4j\Formatter\SummarizedResultFormatter which decorates any formatter and adds an extensive result summary.

The client builder provides an easy way to change the formatter:

In order to use a custom formatter, implement the Laudis\Neo4j\Contracts\FormatterInterface and provide it when using the client builder.

Concepts

The driver API described here is the main target of the driver. Because of this, the client is nothing more than a driver manager. The driver creates sessions. A session runs queries through a transaction.

Because of this behaviour, you can access each concept starting from the client like this:

If you need complete control, you can control each object with custom configuration objects.

Client

A client manages drivers and routes the queries to the correct drivers based on preconfigured aliases.

Driver

The driver object is the thread-safe backbone that gives access to Neo4j. It owns a connection pool and can spawn sessions for carrying out work.

Session

Sessions are lightweight containers for causally chained sequences of transactions. They borrow connections from the connection pool as required and chain transactions using bookmarks.

Transaction

Transactions are atomic units of work that may contain one or more query. Each transaction is bound to a single connection and is represented in the causal chain by a bookmark.

Statement

Queries are executable units within transactions and consist of a Cypher string and a keyed parameter set. Each query outputs a result that may contain zero or more records.

Result

A result contains the output from a query, made up of header metadata, content records and summary metadata. In Neo4j 4.0 and above, applications have control over the flow of result data.

In-depth configuration

Url Schemes

The URL scheme is the easiest way to configure the driver.

Configuration format:

Default configuration:

Scheme configuration matrix

This library supports three drivers: bolt, HTTP and neo4j. The scheme part of the url determines the driver.

Configuration objects

A driver, session and transaction can be configured using configuration objects. An overview of the configuration options can be found here:

Code Example: