Neo4j::Driver::Result - Result of running a Cypher statement (a stream of records)


version 0.41


 use Neo4j::Driver;
 $session = Neo4j::Driver->new->basic_auth(...)->session;
 # stream result records
 $result = $session->run('MATCH (a:Actor) RETURN, a.born');
 while ( $record = $result->fetch ) {
 # list result records
 $result = $session->run('MATCH (m:Movie) RETURN, m.year');
 $record_count = $result->size;
 @records = $result->list;
 # shortcut for results with a single record only
 $query = 'MATCH (m:Movie) WHERE id(m) = {id} RETURN';
 $name = $session->run($query, id => 12)->single->get('');


The result of running a Cypher statement, conceptually a stream of records. The result stream can be navigated through using fetch() to consume records one at a time, or be consumed in its entirety using list() to get an array of all records.

Result streams typically are initially attached to the active session. As records are retrieved from the stream, they may be buffered locally in the driver. Once all data on the result stream has been retrieved from the server and buffered locally, the stream becomes detached.

Results received over HTTP always contain the complete list of records, which is kept buffered in the driver. HTTP result streams are thus immediately detached and valid indefinitely.

Result streams received on Bolt are valid until the next statement is run on the same session or (if the result was retrieved within an explicit transaction) until the transaction is closed, whichever comes first. When a result stream has become invalid before it was detached, calling any methods in this class may fail.

To obtain a query result, call "run" in Neo4j::Driver::Transaction.

Until version 0.18, this module was named StatementResult.


Neo4j::Driver::Result implements the following methods.


 while ($record = $result->fetch) {

Navigate to and retrieve the next Record in this result.

When a record is fetched, that record is removed from the result stream. Once all records have been fetched, the result stream is exhausted and fetch() returns undef.


 while ($record = $result->fetch) {
   print $record->get('field');
   print ', ' if $result->has_next;

Whether the next call to fetch() will return a record.

Calling this method may change the internal stream buffer and detach the result, but will never exhaust it.


 @keys = $result->keys;

Retrieve the column names of the records this result contains.


 @records = $result->list;
 $records = $result->list;  # arrayref

Return the entire list of all Records that remain in the result stream. Calling this method exhausts the result stream.

The list is internally buffered by this class. Calling this method multiple times returns the buffered list.

This method returns an array reference if called in scalar context.


 $name = $session->run('... LIMIT 1')->single->get('name');

Return the single Record left in the result stream, failing if there is not exactly one record left. Calling this method exhausts the result stream.

The returned record is internally buffered by this class. Calling this method multiple times returns the buffered record.


 $record_count = $result->size;

Return the count of records that calling list() would yield.

Calling this method exhausts the result stream and buffers all records for use by list().


 $result_summary = $result->summary;

Return a Neo4j::Driver::ResultSummary object. Calling this method detaches the result stream, but does not exhaust it.

As a special case, Records returned by the single method also have a summary method that works the same way.

 $record = $transaction->run('...')->single;
 $result_summary = $record->summary;


Neo4j::Driver::Result implements the following experimental features. These are subject to unannounced modification or removal in future versions. Expect your code to break if you depend upon these features.

Calling in scalar context

 $count = $result->keys;

The keys() method returns the number of columns if called in scalar context.

Until version 0.25, it returned an array reference instead.

Discarding the result stream


Discarding the entire result may be useful as a cheap way to signal to the Bolt networking layer that any resources held by the result may be released. The actual result records are silently discarded without any effort to buffer the results. Calling this method exhausts the result stream.

As a side effect, discarding the result yields a summary of it.

 $result_summary = $result->consume;

Using a result after this method has been called is discouraged. This may become a fatal error in future versions.

All of the official drivers offer this method, but it doesn't appear to be necessary here, since Neo4j::Bolt::ResultStream reliably calls neo4j_close_results() in its DESTROY() method. It may be removed in future versions.

Look ahead in the result stream

 say "Next record: ", $result->peek->get(...) if $result->has_next;

Using peek(), it is possible to retrieve the same record the next call to fetch() would retrieve without actually navigating to it. This may change the internal stream buffer and detach the result, but will never exhaust it.



Arne Johannessen <>

If you contact me by email, please make sure you include the word "Perl" in your subject header to help beat the spam filters.


This software is Copyright (c) 2016-2023 by Arne Johannessen.

This is free software; you can redistribute it and/or modify it under the terms of the Artistic License 2.0 or (at your option) the same terms as the Perl 5 programming language system itself.