neo4j php client

Klien dan driver php neo4j

Kontrol ke database grafik paling kuat di dunia

• Pilih dan pilih driver Anda dengan konfigurasi yang mudah
• API intuitif
• Dapat diperluas
• Dirancang, dibangun dan diuji di bawah pengawasan ketat dengan tim pengemudi NEO4J resmi
• Divalidasi dengan testkit
• Sepenuhnya diketik dengan mazmur
• Bolt, HTTP, dan driver yang dialihkan secara otomatis

Lihat pengemudi yang sedang beraksi

• Implementasi basis data film kelas. Ini menggunakan klien ramping dan neo4j-php untuk membangun API untuk contoh film klasik Neo4j.
• Implementasi lengkap dari contoh RealWorld. Ini menggunakan Laravel untuk mengimplementasikan proyek contoh dunia nyata, ibu dari semua aplikasi demo .
• Teman -teman API untuk proyek contoh paling klise di dunia yang memanfaatkan kekuatan Neo4j.

Untuk beberapa artikel yang lebih rinci, Anda dapat merujuk ke tiang blog ini:

• Cara Membangun API Restful JSON dengan Neo4j, PHP dan Open API
• Membangun Aplikasi Web dengan Neo4j, Auradb dan PHP
• Terhubung ke neo4j dengan php
• Level Enterprise PHP dan NEO4J

Atau tonton salah satu dari video ini.

Mulailah pengalaman berkendara Anda dalam tiga langkah mudah

Langkah 1: Instal via Composer

composer require laudis/neo4j-php-client

Temukan detail lebih lanjut di sini

Langkah 2: Buat klien

 use Laudis  Neo4j  Authentication  Authenticate ;
use Laudis  Neo4j  ClientBuilder ;

$ client = ClientBuilder:: create ()
    -> withDriver ( ' bolt ' , ' bolt+s://user:password@localhost ' ) // creates a bolt driver
    -> withDriver ( ' https ' , ' https://test.com ' , Authenticate:: basic ( ' user ' , ' password ' )) // creates an http driver
    -> withDriver ( ' neo4j ' , ' neo4j://neo4j.test.com?database=my-database ' , Authenticate:: oidc ( ' token ' )) // creates an auto routed driver with an OpenID Connect token
    -> withDefaultDriver ( ' bolt ' )
    -> build ();

Anda sekarang telah membuat klien dengan driver Bolt, HTTPS dan NEO4J . Driver default yang akan digunakan klien adalah Bolt .

Baca lebih lanjut tentang URL dan cara menggunakannya untuk mengkonfigurasi driver di sini.

Langkah 3: Jalankan transaksi

 use Laudis  Neo4j  Contracts  TransactionInterface ;

$ result = $ client -> writeTransaction ( static function ( TransactionInterface $ tsx ) {
    $ result = $ tsx -> run ( ' MERGE (x {y: "z"}:X) return x ' );
    return $ result -> first ()-> get ( ' x ' )[ ' y ' ];
});

echo $ result ; // echos 'z' 

Putuskan cara mengirim kueri cypher Anda

Anda dapat mengontrol driver menggunakan tiga pendekatan berbeda:

• Kueri berkomitmen otomatis (termudah dan paling intuitif)
• Fungsi transaksi (paling portabel)
• Transaksi yang tidak dikelola (untuk tingkat kontrol tertinggi)

Kueri berkomitmen otomatis

Kueri yang berkomitmen otomatis adalah yang paling mudah dan paling intuitif tetapi memiliki banyak kelemahan saat menjalankan logika bisnis yang kompleks atau dalam lingkungan ketersediaan yang tinggi.

Jalankan kueri cypher sederhana

 $ client -> run (
    ' MERGE (user {email: $email}) ' , //The query is a required parameter
    [ ' email ' => ' [email protected] ' ],  //Requests can be optionally added
    ' backup ' //The default connection can be overridden
);

Jalankan objek pernyataan:

 use Laudis  Neo4j  Databags  Statement ;

$ statement = new Statement ( ' MERGE (user {email: $email}) ' , [ ' email ' => ' [email protected] ' ]);
$ client -> runStatement ( $ statement , ' default ' );

Menjalankan beberapa kueri sekaligus

