File Coverage

lib/Neo4j/Driver/Result.pm

Criterion	Covered	Total	%
statement	89	91	97.8
branch	19	20	95.0
condition	14	16	87.5
subroutine	21	21	100.0
pod	8	10	100.0
total	151	158	96.8

use v5.12;
use warnings;

package Neo4j::Driver::Result 1.02;
# ABSTRACT: Result of running a Cypher query (a stream of records)


use Carp qw(croak);

use Neo4j::Driver::Record;
use Neo4j::Driver::ResultSummary;


our $fake_attached = 0;  # 1: simulate an attached stream (only used in testing)


sub new {
	# uncoverable pod (private method)
	my ($class) = @_;

	return bless { buffer => [] }, $class;
}


sub keys {
	my ($self) = @_;

	return @{ $self->{result}->{columns} // [] };
}


sub list {
	my ($self) = @_;

	$self->_fill_buffer;
	$self->{exhausted} = 1;
	return wantarray ? @{$self->{buffer}} : $self->{buffer};
}


sub size {
	my ($self) = @_;

	return scalar @{$self->list};
}


sub single {
	my ($self) = @_;

	croak 'There is not exactly one result record' if $self->size != 1;
	my ($record) = $self->list;
	$record->{_summary} = $self->_summary;
	return $record;
}


sub _as_fully_buffered {
	my ($self) = @_;

	$self->{attached} = $fake_attached;
	return $self if $fake_attached;  # (only used in testing)

	# JSON results are completely available immediately and can be fully
	# buffered right away, avoiding the need to loop through _fetch_next().
	# (also used in Bolt/Jolt testing, $gather_results 1)
	$self->{buffer} = $self->{result}->{data};
	$self->{field_names_cache} = Neo4j::Driver::Record::_field_names_cache( $self->{result} );
	$self->_init_record( $_ ) for @{ $self->{buffer} };
	return $self;
}


sub _fill_buffer {
	my ($self, $minimum) = @_;

	return 0 unless $self->{attached};

	$self->{field_names_cache} //= Neo4j::Driver::Record::_field_names_cache( $self->{result} );

	# try to get at least $minimum records on the buffer
	my $buffer = $self->{buffer};
	my $count = 0;
	my $next = 1;
	while ( (! $minimum || @$buffer < $minimum)
			&& ($next = $self->_fetch_next) ) {
		push @$buffer, $next;
		$count++;
	}

	# _fetch_next was called, but didn't return records => end of stream; detach
	if (! $next) {
		$self->{result}->{stats} = $self->{stream}->update_counts if $self->{stream};
		$self->{cxn} = undef;  # decrease reference count, allow garbage collection
		$self->{stream} = undef;
		$self->{attached} = 0;
	}

	return $count;
}


sub _fetch_next {
	my ($self) = @_;

	# simulate a JSON-backed result stream (only used in testing, $fake_attached 1)
	$self->{json_cursor} //= 0;
	my $record = $self->{result}->{data}->[ $self->{json_cursor}++ ];
	return undef unless $record;  ##no critic (ProhibitExplicitReturnUndef)
	return $self->_init_record( $record );
}


sub fetch {
	my ($self) = @_;

	return if $self->{exhausted};  # fetch() mustn't destroy a list() buffer
	$self->_fill_buffer(2);
	my $next = shift @{$self->{buffer}};
	$self->{exhausted} = ! $next;
	return $next;
}


sub peek {
	my ($self) = @_;

	$self->_fill_buffer(1);
	return scalar $self->{buffer}->[0];
}


sub has_next {
	my ($self) = @_;

	return 0 if $self->{exhausted};
	$self->_fill_buffer(1);
	return scalar @{$self->{buffer}};
}


sub consume {
	my ($self) = @_;

	1 while $self->fetch;  # Exhaust the result stream
	return $self->_summary;
}


sub summary {
	# uncoverable pod (see consume)
	warnings::warnif deprecated => "summary() in Neo4j::Driver::Result is deprecated; use consume() instead";
	&_summary;
}


sub _summary {
	my ($self) = @_;

	$self->_fill_buffer;

	$self->{summary} //= Neo4j::Driver::ResultSummary->new( $self->{result}, $self->{notifications}, $self->{query}, $self->{server_info} );

	return $self->{summary};
}


sub _bool_values {
	no if $^V ge v5.36, 'warnings', 'experimental::builtin';
	if ( $^V ge v5.36 ) {
		return builtin::false(), builtin::true();
	}
	else {
		require JSON::PP;
		return JSON::PP::false(), JSON::PP::true();
	}
}


1;

__END__