FalkorDB/QueryResult.pm untested

filter: Statementstmt 0.0% 0 / 145 Branchbran 0.0% 0 / 64 Conditioncond 0.0% 0 / 66 MC/DCmcdc 0.0% 0 / 33 Subroutinesub 0.0% 0 / 32 Podpod 0.0% 0 / 26 totaltotal 0.0% 0 / 366 CC 33 SCAR 34.0
CC
33
Cov
0%
_parse_stats
110.0
new_from_raw
42.0
_parse_cell
42.0
CRAP 29.9
1 package FalkorDB::QueryResult;
2  
3 use strict;
4 use warnings;
5 use FalkorDB::Node;
6 use FalkorDB::Edge;
7 use Scalar::Util qw(looks_like_number);
8 use FalkorDB::Path;
9  
10 sub new {
11 my ( $class, %args ) = @_;
12 my $self = bless \%args, $class;
13 $self->_parse_stats();
14 return $self;
15 }
16  
17 sub header { shift->{header} }
18 sub result_set { shift->{result_set} }
19 sub stats { shift->{stats} }
20  
21 sub labels_added { shift->{labels_added} || 0 }
22 sub nodes_created { shift->{nodes_created} || 0 }
23 sub nodes_deleted { shift->{nodes_deleted} || 0 }
24 sub properties_set { shift->{properties_set} || 0 }
25 sub relationships_created { shift->{relationships_created} || 0 }
26 sub relationships_deleted { shift->{relationships_deleted} || 0 }
27 sub cached_execution { shift->{cached_execution} || 0 }
28 sub internal_execution_time { shift->{internal_execution_time} || 0 }
29  
30 sub row_count {
31 my ($self) = @_;
32 return scalar @{ $self->{result_set} || [] };
33 }
34  
35 sub get_row {
36 my ( $self, $idx ) = @_;
37 return $self->{result_set}->[$idx];
38 }
39  
40 sub next_row {
41 my ($self) = @_;
42 $self->{_iterator_idx} //= 0;
43 if ( $self->{_iterator_idx} < $self->row_count ) {
44 return $self->{result_set}->[ $self->{_iterator_idx}++ ];
45 }
46 return;
47 }
48  
49 sub reset_iterator {
50 my ($self) = @_;
51 $self->{_iterator_idx} = 0;
52 }
53  
54 sub hashes {
55 my ($self) = @_;
56 my $header = $self->header;
57 my $result_set = $self->result_set;
58 my @hashes;
59 for my $row (@$result_set) {
60 my %hash;
61 for my $i ( 0 .. $#$header ) {
62 $hash{ $header->[$i] } = $row->[$i];
63 }
64 push @hashes, \%hash;
65 }
66 return \@hashes;
67 }
68  
69 sub next_hash {
70 my ($self) = @_;
71 my $row = $self->next_row();
72 return unless $row;
73 my $header = $self->header;
74 my %hash;
75 for my $i ( 0 .. $#$header ) {
76 $hash{ $header->[$i] } = $row->[$i];
77 }
78 return \%hash;
79 }
80  
81 # --- Parsing logic ---
82  
83 sub new_from_raw {
84 my ( $class, $raw_res ) = @_;
85  
86 my ( $header, $rows, $stats );
87 if ( ref $raw_res eq 'ARRAY' ) {
88 if ( @$raw_res == 1 ) {
89 $stats = $raw_res->[0];
90 $header = [];
91 $rows = [];
92 }
93 elsif ( @$raw_res == 3 ) {
94 $header = $raw_res->[0];
95 $rows = $raw_res->[1];
96 $stats = $raw_res->[2];
97 }
98 else {
99 $stats = [];
100 $header = [];
101 $rows = [];
102 }
103 }
104  
105 my @processed_rows;
106 if ( ref $rows eq 'ARRAY' ) {
107 for my $row (@$rows) {
108 my @processed_row;
109 if ( ref $row eq 'ARRAY' ) {
110 for my $cell (@$row) {
111 push @processed_row, _parse_cell($cell);
112 }
113 }
114 else {
115 push @processed_row, _parse_cell($row);
116 }
117 push @processed_rows, \@processed_row;
118 }
119 }
120  
121 return $class->new(
122 header => $header || [],
123 result_set => \@processed_rows,
124 stats => $stats || [],
125 );
126 }
127  
128 sub _parse_cell {
129 my ($val) = @_;
130  
131 if ( _is_node($val) ) {
132 return FalkorDB::Node->new_from_resp($val);
133 }
134 elsif ( _is_edge($val) ) {
135 return FalkorDB::Edge->new_from_resp($val);
136 }
137 elsif ( _is_path($val) ) {
138 return FalkorDB::Path->new_from_string($val);
139 }
140 elsif ( defined $val && !ref $val && $val =~ /^\[.*\]$/ ) {
141 return _parse_array_string($val);
142 }
143 elsif ( ref $val eq 'ARRAY' ) {
144 return [ map { _parse_cell($_) } @$val ];
145 }
146 else {
147 return $val;
148 }
149 }
150  
151 sub _is_node {
152 my ($val) = @_;
153 return unless ref $val eq 'ARRAY' && @$val == 3;
154 my %keys = map { ref $_ eq 'ARRAY' ? ( $_->[0] => 1 ) : () } @$val;
155 return $keys{id} && $keys{labels} && $keys{properties};
156 }
157  
158 sub _is_edge {
159 my ($val) = @_;
160 return unless ref $val eq 'ARRAY' && @$val == 5;
161 my %keys = map { ref $_ eq 'ARRAY' ? ( $_->[0] => 1 ) : () } @$val;
162 return
163 $keys{id}
164 && $keys{type}
165 && $keys{src_node}
166 && $keys{dest_node}
167 && $keys{properties};
168 }
169  
170 sub _is_path {
171 my ($val) = @_;
172 return unless defined $val && !ref $val;
173 return $val =~ /^\[\s*(\(\d+\)|\[\d+\])(?:\s*,\s*(\(\d+\)|\[\d+\]))*\s*\]$/;
174 }
175  
176 sub _parse_array_string {
177 my ($str) = @_;
178 if ( $str =~ /^\[(.*)\]$/ ) {
179 my $content = $1;
180 return [] if $content =~ /^\s*$/;
181 my @elements = split /,\s*/, $content;
182 for my $el (@elements) {
183 $el =~ s/^['"]//;
184 $el =~ s/['"]$//;
185 if ( looks_like_number($el) ) {
186 $el = 0 + $el;
187 }
188 }
189 return \@elements;
190 }
191 return;
192 }
193  
194 sub _parse_properties {
195 my ($props_array) = @_;
196 my %props;
197 if ( ref $props_array eq 'ARRAY' ) {
198 for my $pair (@$props_array) {
199 if ( ref $pair eq 'ARRAY' && @$pair == 2 ) {
200 my ( $k, $v ) = @$pair;
201 if ( defined $v && !ref $v && $v =~ /^\[.*\]$/ ) {
202 $v = _parse_array_string($v);
203 }
204 $props{$k} = $v;
205 }
206 }
207 }
208 return \%props;
209 }
210  
211 # --- Statistics Parsing ---
212  
213 sub _parse_stats {
214 my ($self) = @_;
215 my $stats = $self->{stats};
216 return unless ref $stats eq 'ARRAY';
217  
218 for my $stat (@$stats) {
219 if ( $stat =~ /^Labels added:\s*(\d+)/i ) {
220 $self->{labels_added} = 0 + $1;
221 }
222 elsif ( $stat =~ /^Nodes created:\s*(\d+)/i ) {
223 $self->{nodes_created} = 0 + $1;
224 }
225 elsif ( $stat =~ /^Nodes deleted:\s*(\d+)/i ) {
226 $self->{nodes_deleted} = 0 + $1;
227 }
228 elsif ( $stat =~ /^Properties set:\s*(\d+)/i ) {
229 $self->{properties_set} = 0 + $1;
230 }
231 elsif ( $stat =~ /^Relationships created:\s*(\d+)/i ) {
232 $self->{relationships_created} = 0 + $1;
233 }
234 elsif ( $stat =~ /^Relationships deleted:\s*(\d+)/i ) {
235 $self->{relationships_deleted} = 0 + $1;
236 }
237 elsif ( $stat =~ /^Cached execution:\s*(\d+)/i ) {
238 $self->{cached_execution} = 0 + $1;
239 }
240 elsif ( $stat =~ /^Query internal execution time:\s*([\d\.]+)/i ) {
241 $self->{internal_execution_time} = 0 + $1;
242 }
243 }
244 }
245  
246 1;
247 __END__