Metode runStatements akan menjalankan semua pernyataan sekaligus. Metode ini adalah alat penting untuk mengurangi jumlah panggilan database, terutama saat menggunakan protokol HTTP.

 use Laudis  Neo4j  Databags  Statement ;

$ results = $ client -> runStatements ([
    Statement:: create ( ' MATCH (x) RETURN x LIMIT 100 ' ),
    Statement:: create ( ' MERGE (x:Person {email: $email}) ' , [ ' email ' => ' [email protected] ' ])
]);

Fungsi transaksi

Fungsi transaksi adalah standar de facto saat menggunakan driver. Ini adalah yang paling portabel karena tahan terhadap banyak jebakan ketika pertama kali berkembang dengan solusi ketersediaan tinggi seperti neo4j aura atau cluster.

Pengemudi mengelola fungsi transaksi:

• Ini mengeksekusi ulang fungsi jika terjadi kesalahan sementara.
• Itu melakukan transaksi pada eksekusi yang berhasil
• Itu menggulung kembali transaksi jika terjadi batas waktu.
• Ini merutekan eksekusi ke pengikut atau server pemimpin yang relevan ketika protokol NEO4J diaktifkan.

Perhatian: Karena fungsionalitas coba lagi otomatis, fungsi harus menghasilkan hasil yang sama pada penarikan berikutnya, atau dalam istilah yang lebih teknis: harus idempoten . Selalu ingat ini saat merancang logika eksekusi dalam fungsi.

Beberapa contoh:

 use Laudis  Neo4j  Contracts  TransactionInterface ;

// Do a simple merge and return the result
$ result = $ client -> writeTransaction ( static function ( TransactionInterface $ tsx ) {
    $ result = $ tsx -> run ( ' MERGE (x {y: "z"}:X) return x ' );
    return $ result -> first ()-> get ( ' x ' )[ ' y ' ];
});

// Will result in an error
$ client -> readTransaction ( static function ( TransactionInterface $ tsx ) {
    $ tsx -> run ( ' MERGE (x {y: "z"}:X) return x ' );
});

// This is a poorly designed transaction function
$ client -> writeTransaction ( static function ( TransactionInterface $ tsx ) use ( $ externalCounter ) {
    $ externalCounter -> incrementNodesCreated ();
    $ tsx -> run ( ' MERGE (x {y: $id}:X) return x ' , [ ' id ' => Uuid:: v4 ()]);
});

// This achieves the same effect but is safe in case it should be retried. The function is now idempotent.
$ id = Uuid:: v4 ();
$ client -> writeTransaction ( static function ( TransactionInterface $ tsx ) use ( $ id ) {
    $ tsx -> run ( ' MERGE (x {y: $id}:X) return x ' , [ ' id ' => $ id ]);
});
$ externalCounter -> incrementNodesCreated ();

Transaksi yang tidak dikelola

Jika Anda memerlukan akses tingkat rendah ke kemampuan pengemudi, maka Anda ingin transaksi yang tidak dikelola. Mereka memungkinkan komitmen dan rollback yang sepenuhnya terkendali.

Membuka transaksi

Metode beginTransaction akan memulai transaksi dengan driver yang relevan.

 use Laudis  Neo4j  Databags  Statement ;

$ tsx = $ client -> beginTransaction (
    // This is an optional set of statements to execute while opening the transaction
    [Statement:: create ( ' MERGE (x:Person({email: $email}) ' , [ ' email ' => ' [email protected] ' ])],
    ' backup ' // This is the optional connection alias
);

Perhatikan bahwa beginTransaction hanya mengembalikan objek transaksi, bukan hasil dari pernyataan yang disediakan.

Menjalankan pernyataan dalam transaksi

Transaksi dapat menjalankan pernyataan seperti objek klien selama masih terbuka.

 $ result = $ tsx -> run ( ' MATCH (x) RETURN x LIMIT 100 ' );
$ result = $ tsx -> runStatement (Statement:: create ( ' MATCH (x) RETURN x LIMIT 100 ' ));
$ results = $ tsx -> runStatements ([Statement:: create ( ' MATCH (x) RETURN x LIMIT 100 ' )]);

Selesaikan transaksi

Rollback transaksi:

 $ tsx -> rollback ();

