File Coverage

lib/Neo4j/Driver/Record.pm

Criterion	Covered	Total	%
statement	59	59	100.0
branch	20	20	100.0
condition	9	9	100.0
subroutine	13	13	100.0
pod	2	3	100.0
total	103	104	100.0

use v5.12;
use warnings;

package Neo4j::Driver::Record 1.02;
# ABSTRACT: Container for Cypher result values


use Carp qw(croak);
use List::Util qw(first);

use Neo4j::Driver::ResultSummary;


# Check if the given value was created as a number. Older Perls lack stable
# tracking of numbers vs. strings, but a quirk of bitwise string operators
# can be used to determine whether the scalar contains a number (see perlop).
# That isn't quite the same, but it should be good enough for us.
# (original idea from https://github.com/makamaka/JSON-PP/commit/87bd6a4)
sub _SvNIOKp {
	no warnings 'numeric';
	return length( (my $string = '') & shift );
}
*created_as_number = $^V ge v5.36 ? \&builtin::created_as_number : \&_SvNIOKp;


sub get {
	my ($self, $field) = @_;

	if ( ! defined $field ) {
		warnings::warnif ambiguous =>
			sprintf "Ambiguous get() on %s with multiple fields", __PACKAGE__
			if @{$self->{row}} > 1;
		return $self->{row}->[0];
	}

	my $index = $self->{field_names_cache}->{$field};
	return $self->{row}->[$index] if defined $index && length $field;

	# At this point, it looks like the given $field is both a valid name and
	# a valid index, which should be pretty rare.
	# Callers usually specify the field as a literal in the method call, so we
	# can DWIM and disambiguate by using Perl's created_as_number() built-in.

	no if $^V ge v5.36, 'warnings', 'experimental::builtin';
	if ( created_as_number($field) ) {
		croak sprintf "Field %s not present in query result", $field
			unless $field == int $field && $field >= 0 && $field < @{$self->{row}};
		return $self->{row}->[$field];
	}

	my $field_names = $self->{field_names_cache}->{''};
	$index = first { $field eq $field_names->[$_] } 0 .. $#$field_names;
	croak sprintf "Field '%s' not present in query result", $field
		unless defined $index;
	return $self->{row}->[$index];
}


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

	return $self->{hash} if exists $self->{hash};

	my $field_names = $self->{field_names_cache}->{''};
	my %data;
	$data{ $field_names->[$_] } = $self->{row}->[$_] for 0 .. $#$field_names;
	return $self->{hash} = \%data;
}


# Parse the field names (result column keys) provided by the server and
# return them as a hash ref for fast index lookups
sub _field_names_cache {
	my ($result) = @_;

	my $field_names = $result->{columns};
	my $cache = { '' => $field_names };
	for my $index (0 .. $#$field_names) {
		my $name = $field_names->[$index];

		# Create lookup cache for both index and field name to the index.
		# Skip ambiguous index/name pairs.

		if ( exists $cache->{$name} ) {
			delete $cache->{$name};
		}
		else {
			$cache->{$name} = $index;
		}

		if ( exists $cache->{$index} ) {
			delete $cache->{$index};
		}
		else {
			$cache->{$index} = $index;
		}
	}

	return $cache;
}

# The field names (column keys / ex ResultColumns) are stored in a hash ref.
# For each field, there are entries with keys for the name and the column index
# in the result record array. The value is always the column index.
# For example, for `RETURN 1 AS foo`, it would look like this:
#   $cache = { 'foo' => 0, '0' => 0 };

# Exceptionally, index/name collisions can occur (see record-ambiguous.t).
# The field names lookup cache is limited to cases where no ambiguity exists.
# A reference to the original list of field names is kept in
# the entry '' (empty string). Neo4j doesn't allow zero-length
# field names, so '' itself is never ambiguous.


sub summary {
	# uncoverable pod (see consume)
	my ($self) = @_;
	warnings::warnif deprecated => "summary() in Neo4j::Driver::Record is deprecated; use consume() in Neo4j::Driver::Result instead";

	croak 'Summary unavailable for Record retrieved with fetch() or list(); use consume() in Neo4j::Driver::Result' unless $self->{_summary};
	return $self->{_summary};
}


1;

__END__