| 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__ |