Melakukan transaksi:

 $ tsx -> commit ([Statement:: create ( ' MATCH (x) RETURN x LIMIT 100 ' )]);

Mengakses hasilnya

Hasil dikembalikan dalam format standar baris dan kolom:

 // Results are a CypherList
$ results = $ client -> run ( ' MATCH (node:Node) RETURN node, node.id AS id ' );

// A row is a CypherMap
foreach ( $ results as $ result ) {
    // Returns a Node
    $ node = $ result -> get ( ' node ' );

    echo $ node -> getProperty ( ' id ' );
    echo $ result -> get ( ' id ' );
}

Nilai dan Jenis Cypher Peta ke tipe dan kelas PHP ini:

Nol	Php
batal	* null
rangkaian	* string
bilangan bulat	* int
mengambang	* float
Boolean	* bool
Peta	* LaudisNeo4jTypesCypherMap
Daftar	* LaudisNeo4jTypesCypherList
Titik	* LaudisNeo4jContractsPointInterface **
Tanggal	* LaudisNeo4jTypesDate
Waktu	* LaudisNeo4jTypesTime
Waktu setempat	* LaudisNeo4jTypesLocalTime
Datetime	* LaudisNeo4jTypesDateTime
Datetimezoneid	* LaudisNeo4jTypesDateTimeZoneId
LocalDatetime	* LaudisNeo4jTypesLocalDateTime
Lamanya	* LaudisNeo4jTypesDuration
Node	LaudisNeo4jTypesNode
Hubungan	LaudisNeo4jTypesRelationship
Jalur	LaudisNeo4jTypesPath

(*) Barang -barang ini juga dapat digunakan sebagai parameter dalam protokol baut dan secara otomatis akan dikonversi oleh driver, sehingga dapat digunakan di Cypher.

Selain contoh -contoh ini, DateTimeInterface akan memetakan ke DateTimeZoneId di Cypher. array kosong atau tipe daftar akan dikonversi ke List cypher, dan associative array akan dikonversi ke map .

(**) Suatu titik dapat berupa salah satu dari empat tipe yang menerapkan pointinterface: LaudisNeo4jTypesCartesianPoint LaudisNeo4jTypesCartesian3DPoint LaudisNeo4jTypesWGS84Point LaudisNeo4jTypesWGS843DPoint

Menyelam lebih dalam

Membedakan antara jenis parameter

Cypher memiliki daftar dan peta. Gagasan ini bisa bermasalah karena array PHP standar merangkum keduanya. Saat Anda memberikan array kosong sebagai parameter, tidak mungkin untuk menentukan daftar atau peta kosong.

Kelas ParameterHelper adalah teman yang ideal untuk ini:

 use Laudis  Neo4j  ParameterHelper ;

$ client -> run ( ' MATCH (x) WHERE x.slug in $listOrMap RETURN x ' , [ ' listOrMap ' => ParameterHelper:: asList ([])]); // will return an empty CypherList
$ client -> run ( ' MATCH (x) WHERE x.slug in $listOrMap RETURN x ' , [ ' listOrMap ' => ParameterHelper:: asMap ([])]); // will error
$ client -> run ( ' MATCH (x) WHERE x.slug in $listOrMap RETURN x ' , [ ' listOrMap ' => []]); // will return an empty CypherList

Matriks Kompatibilitas Versi

Versi Driver	Versi PHP	Versi neo4j
^2.8	7.4, ^8.0	^3.5, ^4.0
^3.0	^8.0	^4.0, ^5.0

Dukungan fitur NEO4J

Fitur	Didukung?
Otentikasi	Ya
Transaksi	Ya
Protokol HTTP	Ya
Protokol baut	Ya
Gugus	Ya
Aura	Ya
Protokol Jolt	Ya
Bookmark	Ya

Persyaratan mendalam

• PHP> = 7.4
• Database NEO4J (Versi Minimum 3.5)
• ext-bcmath *
• ext-json **
• ext-sockets ***

(*) Diperlukan untuk mengimplementasikan protokol baut

(**) Diperlukan untuk mengimplementasikan protokol HTTP

(***) dapat dipasang untuk kinerja protokol baut yang optimal

Jika Anda berencana menggunakan driver HTTP, pastikan Anda memiliki implementasi PSR-7, PSR-17 dan PSR-18 termasuk dalam proyek. Jika Anda tidak memilikinya, Anda dapat menginstalnya melalui komposer:

composer require nyholm/psr7 nyholm/psr7-server kriswallsmith/buzz

Format Hasil/Hidrasi

Untuk membuat hasil protokol baut dan seragam HTTP, pengemudi memberikan formatters hasil (alias hidrator). Klien dapat dikonfigurasi dengan format ini. Anda bahkan dapat menerapkan sendiri.

Formatter default adalah LaudisNeo4jFormattersOGMFormatter , yang dijelaskan secara luas di bagian format hasil.

Pengemudi menyediakan tiga formatter secara default, yang semuanya ditemukan di formatter namespace:

• LaudisNeo4jFormatterBasicFormatter yang menghapus semua jenis cypher dan cukup mengembalikan setiap nilai dalam peta yang dihasilkan sebagai skalar, nol atau nilai array.
• LaudisNeo4jFormatterOGMFormatter yang memetakan tipe cypher ke tipe php seperti yang dijelaskan di sini.
• LaudisNeo4jFormatterSummarizedResultFormatter yang menghiasi formatter dan menambahkan ringkasan hasil yang luas.

Pembuat klien menyediakan cara mudah untuk mengubah formatter:

 $ client =  Laudis  Neo4j ClientBuilder:: create ()
    -> withFormatter ( Laudis  Neo4j  Formatter SummarizedResultFormatter:: create ())
    -> build ();

/**
 * The client will now return a result, decorated with a summary.
 *
 * @var LaudisNeo4jDatabagsSummarizedResult $results
 */
$ summarisedResult = $ client -> run ( ' MATCH (x) RETURN x ' );

// The summary contains extensive information such as counters for changed values in the database,
// information on the database, potential notifications, timing, a (profiled) plan, the type of query
// and information on the server itself.
$ summary = $ summarisedResult -> getSummary ();
// The result is exactly the same as the default.
$ result = $ summarisedResult -> getResult ();

Untuk menggunakan formatter khusus, terapkan LaudisNeo4jContractsFormatterInterface dan berikan saat menggunakan pembangun klien.

Konsep

API pengemudi yang dijelaskan di sini adalah target utama pengemudi. Karena itu, klien tidak lebih dari manajer pengemudi. Pengemudi membuat sesi. Sesi menjalankan kueri melalui transaksi.

Karena perilaku ini, Anda dapat mengakses setiap konsep mulai dari klien seperti ini:

 use Laudis  Neo4j  ClientBuilder ;

// A builder is responsible for configuring the client on a high level.
$ builder = ClientBuilder:: create ();
// A client manages the drivers as configured by the builder.
$ client = $ builder -> build ();
// A driver manages connections and sessions.
$ driver = $ client -> getDriver ( ' default ' );
// A session manages transactions.
$ session = $ driver -> createSession ();
// A transaction is the atomic unit of the driver where are the cypher queries are chained.
$ transaction = $ session -> beginTransaction ();
// A transaction runs the actual queries
$ transaction -> run ( ' MATCH (x) RETURN count(x) ' );

Jika Anda memerlukan kontrol penuh, Anda dapat mengontrol setiap objek dengan objek konfigurasi khusus.

Klien

Klien mengelola driver dan merutekan kueri ke driver yang benar berdasarkan alias yang telah dikonfigurasi sebelumnya.

Pengemudi

Objek driver adalah tulang punggung yang aman-utas yang memberikan akses ke Neo4j. Ini memiliki kolam koneksi dan dapat menelurkan sesi untuk melakukan pekerjaan.

 use Laudis  Neo4j  Basic  Driver ;
use Laudis  Neo4j  Databags  DriverConfiguration ;

$ driver = Driver:: create (
    uri: ' neo4j://user:mypassword@Localhost:7687 ' ,
    configuration: DriverConfiguration:: create ()-> withUserAgent ( ' MyApp/1.0.0 ' )
);

Sidang

Sesi adalah wadah ringan untuk urutan transaksi yang dirantai secara kausal. Mereka meminjam koneksi dari kumpulan koneksi sesuai kebutuhan dan transaksi rantai menggunakan bookmark .

 use Laudis  Neo4j  Databags  SessionConfiguration ;
use Laudis  Neo4j  Enum  AccessMode ;

$ session = $ driver -> createSession (SessionConfiguration:: create ()
    -> withDatabase ( ' my-database ' )
    -> withAccessMode (AccessMode:: READ ())
);

Transaksi

Transaksi adalah unit atom dari pekerjaan yang mungkin mengandung satu atau lebih permintaan . Setiap transaksi terikat pada satu koneksi dan diwakili dalam rantai kausal dengan bookmark .

Penyataan

Kueri adalah unit yang dapat dieksekusi dalam transaksi dan terdiri dari string cypher dan set parameter kunci. Setiap kueri mengeluarkan hasil yang mungkin mengandung nol atau lebih catatan .

Hasil

Hasilnya berisi output dari kueri , yang terdiri dari metadata header, catatan konten dan ringkasan metadata. Di Neo4J 4.0 dan di atas, aplikasi memiliki kontrol atas aliran data hasil.

Konfigurasi mendalam

Skema URL

Skema URL adalah cara termudah untuk mengonfigurasi driver.

Format Konfigurasi:

 '<scheme>://<user>:<password>@<host>:<port>?database=<database>'

Konfigurasi default:

 bolt://localhost:7687?database=neo4j

Matriks Konfigurasi Skema

Perpustakaan ini mendukung tiga driver: Bolt, HTTP dan Neo4j. Bagian skema dari URL menentukan pengemudi.

pengemudi	skema	Sertifikat yang valid	sertifikat yang ditandatangani sendiri	fungsi
neo4j	neo4j	neo4j+s	neo4j+ssc	Routing sisi klien di atas baut
baut	baut	baut+s	baut+ssc	Server tunggal di atas baut
http	http	https	Dikonfigurasi melalui Implementasi Klien PSR	Server tunggal melalui http

Objek konfigurasi

Driver, sesi, dan transaksi dapat dikonfigurasi menggunakan objek konfigurasi. Gambaran umum opsi konfigurasi dapat ditemukan di sini:

nama	konsep	keterangan	kelas
agen pengguna	pengemudi	Agen pengguna yang digunakan untuk mengidentifikasi klien ke server NEO4J.	DriverConfiguration
HTTP PSR Bindings	pengemudi	Implementasi PSR yang relevan digunakan oleh driver saat menggunakan protokol HTTP.	DriverConfiguration
database	sidang	Database untuk terhubung ke.	SessionConfiguration
mengambil ukuran	sidang	Jumlah baris untuk diambil sekaligus.	SessionConfiguration
mode akses	sidang	Mode default saat mengakses server.	SessionConfiguration
Bookmark	sidang	Bookmark yang digunakan dalam sesi ini. (Eksperimental)	SessionConfiguration
metadata	transaksi	Metadata yang digunakan selama transaksi. (Eksperimental)	TransactionConfiguration
Batas waktu	transaksi	Jumlah waktu maksimum sebelum waktu habis.	TransactionConfiguration

Contoh kode:

 use  Laudis  Neo4j  Databags  DriverConfiguration ;
use Laudis  Neo4j  Databags  SessionConfiguration ;
use Laudis  Neo4j  Databags  TransactionConfiguration ;

$ client =  Laudis  Neo4j ClientBuilder:: create ()
    -> withDefaultDriverConfiguration (DriverConfiguration:: default ()-> withUserAgent ( ' MyApp/1.0.0 ' ))
    -> withDefaultSessionConfiguration (SessionConfiguration:: default ()-> withDatabase ( ' app-database ' ))
    -> withDefaultTransactionConfiguration (TransactionConfiguration:: default ()-> withTimeout ( 5.0 ))
    -> build ();

// The client will run the query on a driver with the provided config,
// which spawns a session with the provided session config
// and runs the query in a transaction with the provided transaction config
$ client -> run ( ' MATCH (x) RETURN count(x) AS count ' );

// More granular control can be achieved by requesting the concepts yourself:
$ tsx = $ client -> getDriver ( ' default ' )
    -> createSession (SessionConfiguration:: default ()-> withDatabase ( ' management-database ' ))
    -> beginTransaction ( null , TransactionConfiguration:: default ()-> withTimeout ( 200 ));

$ tsx -> run ( ' SOME REALLY LONG MANAGEMENT QUERY ' );

$ tsx -> commit ();