Attean/SimpleQueryEvaluator.pm

filter: Statementstmt 40.5% 462 / 1140 Branchbran 21.6% 156 / 720 Conditioncond 14.9% 40 / 267 MC/DCmcdc 12.3% 19 / 154 Subroutinesub 81.3% 61 / 75 Podpod 50.0% 3 / 6 totaltotal 31.3% 741 / 2362 CC 485 SCAR 93.1
CC
485
Cov
31%
__ANON__
32126.5
evaluate
2448.9
__ANON__
918.0
CRAP 11050.0
« Attean/Plan.pm ↑ Summary Attean/QueryPlanner.pm »
1 3 ▶use v5.14;
Subroutine BEGIN: called CC=1 SCAR=0.0
2 3 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
3  
4 =head1 NAME
5  
6 Attean::SimpleQueryEvaluator - Simple query evaluator
7  
8 =head1 VERSION
9  
10 This document describes Attean::SimpleQueryEvaluator version 0.040
11  
12 =head1 SYNOPSIS
13  
14 use v5.14;
15 use Attean;
16 my $algebra = Attean->get_parser('SPARQL')->parse('SELECT * WHERE { ... }');
17 my $active_graph = Attean::IRI->new('http://example.org/');
18 my $e = Attean::SimpleQueryEvaluator->new( model => $model );
19 my $iter = $e->evaluate( $algebra, $active_graph );
20  
21 =head1 DESCRIPTION
22  
23 The Attean::SimpleQueryEvaluator class implements a simple query evaluator that,
24 given an L<Attean::API::Algebra|Attean::API::Query> and a L<Attean::API::Model>
25 object, evaluates the query represented by the algebra using data from the
26 model, and returns a query result.
27  
28 =head1 ATTRIBUTES
29  
30 =over 4
31  
32 =cut
33  
34 3 ▶use Attean::Algebra;
Subroutine BEGIN: called CC=1 SCAR=0.0
35 3 ▶use Attean::Expression;
Subroutine BEGIN: called CC=1 SCAR=0.0
36  
37 3 package Attean::SimpleQueryEvaluator 0.040 {
38 3 ▶ use Moo;
Subroutine BEGIN: called CC=1 SCAR=0.0
39 3 ▶ use Encode qw(encode);
Subroutine BEGIN: called CC=1 SCAR=0.0
40 3 ▶ use Attean::RDF;
Subroutine BEGIN: called CC=1 SCAR=0.0
41 3 ▶ use AtteanX::Functions::CompositeLists;
Subroutine BEGIN: called CC=1 SCAR=0.0
42 3 ▶ use AtteanX::Functions::CompositeMaps;
Subroutine BEGIN: called CC=1 SCAR=0.0
43 3 ▶ use LWP::UserAgent;
Subroutine BEGIN: called CC=1 SCAR=0.0
44 3 ▶ use Scalar::Util qw(blessed);
Subroutine BEGIN: called CC=1 SCAR=0.0
45 3 ▶ use List::Util qw(all any reduce);
Subroutine BEGIN: called CC=1 SCAR=0.0
46 3 ▶ use Types::Standard qw(ConsumerOf InstanceOf Bool Object);
Subroutine BEGIN: called CC=1 SCAR=0.0
47 3 ▶ use URI::Escape;
Subroutine BEGIN: called CC=1 SCAR=0.0
48 3 ▶ use Attean::SPARQLClient;
Subroutine BEGIN: called CC=1 SCAR=0.0
49 3 ▶ use namespace::clean;
Subroutine BEGIN: called CC=1 SCAR=0.0
50  
51 =item C<< model >>
52  
53 The L<Attean::API::Model> object used for query evaluation.
54  
55 =cut
56  
57 3 has 'model' => (is => 'ro', isa => ConsumerOf['Attean::API::Model'], required => 1);
58
59 =item C<< default_graph >>
60  
61 The L<Attean::API::IRI> object representing the default graph in the C<< model >>.
62 The default graph will be excluded from enumeration of graph names for query
63 features such as C<< GRAPH ?g {} >>.
64  
65 =cut
66  
67 3 has 'default_graph' => (is => 'ro', isa => ConsumerOf['Attean::API::IRI'], required => 1);
68  
69 18 ▶ has 'user_agent' => (is => 'rw', isa => InstanceOf['LWP::UserAgent'], default => sub { my $ua = LWP::UserAgent->new(); $ua->agent("Attean/$Attean::VERSION " . $ua->_agent); $ua });
Subroutine __ANON__: called CC=1 SCAR=0.0
70
71 =item C<< request_signer >>
72  
73 If set, used to modify HTTP::Request objects used in evaluating SERVICE calls
74 before the request is made. This may be used to, for example, add cryptographic
75 signature headers to the request. The modification is performed by calling
76 C<< $request_signer->sign( $request ) >>.
77  
78 =cut
79  
80 3 has 'request_signer' => (is => 'rw', isa => Object);
81
82 3 has 'ground_blanks' => (is => 'rw', isa => Bool, default => 0);
83
84 19 ▶ sub BUILD {
Subroutine BUILD: called CC=1 SCAR=0.0
Pod undocumented
85 # Ensure that the CT extensions are registered
86 19 AtteanX::Functions::CompositeLists->register();
87 19 AtteanX::Functions::CompositeMaps->register();
88 }
89
90 =back
91  
92 =head1 METHODS
93  
94 =over 4
95  
96 =item C<< evaluate( $algebra, $active_graph ) >>
97  
98 Returns an L<Attean::API::Iterator> object with results produced by evaluating
99 the query C<< $algebra >> against the evaluator's C<< model >>, using the
100 supplied C<< $active_graph >>.
101  
102 =cut
103  
104 65 ▶ sub evaluate {
Subroutine evaluate: called CC=129 SCAR=78.0
Pod documented
105 65 my $self = shift;
106 65 my $algebra = shift;
107 65 ▶ my $active_graph = shift || Carp::confess "No active-graph passed to Attean::SimpleQueryEvaluator->evaluate";
Condition50%1/2
shift() || Carp::confess('No active-graph passed to Attean::SimpleQueryEvaluator->evaluate')
l!l
650
MC/DC0%0/1
shift() || Carp::confess('No active-graph passed to Attean::SimpleQueryEvaluator->evaluate')
shift()
Truth table50%1/2
A
A= shift()
Aresult
11
00
108 65 my %args = @_;
109
110 65 ▶ Carp::confess "No algebra passed for evaluation" unless ($algebra);
Branch: 1 branch
BranchTrueFalseTotal
unless $algebra 0 65 65
111
112 65 my $expr_eval = Attean::SimpleQueryEvaluator::ExpressionEvaluator->new( evaluator => $self );
113  
114 65 my @children = @{ $algebra->children };
115 65 my ($child) = $children[0];
116 65 ▶ if ($algebra->isa('Attean::Algebra::Query') or $algebra->isa('Attean::Algebra::Update')) {
Branch: 20 branches
BranchTrueFalseTotal
if ($algebra->isa('Attean::Algebra::Query') or $algebra->isa('Attean::Algebra::Update')) { } 0 65 65
elsif ($algebra->isa('Attean::Algebra::BGP')) { } 21 44 65
elsif ($algebra->isa('Attean::Algebra::Distinct') or $algebra->isa('Attean::Algebra::Reduced')) { } 1 43 44
elsif ($algebra->isa('Attean::Algebra::Extend')) { } 2 41 43
elsif ($algebra->isa('Attean::Algebra::Unfold')) { } 0 41 41
elsif ($algebra->isa('Attean::Algebra::Filter')) { } 1 40 41
elsif ($algebra->isa('Attean::Algebra::OrderBy')) { } 3 37 40
elsif ($algebra->isa('Attean::Algebra::Service')) { } 1 36 37
elsif ($algebra->isa('Attean::Algebra::Graph')) { } 3 33 36
elsif ($algebra->isa('Attean::Algebra::Group')) { } 0 33 33
elsif ($algebra->isa('Attean::Algebra::Join')) { } 2 31 33
elsif ($algebra->isa('Attean::Algebra::LeftJoin')) { } 0 31 31
elsif ($algebra->isa('Attean::Algebra::Minus')) { } 0 31 31
elsif ($algebra->isa('Attean::Algebra::Path')) { } 24 7 31
elsif ($algebra->isa('Attean::Algebra::Project')) { } 3 4 7
elsif ($algebra->isa('Attean::Algebra::Slice')) { } 3 1 4
elsif ($algebra->isa('Attean::Algebra::Union')) { } 0 1 1
elsif ($algebra->isa('Attean::Algebra::Ask')) { } 0 1 1
elsif ($algebra->isa('Attean::Algebra::Construct')) { } 1 0 1
elsif ($algebra->isa('Attean::Algebra::Table')) { } 0 0 0
Condition33%1/3
$algebra->isa("Attean::Algebra::Query") or $algebra->isa("Attean::Algebra::Update")
l!l&&r!l&&!r
0065
MC/DC0%0/2
$algebra->isa("Attean::Algebra::Query") or $algebra->isa("Attean::Algebra::Update")
$algebra->isa("Attean::Algebra::Query") $algebra->isa("Attean::Algebra::Update")
Truth table33%1/3
A or B
A= $algebra->isa("Attean::Algebra::Query")B= $algebra->isa("Attean::Algebra::Update")
ABresult
1X1
011
000
117 0 my $dataset = $algebra->dataset;
118 0 my $named = $dataset->{'named'};
119 0 ▶ my @named = (ref($named) eq 'ARRAY') ? @$named : (values %{ $named || {} });
Branch: 1 branch
BranchTrueFalseTotal
ref $named eq 'ARRAY' ? : 0 0 0
Condition0%0/2
$named || {}
l!l
00
MC/DC0%0/1
$named || {}
$named
Truth table0%0/2
A
A= $named
Aresult
11
00
120
121 0 ▶ if (scalar(@named)) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @named) { } 0 0 0
122 0 $args{ available_graphs } = [@named];
123 } else {
124 # no custom dataset
125 }
126  
127  
128 0 return $self->evaluate( $algebra->child, $active_graph, %args ) ;
129 } elsif ($algebra->isa('Attean::Algebra::BGP')) {
130 21 my @triples = @{ $algebra->triples };
131 21 ▶ if (scalar(@triples) == 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @triples == 0) { } 0 21 21
132 0 my $b = Attean::Result->new( bindings => {} );
133 0 return Attean::ListIterator->new(variables => [], values => [$b], item_type => 'Attean::API::Result');
134 } else {
135 21 my @iters;
136 my @new_vars;
137 21 my %blanks;
138 21 foreach my $t (@triples) {
139 24 push(@iters, $self->evaluate_pattern($t, $active_graph, \@new_vars, \%blanks));
140 }
141 21 ▶ while (scalar(@iters) > 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @iters > 1) 3 21 24
142 3 my ($lhs, $rhs) = splice(@iters, 0, 2);
143 3 unshift(@iters, $lhs->join($rhs));
144 }
145 21 ▶ return shift(@iters)->map(sub { shift->project_complement(@new_vars) });
Subroutine __ANON__: called CC=1 SCAR=0.0
146 }
147 ▶ } elsif ($algebra->isa('Attean::Algebra::Distinct') or $algebra->isa('Attean::Algebra::Reduced')) {
Condition66%2/3
$algebra->isa("Attean::Algebra::Distinct") or $algebra->isa("Attean::Algebra::Reduced")
l!l&&r!l&&!r
1043
MC/DC50%1/2
$algebra->isa("Attean::Algebra::Distinct") or $algebra->isa("Attean::Algebra::Reduced")
$algebra->isa("Attean::Algebra::Distinct") $algebra->isa("Attean::Algebra::Reduced")
Truth table66%2/3
A or B
A= $algebra->isa("Attean::Algebra::Distinct")B= $algebra->isa("Attean::Algebra::Reduced")
ABresult
1X1
011
000
148 1 my %seen;
149 1 my $iter = $self->evaluate( $child, $active_graph, %args ) ;
150 4 ▶ return $iter->grep(sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
151 4 my $r = shift;
152 4 my $str = $r->as_string;
153 4 ▶ my $ok = not($seen{ $str }) ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
!$seen{$str} ? : 2 2 4
154 4 $seen{ $str }++;
155 4 return $ok;
156 1 });
157 } elsif ($algebra->isa('Attean::Algebra::Extend')) {
158 2 my $child = $algebra;
159 2 my @extends;
160 my %extends;
161 2 ▶ while ($child->isa('Attean::Algebra::Extend')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($child->isa("Attean::Algebra::Extend")) 2 2 4
162 2 my $expr = $child->expression;
163 2 my $var = $child->variable->value;
164 2 $extends{ $var } = $expr;
165 2 unshift(@extends, $var);
166 2 ($child) = @{ $child->children };
167 }
168 8 ▶ return $self->evaluate( $child, $active_graph, %args ) ->map(sub {
Subroutine __ANON__: called CC=6 SCAR=22.9
169 8 my $r = shift;
170 8 my %extension;
171 my %row_cache;
172 8 foreach my $var (@extends) {
173 8 my $expr = $extends{ $var };
174 8 my $val = $expr_eval->evaluate_expression( $expr, $r, $active_graph, \%row_cache );
175 8 ▶ if (blessed($val) and $val->does('Attean::API::Binding')) {
Branch: 1 branch
BranchTrueFalseTotal
if (builtin::blessed($val) and $val->does("Attean::API::Binding")) 0 8 8
Condition33%1/3
builtin::blessed($val) and $val->does("Attean::API::Binding")
!ll&&!rl&&r
080
MC/DC0%0/2
builtin::blessed($val) and $val->does("Attean::API::Binding")
builtin::blessed($val) $val->does("Attean::API::Binding")
Truth table33%1/3
A and B
A= builtin::blessed($val)B= $val->does("Attean::API::Binding")
ABresult
0X0
100
111
176 # patterns need to be made ground to be bound as values (e.g. TriplePattern -> Triple)
177 0 $val = eval { $val->ground($r) };
178 0 ▶ if ($@) {
Branch: 1 branch
BranchTrueFalseTotal
if ($@) 0 0 0
179 0 $val = undef;
180 }
181 }
182 # warn "Extend error: $@" if ($@);
183 8 ▶ $r = Attean::Result->new( bindings => { $var => $val } )->join($r) if ($val);
Branch: 1 branch
BranchTrueFalseTotal
if $val 8 0 8
184 }
185 8 return $r;
186 2 });
187 } elsif ($algebra->isa('Attean::Algebra::Unfold')) {
188 0 my $expr = $algebra->expression;
189 0 my @vars = map { $_->value } @{ $algebra->variables };
190 0 my ($first, $second);
191 0 $first = $vars[0];
192 0 ▶ if (scalar(@vars) == 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @vars == 2) 0 0 0
193 0 $second = $vars[1];
194 }
195  
196 0 my ($child) = @{ $algebra->children };
197 0 my $iter = $self->evaluate( $child, $active_graph, %args ) ;
198 0 my @results;
199 0 ▶ while (my $r = $iter->next) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $r = $iter->next) 0 0 0
200 0 my %extension;
201 my %row_cache;
202 0 my $val = $expr_eval->evaluate_expression( $expr, $r, $active_graph, \%row_cache );
203 0 my $dt = $val->datatype;
204 0 ▶ if ($dt->value eq $AtteanX::Functions::CompositeLists::LIST_TYPE_IRI) {
Branch: 2 branches
BranchTrueFalseTotal
if ($dt->value eq $AtteanX::Functions::CompositeLists::LIST_TYPE_IRI) { } 0 0 0
elsif ($dt->value eq $AtteanX::Functions::CompositeMaps::MAP_TYPE_IRI) { } 0 0 0
205 0 my @nodes = AtteanX::Functions::CompositeLists::lex_to_list($val);
206 0 foreach my $i (0 .. $#nodes) {
207 0 my $val = $nodes[$i];
208 0 my %bindings;
209 0 ▶ if (defined($val)) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $val) 0 0 0
210 0 ▶ if ($val->does('Attean::API::Binding')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($val->does("Attean::API::Binding")) 0 0 0
211 # patterns need to be made ground to be bound as values (e.g. TriplePattern -> Triple)
212 0 $val = $val->ground($r);
213 }
214 # warn "Unfold error: $@" if ($@);
215 0 ▶ $bindings{$first} = $val if ($val);
Branch: 1 branch
BranchTrueFalseTotal
if $val 0 0 0
216 }
217
218 0 ▶ if (defined($second)) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $second) 0 0 0
219 0 $bindings{$second} = Attean::Literal->integer(1+$i);
220 }
221 0 my $new = Attean::Result->new( bindings => \%bindings )->join($r);
222 0 push(@results, $new);
223 }
224 } elsif ($dt->value eq $AtteanX::Functions::CompositeMaps::MAP_TYPE_IRI) {
225 0 my @nodes = AtteanX::Functions::CompositeMaps::lex_to_map($val);
226 # The namespace map here is used to correctly parse maps with boolean keys like `{true:1}`
227 0 my $p = AtteanX::Parser::Turtle->new();
228 0 ▶ while (my ($key_string, $val) = splice(@nodes, 0, 2)) {
Branch: 1 branch
BranchTrueFalseTotal
if (() = splice(@nodes, 0, 2)) 0 0 0
229 0 my $key = $p->parse_node($key_string); # TODO: this mistakes "true:4" as an attempted prefixname, not a key-value pair
230 0 my %bindings;
231 0 ▶ if (defined($first)) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $first) 0 0 0
232 0 ▶ if ($key->does('Attean::API::Binding')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($key->does("Attean::API::Binding")) 0 0 0
233 # patterns need to be made ground to be bound as values (e.g. TriplePattern -> Triple)
234 0 $key = $key->ground($r);
235 }
236 # warn "Unfold error: $@" if ($@);
237 0 ▶ $bindings{$first} = $key if ($key);
Branch: 1 branch
BranchTrueFalseTotal
if $key 0 0 0
238 }
239  
240 0 ▶ if (defined($second)) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $second) 0 0 0
241 0 ▶ if (blessed($val) and $val->does('Attean::API::Binding')) {
Branch: 1 branch
BranchTrueFalseTotal
if (builtin::blessed($val) and $val->does("Attean::API::Binding")) 0 0 0
Condition0%0/3
builtin::blessed($val) and $val->does("Attean::API::Binding")
!ll&&!rl&&r
000
MC/DC0%0/2
builtin::blessed($val) and $val->does("Attean::API::Binding")
builtin::blessed($val) $val->does("Attean::API::Binding")
Truth table0%0/3
A and B
A= builtin::blessed($val)B= $val->does("Attean::API::Binding")
ABresult
0X0
100
111
242 # patterns need to be made ground to be bound as values (e.g. TriplePattern -> Triple)
243 0 $val = $val->ground($r);
244 }
245 # warn "Unfold error: $@" if ($@);
246 0 ▶ $bindings{$second} = $val if ($val);
Branch: 1 branch
BranchTrueFalseTotal
if $val 0 0 0
247 }
248
249 0 my $new = Attean::Result->new( bindings => \%bindings )->join($r);
250 0 push(@results, $new);
251 }
252 }
253 }
254 0 my %vars = map { $_ => 1 } $iter->variables;
255 0 $vars{$first}++;
256 0 ▶ $vars{$second}++ if defined($second);
Branch: 1 branch
BranchTrueFalseTotal
if defined $second 0 0 0
257 0 return Attean::ListIterator->new(variables => [keys %vars], values => \@results, item_type => 'Attean::API::Result');
258 } elsif ($algebra->isa('Attean::Algebra::Filter')) {
259 # TODO: Merge adjacent filter evaluation so that they can share a row_cache hash (as is done for Extend above)
260 1 my $expr = $algebra->expression;
261 1 my $iter = $self->evaluate( $child, $active_graph, %args ) ;
262 4 ▶ return $iter->grep(sub {
Subroutine __ANON__: called CC=2 SCAR=7.2
263 4 my $t = $expr_eval->evaluate_expression( $expr, shift, $active_graph, {} );
264 # if ($@) { warn "Filter evaluation: $@\n" };
265 4 ▶ return ($t ? $t->ebv : 0);
Branch: 1 branch
BranchTrueFalseTotal
$t ? : 4 0 4
266 1 });
267 } elsif ($algebra->isa('Attean::Algebra::OrderBy')) {
268 3 local($Attean::API::Binding::ALLOW_IRI_COMPARISON) = 1;
269 3 my $iter = $self->evaluate( $child, $active_graph, %args ) ;
270 3 my @rows = $iter->elements;
271 3 my @cmps = @{ $algebra->comparators };
272 3 my @exprs = map { $_->expression } @cmps;
273 3 my @dirs = map { $_->ascending } @cmps;
274 12 my @sorted = map { $_->[0] } sort {
275 12 my ($ar, $avalues) = @$a;
276 12 my ($br, $bvalues) = @$b;
277 12 my $c = 0;
278 12 foreach my $i (0 .. $#cmps) {
279 13 my ($av, $bv) = map { $_->[$i] } ($avalues, $bvalues);
280 # Mirrors code in Attean::Plan::OrderBy->sort_rows
281 13 ▶ if (blessed($av) and $av->does('Attean::API::Binding') and (not(defined($bv)) or not($bv->does('Attean::API::Binding')))) {
Branch: 2 branches
BranchTrueFalseTotal
if (builtin::blessed($av) and $av->does('Attean::API::Binding') and not defined $bv && $bv->does('Attean::API::Binding')) { } 0 13 13
elsif (builtin::blessed($bv) and $bv->does('Attean::API::Binding') and not defined $av && $av->does('Attean::API::Binding')) { } 0 13 13
Condition22%2/9
builtin::blessed($av) and $av->does("Attean::API::Binding") and not defined $bv && $bv->does("Attean::API::Binding")
!ll&&!rl&&r
1300
builtin::blessed($av) and $av->does("Attean::API::Binding")
!ll&&!rl&&r
0130
defined $bv && $bv->does('Attean::API::Binding')
!ll&&!rl&&r
000
MC/DC0%0/4
builtin::blessed($av) and $av->does("Attean::API::Binding") and not defined $bv && $bv->does("Attean::API::Binding")
builtin::blessed($av) $av->does("Attean::API::Binding") defined $bv $bv->does('Attean::API::Binding')
Truth table20%1/5
A and B and not(C && D)
A= builtin::blessed($av)B= $av->does("Attean::API::Binding")C= defined $bvD= $bv->does('Attean::API::Binding')
ABCDresult
0XXX0
10XX0
11110
110X1
11101
282 0 $c = 1;
283 ▶ } elsif (blessed($bv) and $bv->does('Attean::API::Binding') and (not(defined($av)) or not($av->does('Attean::API::Binding')))) {
Condition22%2/9
builtin::blessed($bv) and $bv->does("Attean::API::Binding") and not defined $av && $av->does("Attean::API::Binding")
!ll&&!rl&&r
1300
builtin::blessed($bv) and $bv->does("Attean::API::Binding")
!ll&&!rl&&r
0130
defined $av && $av->does('Attean::API::Binding')
!ll&&!rl&&r
000
MC/DC0%0/4
builtin::blessed($bv) and $bv->does("Attean::API::Binding") and not defined $av && $av->does("Attean::API::Binding")
builtin::blessed($bv) $bv->does("Attean::API::Binding") defined $av $av->does('Attean::API::Binding')
Truth table20%1/5
A and B and not(C && D)
A= builtin::blessed($bv)B= $bv->does("Attean::API::Binding")C= defined $avD= $av->does('Attean::API::Binding')
ABCDresult
0XXX0
10XX0
11110
110X1
11101
284 0 $c = -1;
285 } else {
286 13 ▶ $c = eval { $av ? $av->order($bv) : 1 };
Branch: 1 branch
BranchTrueFalseTotal
$av ? : 13 0 13
287 13 ▶ if ($@) {
Branch: 1 branch
BranchTrueFalseTotal
if ($@) 0 13 13
288 0 $c = 1;
289 }
290 }
291 13 ▶ $c *= -1 if ($dirs[$i] == 0);
Branch: 1 branch
BranchTrueFalseTotal
if $dirs[$i] == 0 5 8 13
292 13 ▶ last unless ($c == 0);
Branch: 1 branch
BranchTrueFalseTotal
unless $c == 0 12 1 13
293 }
294 $c
295 3 } map { my $r = $_; [$r, [map { $expr_eval->evaluate_expression( $_, $r, $active_graph, {} ) } @exprs]] } @rows;
296 3 return Attean::ListIterator->new( values => \@sorted, item_type => $iter->item_type, variables => $iter->variables);
297 } elsif ($algebra->isa('Attean::Algebra::Service')) {
298 1 my $endpoint = $algebra->endpoint->value;
299 1 my ($pattern) = @{ $algebra->children };
300 1 my $sparql = Attean::Algebra::Project->new( variables => [ map { variable($_) } $pattern->in_scope_variables ], children => [ $pattern ] )->as_sparql;
301 1 my $silent = $algebra->silent;
302 1 my $client = $self->new_service_client($endpoint, $silent);
303 1 return $client->query($sparql);
304 } elsif ($algebra->isa('Attean::Algebra::Graph')) {
305 3 my $available_graphs = $args{ available_graphs };
306 3 ▶ my @graphs = ref($available_graphs) ? @$available_graphs : $self->model->get_graphs()->elements;
Branch: 1 branch
BranchTrueFalseTotal
ref $available_graphs ? : 0 3 3
307 3 my %graphs = map { $_->value => 1 } @graphs;
308  
309 3 my $graph = $algebra->graph;
310 3 ▶ if ($graph->does('Attean::API::Term')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($graph->does("Attean::API::Term")) 2 1 3
311 2 ▶ unless (exists $graphs{ $graph->value }) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $graphs{$graph->value}) 0 2 2
312 # graph does not exist in the dataset
313 0 return Attean::ListIterator->new(variables => [], values => [], item_type => 'Attean::API::Result');
314 }
315 2 return $self->evaluate( $child, $graph, %args );
316 }
317
318 1 my @iters;
319 my %vars;
320 1 ▶ while (my $g = shift(@graphs)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $g = shift @graphs) 2 1 3
321 2 ▶ next if ($g->value eq $self->default_graph->value);
Branch: 1 branch
BranchTrueFalseTotal
if $g->value eq $self->default_graph->value 1 1 2
322 1 my $gr = Attean::Result->new( bindings => { $graph->value => $g } );
323 0 ▶ my $iter = $self->evaluate( $child, $g, %args ) ->map(sub { if (my $result = shift->join($gr)) { return $result } else { return } });
Subroutine __ANON__: called CC=2 SCAR=7.6
Branch: 1 branch
BranchTrueFalseTotal
if (my $result = (shift())->join($gr)) { } 4 0 4
324 1 foreach my $v (@{ $iter->variables }) {
325 2 $vars{$v}++;
326 }
327 1 push(@iters, $iter);
328 }
329 1 return Attean::IteratorSequence->new( variables => [keys %vars], iterators => \@iters, item_type => 'Attean::API::Result' );
330 } elsif ($algebra->isa('Attean::Algebra::Group')) {
331 0 my @groupby = @{ $algebra->groupby };
332 0 my $iter = $self->evaluate( $child, $active_graph, %args ) ;
333 0 my %groups;
334 0 ▶ while (my $r = $iter->next) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $r = $iter->next) 0 0 0
335 0 my %vars;
336 my %row_cache;
337 0 my @group_terms = map { $expr_eval->evaluate_expression( $_, $r, $active_graph, \%row_cache ) } @groupby;
338 0 ▶ my $key = join(' ', map { blessed($_) ? $_->as_string : '' } @group_terms);
Branch: 1 branch
BranchTrueFalseTotal
builtin::blessed($_) ? : 0 0 0
339 0 my %group_bindings;
340 0 foreach my $i (0 .. $#group_terms) {
341 0 my $v = $groupby[$i];
342 0 ▶ if (blessed($v) and $v->isa('Attean::ValueExpression') and $v->value->does('Attean::API::Variable') and $group_terms[$i]) {
Branch: 1 branch
BranchTrueFalseTotal
if (builtin::blessed($v) and $v->isa("Attean::ValueExpression") and $v->value->does("Attean::API::Variable") and $group_terms[$i]) 0 0 0
Condition0%0/9
builtin::blessed($v) and $v->isa("Attean::ValueExpression") and $v->value->does("Attean::API::Variable") and $group_terms[$i]
!ll&&!rl&&r
000
builtin::blessed($v) and $v->isa("Attean::ValueExpression") and $v->value->does("Attean::API::Variable")
!ll&&!rl&&r
000
builtin::blessed($v) and $v->isa("Attean::ValueExpression")
!ll&&!rl&&r
000
MC/DC0%0/4
builtin::blessed($v) and $v->isa("Attean::ValueExpression") and $v->value->does("Attean::API::Variable") and $group_terms[$i]
builtin::blessed($v) $v->isa("Attean::ValueExpression") $v->value->does("Attean::API::Variable") $group_terms[$i]
Truth table0%0/5
A and B and C and D
A= builtin::blessed($v)B= $v->isa("Attean::ValueExpression")C= $v->value->does("Attean::API::Variable")D= $group_terms[$i]
ABCDresult
0XXX0
10XX0
110X0
11100
11111
343 0 $group_bindings{$v->value->value} = $group_terms[$i];
344 }
345 }
346 0 ▶ $groups{$key} = [Attean::Result->new( bindings => \%group_bindings ), []] unless (exists($groups{$key}));
Branch: 1 branch
BranchTrueFalseTotal
unless exists $groups{$key} 0 0 0
347 0 push(@{ $groups{$key}[1] }, $r);
348 }
349 0 my @keys = keys %groups;
350 0 ▶ $groups{''} = [Attean::Result->new( bindings => {} ), []] if (scalar(@groupby) == 0 and scalar(@keys) == 0);
Branch: 1 branch
BranchTrueFalseTotal
if scalar @groupby == 0 and scalar @keys == 0 0 0 0
Condition0%0/3
scalar @groupby == 0 and scalar @keys == 0
!ll&&!rl&&r
000
MC/DC0%0/2
scalar @groupby == 0 and scalar @keys == 0
scalar @groupby == 0 scalar @keys == 0
Truth table0%0/3
A and B
A= scalar @groupby == 0B= scalar @keys == 0
ABresult
0X0
100
111
351 0 my $aggs = $algebra->aggregates;
352 0 my @results;
353 my %vars;
354 0 foreach my $key (keys %groups) {
355 0 my %row_cache;
356 0 my ($binding, $rows) = @{ $groups{$key} };
357 0 my $count = scalar(@$rows);
358 0 my %bindings;
359 0 foreach my $i (0 .. $#{ $aggs }) {
360 0 my $name = $aggs->[$i]->variable->value;
361 0 my $term = $expr_eval->evaluate_expression( $aggs->[$i], $rows, $active_graph, {} );
362 # warn "AGGREGATE error: $@" if ($@);
363 0 $vars{$name}++;
364 0 ▶ $bindings{ $name } = $term if ($term);
Branch: 1 branch
BranchTrueFalseTotal
if $term 0 0 0
365 }
366 0 push(@results, Attean::Result->new( bindings => \%bindings )->join($binding));
367 }
368 0 return Attean::ListIterator->new(variables => [keys %vars], values => \@results, item_type => 'Attean::API::Result');
369 } elsif ($algebra->isa('Attean::Algebra::Join')) {
370 2 my ($lhs, $rhs) = map { $self->evaluate( $_, $active_graph, %args ) } @children;
371 2 return $lhs->join($rhs);
372 } elsif ($algebra->isa('Attean::Algebra::LeftJoin')) {
373 0 my $expr = $algebra->expression;
374 0 my ($lhs_iter, $rhs_iter) = map { $self->evaluate( $_, $active_graph, %args ) } @children;
375 0 my @rhs = $rhs_iter->elements;
376 0 my @results;
377 0 my %vars = map { $_ => 1 } (@{ $lhs_iter->variables }, @{ $rhs_iter->variables });
378 0 ▶ while (my $lhs = $lhs_iter->next) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $lhs = $lhs_iter->next) 0 0 0
379 0 my $joined = 0;
380 0 foreach my $rhs (@rhs) {
381 0 ▶ if (my $j = $lhs->join($rhs)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $j = $lhs->join($rhs)) 0 0 0
382 0 ▶ if ($expr_eval->evaluate_expression( $expr, $j, $active_graph, {} )->ebv) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr_eval->evaluate_expression($expr, $j, $active_graph, {})->ebv) 0 0 0
383 0 $joined++;
384 0 push(@results, $j);
385 }
386 }
387 }
388 0 ▶ push(@results, $lhs) unless ($joined);
Branch: 1 branch
BranchTrueFalseTotal
unless $joined 0 0 0
389 }
390 0 return Attean::ListIterator->new( variables => [keys %vars], values => \@results, item_type => 'Attean::API::Result');
391 } elsif ($algebra->isa('Attean::Algebra::Minus')) {
392 0 my ($lhsi, $rhs) = map { $self->evaluate( $_, $active_graph, %args ) } @children;
393 0 my @rhs = $rhs->elements;
394 0 my @results;
395 0 ▶ while (my $lhs = $lhsi->next) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $lhs = $lhsi->next) 0 0 0
396 0 my @compatible;
397 my @disjoint;
398 0 RHS: foreach my $rhs (@rhs) {
399 0 ▶ if (my $j = $lhs->join($rhs)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $j = $lhs->join($rhs)) { } 0 0 0
400 0 push(@compatible, 1);
401 } else {
402 0 push(@compatible, 0);
403 }
404
405 0 my $intersects = 0;
406 0 my %lhs_dom = map { $_ => 1 } $lhs->variables;
407 0 foreach my $rvar ($rhs->variables) {
408 0 ▶ if (exists $lhs_dom{$rvar}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $lhs_dom{$rvar}) 0 0 0
409 0 $intersects = 1;
410 }
411 }
412 0 push(@disjoint, not($intersects));
413 }
414
415 0 my $count = scalar(@rhs);
416 0 my $keep = 1;
417 0 foreach my $i (0 .. $#rhs) {
418 0 ▶ $keep = 0 unless ($compatible[$i] == 0 or $disjoint[$i] == 1);
Branch: 1 branch
BranchTrueFalseTotal
unless $compatible[$i] == 0 or $disjoint[$i] == 1 0 0 0
Condition0%0/3
$compatible[$i] == 0 or $disjoint[$i] == 1
l!l&&r!l&&!r
000
MC/DC0%0/2
$compatible[$i] == 0 or $disjoint[$i] == 1
$compatible[$i] == 0 $disjoint[$i] == 1
Truth table0%0/3
A or B
A= $compatible[$i] == 0B= $disjoint[$i] == 1
ABresult
1X1
011
000
419 }
420
421 0 ▶ push(@results, $lhs) if ($keep);
Branch: 1 branch
BranchTrueFalseTotal
if $keep 0 0 0
422 }
423 0 return Attean::ListIterator->new( variables => $lhsi->variables, values => \@results, item_type => 'Attean::API::Result');
424 } elsif ($algebra->isa('Attean::Algebra::Path')) {
425 24 my $s = $algebra->subject;
426 24 my $path = $algebra->path;
427 24 my $o = $algebra->object;
428 24 my @children = @{ $path->children };
429 24 my ($child) = $children[0];
430
431 24 ▶ return $self->model->get_bindings( $s, $path->predicate, $o, $active_graph ) if ($path->isa('Attean::Algebra::PredicatePath'));
Branch: 1 branch
BranchTrueFalseTotal
if $path->isa("Attean::Algebra::PredicatePath") 13 11 24
432 11 ▶ if ($path->isa('Attean::Algebra::InversePath')) {
Branch: 6 branches
BranchTrueFalseTotal
if ($path->isa('Attean::Algebra::InversePath')) { } 0 11 11
elsif ($path->isa('Attean::Algebra::AlternativePath')) { } 0 11 11
elsif ($path->isa('Attean::Algebra::NegatedPropertySet')) { } 1 10 11
elsif ($path->isa('Attean::Algebra::SequencePath')) { } 1 9 10
elsif ($path->isa('Attean::Algebra::ZeroOrMorePath') or $path->isa('Attean::Algebra::OneOrMorePath')) { } 4 5 9
elsif ($path->isa('Attean::Algebra::ZeroOrOnePath')) { } 5 0 5
433 0 my $path = Attean::Algebra::Path->new( subject => $o, path => $child, object => $s );
434 0 return $self->evaluate( $path, $active_graph, %args ) ;
435 } elsif ($path->isa('Attean::Algebra::AlternativePath')) {
436 0 my @children = @{ $path->children };
437 0 my @algebras = map { Attean::Algebra::Path->new( subject => $s, path => $_, object => $o ) } @children;
438 0 my @iters = map { $self->evaluate( $_, $active_graph, %args ) } @algebras;
439 0 return Attean::IteratorSequence->new( iterators => \@iters, item_type => $iters[0]->item_type, variables => [$algebra->in_scope_variables] );
440 } elsif ($path->isa('Attean::Algebra::NegatedPropertySet')) {
441 1 my $preds = $path->predicates;
442 1 my %preds = map { $_->value => 1 } @$preds;
443 1 my $rev = $path->reversed;
444 1 ▶ if (scalar(@$rev)) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @$rev) { } 0 1 1
445 # deconstruct
446 0 my $nps_fwd = Attean::Algebra::NegatedPropertySet->new( predicates => $preds );
447 0 my $nps_rev = Attean::Algebra::NegatedPropertySet->new( predicates => $rev );
448 0 my $inv = Attean::Algebra::InversePath->new( children => [$nps_rev] );
449 0 my $alt = Attean::Algebra::AlternativePath->new( children => [ $nps_fwd, $inv ] );
450 0 ▶ my $pp = scalar(@$preds) ? $alt : $inv;
Branch: 1 branch
BranchTrueFalseTotal
scalar @$preds ? : 0 0 0
451 0 my $path = Attean::Algebra::Path->new( path => $pp, subject => $s, object => $o );
452 0 return $self->evaluate( $path, $active_graph, %args ) ;
453 } else {
454 2 ▶ my $filter_fwd = $self->model->get_quads($s, undef, $o, $active_graph)->grep(sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
455 2 my $q = shift;
456 2 my $p = $q->predicate;
457 2 return not exists $preds{ $p->value };
458 1 });
459 1 my %vars;
460 1 ▶ $vars{subject} = $s->value if ($s->does('Attean::API::Variable'));
Branch: 1 branch
BranchTrueFalseTotal
if $s->does("Attean::API::Variable") 0 1 1
461 1 ▶ $vars{object} = $o->value if ($o->does('Attean::API::Variable'));
Branch: 1 branch
BranchTrueFalseTotal
if $o->does("Attean::API::Variable") 1 0 1
462 1 ▶ return $filter_fwd->map(sub {
Subroutine __ANON__: called CC=2 SCAR=7.0
463 1 my $q = shift;
464 1 ▶ return unless $q;
Branch: 1 branch
BranchTrueFalseTotal
unless $q 0 1 1
465 1 my %bindings = map { $vars{$_} => $q->$_() } (keys %vars);
466 1 return Attean::Result->new( bindings => \%bindings );
467 1 }, 'Attean::API::Result', variables => [values %vars]);
468 }
469 } elsif ($path->isa('Attean::Algebra::SequencePath')) {
470 1 ▶ if (scalar(@children) == 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @children == 1) { } 0 1 1
471 0 my $path = Attean::Algebra::Path->new( subject => $s, path => $children[0], object => $o );
472 0 return $self->evaluate( $path, $active_graph, %args ) ;
473 } else {
474 1 my @paths;
475 1 my $first = shift(@children);
476 1 my $join = Attean::Variable->new();
477 1 my @new_vars = ($join->value);
478 1 push(@paths, Attean::Algebra::Path->new( subject => $s, path => $first, object => $join ));
479 1 foreach my $i (0 .. $#children) {
480 1 my $newjoin = Attean::Variable->new();
481 1 ▶ my $obj = ($i == $#children) ? $o : $newjoin;
Branch: 1 branch
BranchTrueFalseTotal
$i == $#children ? : 1 0 1
482 1 push(@new_vars, $newjoin->value);
483 1 push(@paths, Attean::Algebra::Path->new( subject => $join, path => $children[$i], object => $obj ));
484 1 $join = $newjoin;
485 }
486
487 1 ▶ while (scalar(@paths) > 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @paths > 1) 1 1 2
488 1 my ($l, $r) = splice(@paths, 0, 2);
489 1 unshift(@paths, Attean::Algebra::Join->new( children => [$l, $r] ));
490 }
491 1 ▶ return $self->evaluate(shift(@paths), $active_graph)->map(sub { shift->project_complement(@new_vars) });
Subroutine __ANON__: called CC=1 SCAR=0.0
492 }
493 ▶ } elsif ($path->isa('Attean::Algebra::ZeroOrMorePath') or $path->isa('Attean::Algebra::OneOrMorePath')) {
Condition66%2/3
$path->isa("Attean::Algebra::ZeroOrMorePath") or $path->isa("Attean::Algebra::OneOrMorePath")
l!l&&r!l&&!r
405
MC/DC50%1/2
$path->isa("Attean::Algebra::ZeroOrMorePath") or $path->isa("Attean::Algebra::OneOrMorePath")
$path->isa("Attean::Algebra::ZeroOrMorePath") $path->isa("Attean::Algebra::OneOrMorePath")
Truth table66%2/3
A or B
A= $path->isa("Attean::Algebra::ZeroOrMorePath")B= $path->isa("Attean::Algebra::OneOrMorePath")
ABresult
1X1
011
000
494 4 ▶ if ($s->does('Attean::API::TermOrTriple') and $o->does('Attean::API::Variable')) {
Branch: 3 branches
BranchTrueFalseTotal
if ($s->does('Attean::API::TermOrTriple') and $o->does('Attean::API::Variable')) { } 3 1 4
elsif ($s->does('Attean::API::Variable') and $o->does('Attean::API::Variable')) { } 1 0 1
elsif ($s->does('Attean::API::Variable') and $o->does('Attean::API::TermOrTriple')) { } 0 0 0
Condition66%2/3
$s->does("Attean::API::TermOrTriple") and $o->does("Attean::API::Variable")
!ll&&!rl&&r
103
MC/DC50%1/2
$s->does("Attean::API::TermOrTriple") and $o->does("Attean::API::Variable")
$s->does("Attean::API::TermOrTriple") $o->does("Attean::API::Variable")
Truth table66%2/3
A and B
A= $s->does("Attean::API::TermOrTriple")B= $o->does("Attean::API::Variable")
ABresult
0X0
100
111
495 3 my $v = {};
496 3 ▶ if ($path->isa('Attean::Algebra::ZeroOrMorePath')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($path->isa('Attean::Algebra::ZeroOrMorePath')) { } 3 0 3
497 3 $self->_ALP($active_graph, $s, $child, $v, %args);
498 } else {
499 0 my $iter = $self->_eval($active_graph, $s, $child, %args);
500 0 ▶ while (my $n = $iter->next) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $n = $iter->next) 0 0 0
501 0 $self->_ALP($active_graph, $n, $child, $v, %args);
502 }
503 }
504 3 my @results = map { Attean::Result->new( bindings => { $o->value => $_ } ) } (values %$v);
505 3 return Attean::ListIterator->new(variables => [$o->value], values => \@results, item_type => 'Attean::API::Result');
506 ▶ } elsif ($s->does('Attean::API::Variable') and $o->does('Attean::API::Variable')) {
Condition33%1/3
$s->does("Attean::API::Variable") and $o->does("Attean::API::Variable")
!ll&&!rl&&r
001
MC/DC0%0/2
$s->does("Attean::API::Variable") and $o->does("Attean::API::Variable")
$s->does("Attean::API::Variable") $o->does("Attean::API::Variable")
Truth table33%1/3
A and B
A= $s->does("Attean::API::Variable")B= $o->does("Attean::API::Variable")
ABresult
0X0
100
111
507 1 my $nodes = $self->model->graph_nodes( $active_graph );
508 1 my @results;
509 1 ▶ while (my $t = $nodes->next) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $t = $nodes->next) 3 1 4
510 3 my $tr = Attean::Result->new( bindings => { $s->value => $t } );
511 3 my $p = Attean::Algebra::Path->new( subject => $t, path => $path, object => $o );
512 3 my $iter = $self->evaluate( $p, $active_graph, %args ) ;
513 3 ▶ while (my $r = $iter->next) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $r = $iter->next) 6 3 9
514 6 push(@results, $r->join($tr));
515 }
516 }
517 1 my %vars = map { $_ => 1 } ($s->value, $o->value);
518 1 return Attean::ListIterator->new(variables => [keys %vars], values => \@results, item_type => 'Attean::API::Result');
519 ▶ } elsif ($s->does('Attean::API::Variable') and $o->does('Attean::API::TermOrTriple')) {
Condition0%0/3
$s->does("Attean::API::Variable") and $o->does("Attean::API::TermOrTriple")
!ll&&!rl&&r
000
MC/DC0%0/2
$s->does("Attean::API::Variable") and $o->does("Attean::API::TermOrTriple")
$s->does("Attean::API::Variable") $o->does("Attean::API::TermOrTriple")
Truth table0%0/3
A and B
A= $s->does("Attean::API::Variable")B= $o->does("Attean::API::TermOrTriple")
ABresult
0X0
100
111
520 0 my $pclass = ref($path);
521 0 my $pp = $pclass->new( children => [ Attean::Algebra::InversePath->new( children => [$child] ) ] );
522 0 my $p = Attean::Algebra::Path->new( subject => $o, path => $pp, object => $s );
523 0 return $self->evaluate( $p, $active_graph, %args ) ;
524 } else { # Term ZeroOrMorePath(path) Term
525 0 my $v = {};
526 0 $self->_ALP($active_graph, $s, $child, $v, %args);
527 0 my @results;
528 0 foreach my $v (values %$v) {
529 0 ▶ return Attean::ListIterator->new(variables => [], values => [Attean::Result->new()], item_type => 'Attean::API::Result')
Branch: 1 branch
BranchTrueFalseTotal
if $v->equals($o) 0 0 0
530 if ($v->equals($o));
531 }
532 0 return Attean::ListIterator->new(variables => [], values => [], item_type => 'Attean::API::Result');
533 }
534 } elsif ($path->isa('Attean::Algebra::ZeroOrOnePath')) {
535 5 my $path = Attean::Algebra::Path->new( subject => $s, path => $child, object => $o );
536 5 my @iters;
537 my %seen;
538 5 ▶ push(@iters, $self->evaluate( $path, $active_graph, %args ) ->grep(sub { return not($seen{shift->as_string}++); }));
Subroutine __ANON__: called CC=1 SCAR=0.0
539 5 push(@iters, $self->_zeroLengthPath($s, $o, $active_graph));
540 5 my %vars;
541 5 foreach my $iter (@iters) {
542 10 $vars{$_}++ for (@{ $iter->variables });
543 }
544 5 return Attean::IteratorSequence->new( iterators => \@iters, item_type => 'Attean::API::Result', variables => [keys %vars] );
545 }
546 0 die "Unimplemented path type: $path";
547 } elsif ($algebra->isa('Attean::Algebra::Project')) {
548 3 my $iter = $self->evaluate( $child, $active_graph, %args ) ;
549 3 my @vars = map { $_->value } @{ $algebra->variables };
550 9 ▶ return $iter->map(sub {
Subroutine __ANON__: called CC=2 SCAR=7.0
551 9 my $r = shift;
552 9 ▶ my $b = { map { my $t = $r->value($_); $t ? ($_ => $t) : () } @vars };
Branch: 1 branch
BranchTrueFalseTotal
$t ? : 9 0 9
553 9 return Attean::Result->new( bindings => $b );
554 3 }, undef, variables => \@vars); #->debug('Project result');
555 } elsif ($algebra->isa('Attean::Algebra::Slice')) {
556 3 my $iter = $self->evaluate( $child, $active_graph, %args ) ;
557 3 ▶ $iter = $iter->offset($algebra->offset) if ($algebra->offset > 0);
Branch: 1 branch
BranchTrueFalseTotal
if $algebra->offset > 0 2 1 3
558 3 ▶ $iter = $iter->limit($algebra->limit) if ($algebra->limit >= 0);
Branch: 1 branch
BranchTrueFalseTotal
if $algebra->limit >= 0 2 1 3
559 3 return $iter;
560 } elsif ($algebra->isa('Attean::Algebra::Union')) {
561 0 my ($lhs, $rhs) = map { $self->evaluate( $_, $active_graph, %args ) } @children;
562 0 return Attean::IteratorSequence->new(
563 iterators => [$lhs, $rhs],
564 item_type => 'Attean::API::Result',
565 variables => [$algebra->in_scope_variables]
566 );
567 } elsif ($algebra->isa('Attean::Algebra::Ask')) {
568 0 my $iter = $self->evaluate( $child, $active_graph, %args ) ;
569 0 my $result = $iter->next;
570 0 ▶ return Attean::ListIterator->new(values => [$result ? Attean::Literal->true : Attean::Literal->false], item_type => 'Attean::API::Term');
Branch: 1 branch
BranchTrueFalseTotal
$result ? : 0 0 0
571 } elsif ($algebra->isa('Attean::Algebra::Construct')) {
572 1 my $iter = $self->evaluate( $child, $active_graph, %args ) ;
573 1 my $patterns = $algebra->triples;
574 1 my %seen;
575 return Attean::CodeIterator->new(
576 2 ▶ generator => sub {
Subroutine __ANON__: called CC=6 SCAR=18.2
577 2 my $bnode_mapper = Attean::TermMap->uuid_blank_map;
578  
579 2 my $r = $iter->next;
580 2 ▶ return unless ($r);
Branch: 1 branch
BranchTrueFalseTotal
unless $r 1 1 2
581 1 ▶ my %mapping = map { my $t = $r->value($_); $t ? ("?$_" => $t) : (); } ($r->variables);
Branch: 1 branch
BranchTrueFalseTotal
$t ? : 2 0 2
582 1 my $mapper = Attean::TermMap->rewrite_map(\%mapping);
583 1 my @triples;
584 1 PATTERN: foreach my $p (@$patterns) {
585 my @terms = map {
586 1 ▶ ($_->does('Attean::API::TriplePattern'))
Branch: 1 branch
BranchTrueFalseTotal
$_->does('Attean::API::TriplePattern') ? : 0 3 3
587 ? $_->as_triple
588 : $_
589 } $p->apply_map($bnode_mapper)->apply_map($mapper)->values;
590 1 ▶ unless (all { $_->does('Attean::API::TermOrTriple') } @terms) {
Subroutine __ANON__: called CC=1 SCAR=0.2
Branch: 1 branch
BranchTrueFalseTotal
unless (&all(sub { $_->does("Attean::API::TermOrTriple"); } , @terms)) 0 1 1
591 0 next PATTERN;
592 }
593  
594 1 push(@triples, Attean::Triple->new(@terms));
595 }
596 1 return @triples;
597 },
598 item_type => 'Attean::API::Triple'
599 1 ▶ )->grep(sub { return not($seen{shift->as_string}++); });
Subroutine __ANON__: called CC=1 SCAR=0.0
600 } elsif ($algebra->isa('Attean::Algebra::Table')) {
601 0 my $vars = [map { $_->value } @{ $algebra->variables }];
602 0 return Attean::ListIterator->new(variables => $vars, values => $algebra->rows, item_type => 'Attean::API::Result');
603 }
604 0 die "Unimplemented simple algebra evaluation for: $algebra";
605 }
606  
607
608 =item C<< evaluate_pattern( $pattern, $active_graph, \@new_vars, \%blanks ) >>
609  
610 Returns an L<Attean::API::Iterator> object with results produced by evaluating
611 the triple- or quad-pattern C<< $pattern >> against the evaluator's
612 C<< model >>, using the supplied C<< $active_graph >>.
613  
614 If the C<< ground_blanks >> option is false, replaces blank nodes in the
615 pattern with fresh variables before evaluation, and populates C<< %blanks >>
616 with pairs ($variable_name => $variable_node). Each new variable is also
617 appended to C<< @new_vars >> as it is created.
618  
619 =cut
620  
621 24 ▶ sub evaluate_pattern {
Subroutine evaluate_pattern: called CC=7 SCAR=19.8
Pod documented
622 24 my $self = shift;
623 24 my $t = shift;
624 24 ▶ my $active_graph = shift || Carp::confess "No active-graph passed to Attean::SimpleQueryEvaluator->evaluate";
Condition50%1/2
shift() || Carp::confess('No active-graph passed to Attean::SimpleQueryEvaluator->evaluate')
l!l
240
MC/DC0%0/1
shift() || Carp::confess('No active-graph passed to Attean::SimpleQueryEvaluator->evaluate')
shift()
Truth table50%1/2
A
A= shift()
Aresult
11
00
625 24 my $new_vars = shift;
626 24 my $blanks = shift;
627 24 my $q = $t->as_quad_pattern($active_graph);
628 24 my @values;
629 24 foreach my $v ($q->values) {
630 96 ▶ if (not($self->ground_blanks)) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $self->ground_blanks) { } 88 8 96
631 88 ▶ if ($v->does('Attean::API::Blank')) {
Branch: 2 branches
BranchTrueFalseTotal
if ($v->does('Attean::API::Blank')) { } 2 86 88
elsif ($v->does('Attean::API::TriplePattern')) { } 0 86 86
632 2 ▶ unless (exists $blanks->{$v->value}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $$blanks{$v->value}) 1 1 2
633 1 $blanks->{$v->value} = Attean::Variable->new();
634 1 push(@$new_vars, $blanks->{$v->value}->value);
635 }
636 2 push(@values, $blanks->{$v->value});
637 } elsif ($v->does('Attean::API::TriplePattern')) {
638 0 my $tt = [$v];
639 # The replace_blanks_with_variables logic probably belongs somewhere more appropriate
640 # for shared use between the planner and this evaluator, but for now we just call into
641 # the planner.
642 0 my $changed = Attean::QueryPlanner->replace_blanks_with_variables($blanks, $tt);
643 0 push(@values, $tt->[0]);
644 } else {
645 86 push(@values, $v);
646 }
647 } else {
648 8 push(@values, $v);
649 }
650 }
651 24 return $self->model->get_bindings( @values );
652 }
653
654 6 ▶ sub _ALP {
Subroutine _ALP: called CC=3 SCAR=11.0
655 6 my $self = shift;
656 6 my $graph = shift;
657 6 my $term = shift;
658 6 my $path = shift;
659 6 my $v = shift;
660 6 my %args = @_;
661 6 ▶ return if (exists $v->{ $term->as_string });
Branch: 1 branch
BranchTrueFalseTotal
if exists $$v{$term->as_string} 0 6 6
662 6 $v->{ $term->as_string } = $term;
663
664 6 my $iter = $self->_eval($graph, $term, $path, %args);
665 6 ▶ while (my $n = $iter->next) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $n = $iter->next) 3 6 9
666 3 $self->_ALP($graph, $n, $path, $v, %args);
667 }
668 }
669
670 6 ▶ sub _eval {
Subroutine _eval: called CC=1 SCAR=0.0
671 6 my $self = shift;
672 6 my $graph = shift;
673 6 my $term = shift;
674 6 my $path = shift;
675 6 my %args = @_;
676 6 my $pp = Attean::Algebra::Path->new( subject => $term, path => $path, object => variable('o') );
677 6 my $iter = $self->evaluate( $pp, $graph, %args ) ;
678 6 ▶ my $terms = $iter->map(sub { shift->value('o') }, 'Attean::API::Term');
Subroutine __ANON__: called CC=1 SCAR=0.0
679 6 my %seen;
680 6 ▶ return $terms->grep(sub { not $seen{ shift->as_string }++ });
Subroutine __ANON__: called CC=1 SCAR=0.0
681 }
682
683 5 ▶ sub _zeroLengthPath {
Subroutine _zeroLengthPath: called CC=6 SCAR=17.9
684 5 my $self = shift;
685 5 my $s = shift;
686 5 my $o = shift;
687 5 my $graph = shift;
688 5 my $s_term = ($s->does('Attean::API::TermOrTriple'));
689 5 my $o_term = ($o->does('Attean::API::TermOrTriple'));
690 5 ▶ if ($s_term and $o_term) {
Branch: 3 branches
BranchTrueFalseTotal
if ($s_term and $o_term) { } 2 3 5
elsif ($s_term) { } 1 2 3
elsif ($o_term) { } 1 1 2
Condition100%3/3
$s_term and $o_term
!ll&&!rl&&r
212
MC/DC100%2/2
$s_term and $o_term
$s_term $o_term
Truth table100%3/3
A and B
A= $s_termB= $o_term
ABresult
0X0
100
111
691 2 my @r;
692 2 ▶ push(@r, Attean::Result->new()) if ($s->equals($o));
Branch: 1 branch
BranchTrueFalseTotal
if $s->equals($o) 1 1 2
693 2 return Attean::ListIterator->new(variables => [], values => \@r, item_type => 'Attean::API::Result');
694 } elsif ($s_term) {
695 1 my $name = $o->value;
696 1 my $r = Attean::Result->new( bindings => { $name => $s } );
697 1 return Attean::ListIterator->new(variables => [$name], values => [$r], item_type => 'Attean::API::Result');
698 } elsif ($o_term) {
699 1 my $name = $s->value;
700 1 my $r = Attean::Result->new( bindings => { $name => $o } );
701 1 return Attean::ListIterator->new(variables => [$name], values => [$r], item_type => 'Attean::API::Result');
702 } else {
703 1 my @vars = map { $_->value } ($s, $o);
704 1 my $nodes = $self->model->graph_nodes( $graph );
705 return $nodes->map(
706 5 ▶ sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
707 5 my $term = shift;
708 5 Attean::Result->new( bindings => { map { $_ => $term } @vars } );
709 },
710 1 'Attean::API::Result',
711 variables => \@vars
712 );
713 }
714 }
715
716 =item C<< new_service_client( $endpoint, $silent ) >>
717  
718 Returns a new Attean::SPARQLClient for use in evaluating queries using
719 the SPARQL Protocol against the given endpoint.
720  
721 =cut
722  
723 1 ▶ sub new_service_client {
Subroutine new_service_client: called CC=1 SCAR=0.0
Pod documented
724 1 my $self = shift;
725 1 my $endpoint = shift;
726 1 my $silent = shift;
727 1 my $client = Attean::SPARQLClient->new(
728 endpoint => $endpoint,
729 silent => $silent,
730 user_agent => $self->user_agent,
731 request_signer => $self->request_signer,
732 );
733 1 return $client;
734 }
735 }
736  
737 3 package Attean::SimpleQueryEvaluator::ExpressionEvaluator 0.040 {
738 3 ▶ use Moo;
Subroutine BEGIN: called CC=1 SCAR=0.0
739 3 ▶ use Attean::RDF;
Subroutine BEGIN: called CC=1 SCAR=0.0
740 3 ▶ use Scalar::Util qw(blessed looks_like_number);
Subroutine BEGIN: called CC=1 SCAR=0.0
741 3 ▶ use Types::Standard qw(InstanceOf);
Subroutine BEGIN: called CC=1 SCAR=0.0
742 3 ▶ use URI::Escape qw(uri_escape_utf8);
Subroutine BEGIN: called CC=1 SCAR=0.0
743 3 ▶ use Encode qw(encode);
Subroutine BEGIN: called CC=1 SCAR=0.0
744 3 ▶ use POSIX qw(ceil floor);
Subroutine BEGIN: called CC=1 SCAR=0.0
745 3 ▶ use Digest;
Subroutine BEGIN: called CC=1 SCAR=0.0
746 3 ▶ use UUID::Tiny ':std';
Subroutine BEGIN: called CC=1 SCAR=0.0
747 3 ▶ use DateTime::Format::W3CDTF;
Subroutine BEGIN: called CC=1 SCAR=0.0
748 3 ▶ use I18N::LangTags;
Subroutine BEGIN: called CC=1 SCAR=0.0
749 3 ▶ use namespace::clean;
Subroutine BEGIN: called CC=1 SCAR=0.0
750
751 3 has 'evaluator' => (is => 'ro', isa => InstanceOf['Attean::SimpleQueryEvaluator']);
752 53 ▶ sub evaluate_expression {
Subroutine evaluate_expression: called CC=2 SCAR=6.9
Pod undocumented
753 53 my $self = shift;
754 53 my $expr = shift;
755 53 my $row = shift;
756 53 my $active_graph = shift;
757 53 ▶ my $row_cache = shift || {};
Condition100%2/2
shift() || {}
l!l
2825
MC/DC100%1/1
shift() || {}
shift()
Truth table100%2/2
A
A= shift()
Aresult
11
00
758 53 my $impl = $self->impl($expr, $active_graph);
759 53 my $result = eval { $impl->($row, row_cache => $row_cache) };
760 53 return $result;
761 }
762
763 127 ▶ sub impl {
Subroutine impl: called CC=31 SCAR=65.7
Pod undocumented
764 127 my $self = shift;
765 127 my $expr = shift;
766 127 my $active_graph = shift;
767 127 my $op = $expr->operator;
768 127 my $true = Attean::Literal->true;
769 127 my $false = Attean::Literal->false;
770 127 ▶ if ($expr->isa('Attean::ExistsExpression')) {
Branch: 7 branches
BranchTrueFalseTotal
if ($expr->isa('Attean::ExistsExpression')) { } 0 127 127
elsif ($expr->isa('Attean::ValueExpression')) { } 88 39 127
elsif ($expr->isa('Attean::UnaryExpression')) { } 0 39 39
elsif ($expr->isa('Attean::BinaryExpression')) { } 35 4 39
elsif ($expr->isa('Attean::FunctionExpression')) { } 0 4 4
elsif ($expr->isa('Attean::AggregateExpression')) { } 0 4 4
elsif ($expr->isa('Attean::CastExpression')) { } 4 0 4
771 0 my $pattern = $expr->pattern;
772 0 ▶ return sub {
Subroutine __ANON__: not called CC=2 SCAR=17.9
773 0 my $r = shift;
774 0 my $table = Attean::Algebra::Table->new( variables => [map { variable($_) } $r->variables], rows => [$r] );
775 0 my $join = Attean::Algebra::Join->new( children => [$table, $pattern] );
776 # TODO: substitute variables at top-level of EXISTS pattern
777 0 my $iter = $self->evaluator->evaluate($join, $active_graph);
778 0 ▶ return ($iter->next) ? $true : $false;
Branch: 1 branch
BranchTrueFalseTotal
$iter->next ? : 0 0 0
779 0 };
780 } elsif ($expr->isa('Attean::ValueExpression')) {
781 88 my $node = $expr->value;
782 88 ▶ if ($node->does('Attean::API::Variable')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($node->does('Attean::API::Variable')) { } 29 59 88
783 29 ▶ return sub { return shift->value($node->value); };
Subroutine __ANON__: called CC=1 SCAR=0.0
784 } else {
785 59 ▶ return sub { return $node };
Subroutine __ANON__: called CC=1 SCAR=0.0
786 }
787 } elsif ($expr->isa('Attean::UnaryExpression')) {
788 0 my ($child) = @{ $expr->children };
789 0 my $impl = $self->impl($child, $active_graph);
790 0 ▶ if ($op eq '!') {
Branch: 2 branches
BranchTrueFalseTotal
if ($op eq '!') { } 0 0 0
elsif ($op eq '-' or $op eq '+') { } 0 0 0
791 0 ▶ return sub {
Subroutine __ANON__: not called CC=2 SCAR=17.9
792 0 my $term = $impl->(@_);
793 0 ▶ return ($term->ebv) ? $false : $true;
Branch: 1 branch
BranchTrueFalseTotal
$term->ebv ? : 0 0 0
794 }
795 0 ▶ } elsif ($op eq '-' or $op eq '+') {
Condition0%0/3
$op eq "-" or $op eq "+"
l!l&&r!l&&!r
000
MC/DC0%0/2
$op eq "-" or $op eq "+"
$op eq "-" $op eq "+"
Truth table0%0/3
A or B
A= $op eq "-"B= $op eq "+"
ABresult
1X1
011
000
796 0 ▶ return sub {
Subroutine __ANON__: not called CC=3 SCAR=24.8
797 0 my $term = $impl->(@_);
798 0 ▶ die "TypeError $op" unless (blessed($term) and $term->does('Attean::API::NumericLiteral'));
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($term) and $term->does("Attean::API::NumericLiteral") 0 0 0
Condition0%0/3
builtin::blessed($term) and $term->does("Attean::API::NumericLiteral")
!ll&&!rl&&r
000
MC/DC0%0/2
builtin::blessed($term) and $term->does("Attean::API::NumericLiteral")
builtin::blessed($term) $term->does("Attean::API::NumericLiteral")
Truth table0%0/3
A and B
A= builtin::blessed($term)B= $term->does("Attean::API::NumericLiteral")
ABresult
0X0
100
111
799 0 my $v = $term->numeric_value;
800 0 return Attean::Literal->new( value => eval "$op$v", datatype => $term->datatype );
801 0 };
802 }
803 0 die "Unimplemented UnaryExpression evaluation: " . $expr->operator;
804 } elsif ($expr->isa('Attean::BinaryExpression')) {
805 35 my ($lhs, $rhs) = @{ $expr->children };
806 35 my ($lhsi, $rhsi) = map { $self->impl($_, $active_graph) } ($lhs, $rhs);
807 35 ▶ if ($op eq '&&') {
Branch: 5 branches
BranchTrueFalseTotal
if ($op eq '&&') { } 9 26 35
elsif ($op eq '||') { } 9 17 26
elsif ($op =~ m[^(?:[-+*/])$]u) { } 17 0 17
elsif ($op =~ /^!?=$/u) { } 0 0 0
elsif ($op =~ /^[<>]=?$/u) { } 0 0 0
808 9 ▶ return sub {
Subroutine __ANON__: called CC=11 SCAR=24.0
809 9 my ($r, %args) = @_;
810 9 my $lbv = eval { $lhsi->($r, %args) };
811 9 my $rbv = eval { $rhsi->($r, %args) };
812 9 ▶ die "TypeError $op" unless ($lbv or $rbv);
Branch: 1 branch
BranchTrueFalseTotal
unless $lbv or $rbv 1 8 9
Condition100%3/3
$lbv or $rbv
l!l&&r!l&&!r
621
MC/DC100%2/2
$lbv or $rbv
$lbv $rbv
Truth table100%3/3
A or B
A= $lbvB= $rbv
ABresult
1X1
011
000
813 8 ▶ return $false if (not($lbv) and not($rbv->ebv));
Branch: 1 branch
BranchTrueFalseTotal
unless $lbv or $rbv->ebv 1 7 8
Condition100%3/3
$lbv or $rbv->ebv
l!l&&r!l&&!r
611
MC/DC100%2/2
$lbv or $rbv->ebv
$lbv $rbv->ebv
Truth table100%3/3
A or B
A= $lbvB= $rbv->ebv
ABresult
1X1
011
000
814 7 ▶ return $false if (not($rbv) and not($lbv->ebv));
Branch: 1 branch
BranchTrueFalseTotal
unless $rbv or $lbv->ebv 1 6 7
Condition100%3/3
$rbv or $lbv->ebv
l!l&&r!l&&!r
511
MC/DC100%2/2
$rbv or $lbv->ebv
$rbv $lbv->ebv
Truth table100%3/3
A or B
A= $rbvB= $lbv->ebv
ABresult
1X1
011
000
815 6 ▶ die "TypeError $op" unless ($lbv and $rbv);
Branch: 1 branch
BranchTrueFalseTotal
unless $lbv and $rbv 2 4 6
Condition100%3/3
$lbv and $rbv
!ll&&!rl&&r
114
MC/DC100%2/2
$lbv and $rbv
$lbv $rbv
Truth table100%3/3
A and B
A= $lbvB= $rbv
ABresult
0X0
100
111
816 4 ▶ return ($lbv->ebv && $rbv->ebv) ? $true : $false;
Branch: 1 branch
BranchTrueFalseTotal
$lbv->ebv && $rbv->ebv ? : 1 3 4
Condition100%3/3
$lbv->ebv and $rbv->ebv
!ll&&!rl&&r
211
MC/DC100%2/2
$lbv->ebv and $rbv->ebv
$lbv->ebv $rbv->ebv
Truth table100%3/3
A and B
A= $lbv->ebvB= $rbv->ebv
ABresult
0X0
100
111
817 }
818 9 } elsif ($op eq '||') {
819 9 ▶ return sub {
Subroutine __ANON__: called CC=6 SCAR=17.9
820 9 my ($r, %args) = @_;
821 9 my $lbv = eval { $lhsi->($r, %args) };
822 9 ▶ return $true if ($lbv and $lbv->ebv);
Branch: 1 branch
BranchTrueFalseTotal
if $lbv and $lbv->ebv 3 6 9
Condition100%3/3
$lbv and $lbv->ebv
!ll&&!rl&&r
333
MC/DC100%2/2
$lbv and $lbv->ebv
$lbv $lbv->ebv
Truth table100%3/3
A and B
A= $lbvB= $lbv->ebv
ABresult
0X0
100
111
823 6 my $rbv = eval { $rhsi->($r, %args) };
824 6 ▶ die "TypeError $op" unless ($rbv);
Branch: 1 branch
BranchTrueFalseTotal
unless $rbv 2 4 6
825 4 ▶ return $true if ($rbv->ebv);
Branch: 1 branch
BranchTrueFalseTotal
if $rbv->ebv 2 2 4
826 2 ▶ return $false if ($lbv);
Branch: 1 branch
BranchTrueFalseTotal
if $lbv 1 1 2
827 1 die "TypeError $op";
828 }
829 9 } elsif ($op =~ m#^(?:[-+*/])$#) { # numeric operators: - + * /
830 16 ▶ return sub {
Subroutine __ANON__: called CC=4 SCAR=13.9
831 16 my ($r, %args) = @_;
832 16 ($lhs, $rhs) = map { $_->($r, %args) } ($lhsi, $rhsi);
833 16 ▶ for ($lhs, $rhs) { die "TypeError $op" unless (blessed($_) and $_->does('Attean::API::NumericLiteral')); }
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($_) and $_->does("Attean::API::NumericLiteral") 1 31 32
Condition66%2/3
builtin::blessed($_) and $_->does("Attean::API::NumericLiteral")
!ll&&!rl&&r
0131
MC/DC50%1/2
builtin::blessed($_) and $_->does("Attean::API::NumericLiteral")
builtin::blessed($_) $_->does("Attean::API::NumericLiteral")
Truth table66%2/3
A and B
A= builtin::blessed($_)B= $_->does("Attean::API::NumericLiteral")
ABresult
0X0
100
111
834 15 my $lv = $lhs->numeric_value;
835 15 my $rv = $rhs->numeric_value;
836 15 return Attean::Literal->new( value => eval "$lv $op $rv", datatype => $lhs->binary_promotion_type($rhs, $op) );
837 17 };
838 } elsif ($op =~ /^!?=$/) {
839 0 ▶ return sub {
Subroutine __ANON__: not called CC=7 SCAR=40.3
840 0 my ($r, %args) = @_;
841 0 ($lhs, $rhs) = map { $_->($r, %args) } ($lhsi, $rhsi);
842 0 ▶ for ($lhs, $rhs) { die "TypeError $op" unless (blessed($_) and $_->does('Attean::API::TermOrTriple')); }
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($_) and $_->does("Attean::API::TermOrTriple") 0 0 0
Condition0%0/3
builtin::blessed($_) and $_->does("Attean::API::TermOrTriple")
!ll&&!rl&&r
000
MC/DC0%0/2
builtin::blessed($_) and $_->does("Attean::API::TermOrTriple")
builtin::blessed($_) $_->does("Attean::API::TermOrTriple")
Truth table0%0/3
A and B
A= builtin::blessed($_)B= $_->does("Attean::API::TermOrTriple")
ABresult
0X0
100
111
843 0 my $ok;
844 0 ▶ if ($lhs->does('Attean::API::Binding')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($lhs->does('Attean::API::Binding')) { } 0 0 0
845 0 $ok = $lhs->equals($rhs);
846 } else {
847 0 $ok = $lhs->equals($rhs);
848 }
849 0 ▶ $ok = not($ok) if ($op eq '!=');
Branch: 1 branch
BranchTrueFalseTotal
if $op eq "!=" 0 0 0
850 0 ▶ return $ok ? $true : $false;
Branch: 1 branch
BranchTrueFalseTotal
$ok ? : 0 0 0
851 }
852 0 } elsif ($op =~ /^[<>]=?$/) {
853 0 ▶ return sub {
Subroutine __ANON__: not called CC=10 SCAR=47.0
854 0 my ($r, %args) = @_;
855 0 ($lhs, $rhs) = map { $_->($r, %args) } ($lhsi, $rhsi);
856 0 for ($lhs, $rhs) {
857 0 ▶ die "TypeError $op" unless $_->does('Attean::API::TermOrTriple');
Branch: 1 branch
BranchTrueFalseTotal
unless $_->does("Attean::API::TermOrTriple") 0 0 0
858 0 ▶ die "TypeError $op" if ($_->does('Attean::API::IRI')); # comparison of IRIs is only defined for `ORDER BY`, not for general expressions
Branch: 1 branch
BranchTrueFalseTotal
if $_->does("Attean::API::IRI") 0 0 0
859 }
860
861 0 my $c = ($lhs->compare($rhs));
862 0 ▶ return $true if (($c < 0 and ($op =~ /<=?/)) or ($c > 0 and ($op =~ />=?/)) or ($c == 0 and ($op =~ /=/)));
Branch: 1 branch
BranchTrueFalseTotal
if $c < 0 and $op =~ /<=?/u or $c > 0 and $op =~ />=?/u or $c == 0 and $op =~ /=/u 0 0 0
Condition0%0/15
$c < 0 and $op =~ /<=?/u or $c > 0 and $op =~ />=?/u or $c == 0 and $op =~ /=/u
l!l&&r!l&&!r
000
$c < 0 and $op =~ /<=?/u or $c > 0 and $op =~ />=?/u
l!l&&r!l&&!r
000
$c < 0 and $op =~ /<=?/u
!ll&&!rl&&r
000
$c > 0 and $op =~ />=?/u
!ll&&!rl&&r
000
$c == 0 and $op =~ /=/u
!ll&&!rl&&r
000
MC/DC0%0/6
$c < 0 and $op =~ /<=?/u or $c > 0 and $op =~ />=?/u or $c == 0 and $op =~ /=/u
$c < 0 $op =~ /<=?/u $c > 0 $op =~ />=?/u $c == 0 $op =~ /=/u
Truth table0%0/15
A and B or C and D or E and F
A= $c < 0B= $op =~ /<=?/uC= $c > 0D= $op =~ />=?/uE= $c == 0F= $op =~ /=/u
ABCDEFresult
11XXXX1
0X11XX1
1011XX1
0X0X111
0X10111
100X111
1010111
0X0X0X0
0X0X100
0X100X0
0X10100
100X0X0
100X100
10100X0
1010100
863 0 return $false;
864 }
865 0 }
866 0 die "Unexpected operator evaluation: $op";
867 } elsif ($expr->isa('Attean::FunctionExpression')) {
868 0 my $func = $expr->operator;
869 0 my @children = map { $self->impl($_, $active_graph) } @{ $expr->children };
870 0 my %type_roles = qw(URI IRI IRI IRI BLANK Blank LITERAL Literal NUMERIC NumericLiteral TRIPLE Triple);
871 0 my %type_classes = qw(URI Attean::IRI IRI Attean::IRI STR Attean::Literal);
872 0 ▶ return sub {
Subroutine __ANON__: not called CC=180 SCAR=103.8
873 0 my ($r, %args) = @_;
874 0 ▶ my $row_cache = $args{row_cache} || {};
Condition0%0/2
$args{'row_cache'} || {}
l!l
00
MC/DC0%0/1
$args{'row_cache'} || {}
$args{'row_cache'}
Truth table0%0/2
A
A= $args{'row_cache'}
Aresult
11
00
875
876 0 ▶ if ($func eq 'IF') {
Branch: 3 branches
BranchTrueFalseTotal
if ($func eq 'IF') { } 0 0 0
elsif ($func eq 'IN' or $func eq 'NOTIN') { } 0 0 0
elsif ($func eq 'COALESCE') { } 0 0 0
877 0 my $term = $children[0]->( $r, %args );
878 0 my $ebv = $term->ebv;
879 0 ▶ return $ebv ? $children[1]->( $r, %args ) : $children[2]->( $r, %args );
Branch: 1 branch
BranchTrueFalseTotal
$ebv ? : 0 0 0
880 ▶ } elsif ($func eq 'IN' or $func eq 'NOTIN') {
Condition0%0/3
$func eq "IN" or $func eq "NOTIN"
l!l&&r!l&&!r
000
MC/DC0%0/2
$func eq "IN" or $func eq "NOTIN"
$func eq "IN" $func eq "NOTIN"
Truth table0%0/3
A or B
A= $func eq "IN"B= $func eq "NOTIN"
ABresult
1X1
011
000
881 0 ▶ ($true, $false) = ($false, $true) if ($func eq 'NOTIN');
Branch: 1 branch
BranchTrueFalseTotal
if $func eq "NOTIN" 0 0 0
882 0 my $child = shift(@children);
883 0 my $term = $child->( $r, %args );
884 0 foreach my $c (@children) {
885 0 ▶ if (my $value = eval { $c->( $r, %args ) }) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $value = eval { do { &$c($r, %args) } }) 0 0 0
886 0 ▶ return $true if ($term->equals($value));
Branch: 1 branch
BranchTrueFalseTotal
if $term->equals($value) 0 0 0
887 }
888 }
889 0 return $false;
890 } elsif ($func eq 'COALESCE') {
891 0 foreach my $c (@children) {
892 0 my $t = eval { $c->( $r, %args ) };
893 0 ▶ next if ($@);
Branch: 1 branch
BranchTrueFalseTotal
if $@ 0 0 0
894 0 ▶ return $t if $t;
Branch: 1 branch
BranchTrueFalseTotal
if $t 0 0 0
895 }
896 0 return;
897 }
898
899 0 ▶ if ($func eq 'INVOKE') {
Branch: 1 branch
BranchTrueFalseTotal
if ($func eq 'INVOKE') { } 0 0 0
900 0 my $furi = shift(@children)->( $r, %args )->value;
901 0 ▶ if (my $f = Attean->get_global_function($furi)) {
Branch: 2 branches
BranchTrueFalseTotal
if (my $f = 'Attean'->get_global_function($furi)) { } 0 0 0
elsif (my $fform = 'Attean'->get_global_functional_form($furi)) { } 0 0 0
902 0 my @operands = map { $_->( $r, %args ) } @children;
903 0 return $f->($self->evaluator->model, $active_graph, @operands);
904 } elsif (my $fform = Attean->get_global_functional_form($furi)) {
905 0 ▶ my @operands = map { eval { $_->( $r, %args ) } || undef } @children;
Condition0%0/2
eval { do { &$_($r, %args) } } || undef
l!l
00
MC/DC0%0/1
eval { do { &$_($r, %args) } } || undef
eval { do { &$_($r, %args) } }
Truth table0%0/2
A
A= eval { do { &$_($r, %args) } }
Aresult
11
00
906 0 return $fform->($self->evaluator->model, $active_graph, @operands);
907 } else {
908 0 die "No extension registered for <$furi>";
909 }
910 } else {
911 0 my @operands = map { $_->( $r, %args ) } @children;
912 0 ▶ if ($func =~ /^(STR)$/) {
Branch: 37 branches
BranchTrueFalseTotal
if ($func =~ /^(STR)$/u) { } 0 0 0
elsif ($func =~ /^(SUBJECT|PREDICATE|OBJECT)$/u) { } 0 0 0
elsif ($func =~ /^([UI]RI)$/u) { } 0 0 0
elsif ($func eq 'BNODE') { } 0 0 0
elsif ($func eq 'LANG') { } 0 0 0
elsif ($func eq 'LANGMATCHES') { } 0 0 0
elsif ($func eq 'HASLANG') { } 0 0 0
elsif ($func eq 'HASLANGDIR') { } 0 0 0
elsif ($func eq 'LANGDIR') { } 0 0 0
elsif ($func eq 'DATATYPE') { } 0 0 0
elsif ($func eq 'BOUND') { } 0 0 0
elsif ($func eq 'RAND') { } 0 0 0
elsif ($func eq 'ABS') { } 0 0 0
elsif ($func =~ /^(?:CEIL|FLOOR)$/u) { } 0 0 0
elsif ($func eq 'ROUND') { } 0 0 0
elsif ($func eq 'CONCAT') { } 0 0 0
elsif ($func eq 'SUBSTR') { } 0 0 0
elsif ($func eq 'STRLEN') { } 0 0 0
elsif ($func eq 'REPLACE') { } 0 0 0
elsif ($func =~ /^[UL]CASE$/u) { } 0 0 0
elsif ($func eq 'ENCODE_FOR_URI') { } 0 0 0
elsif ($func eq 'CONTAINS') { } 0 0 0
elsif ($func eq 'STRSTARTS' or $func eq 'STRENDS') { } 0 0 0
elsif ($func eq 'STRBEFORE' or $func eq 'STRAFTER') { } 0 0 0
elsif ($func =~ /^(?:YEAR|MONTH|DAY|HOURS|MINUTES)$/u) { } 0 0 0
elsif ($func eq 'SECONDS') { } 0 0 0
elsif ($func eq 'TZ' or $func eq 'TIMEZONE') { } 0 0 0
elsif ($func eq 'NOW') { } 0 0 0
elsif ($func =~ /^(?:STR)?UUID$/u) { } 0 0 0
elsif ($func =~ /^(MD5|SHA1|SHA256|SHA384|SHA512)$/u) { } 0 0 0
elsif ($func eq 'STRLANG') { } 0 0 0
elsif ($func eq 'STRLANGDIR') { } 0 0 0
elsif ($func eq 'STRDT') { } 0 0 0
elsif ($func eq 'SAMETERM') { } 0 0 0
elsif ($func eq 'TRIPLE') { } 0 0 0
elsif ($func =~ /^IS([UI]RI|BLANK|LITERAL|NUMERIC|TRIPLE)$/u) { } 0 0 0
elsif ($func eq 'REGEX') { } 0 0 0
913 0 return $type_classes{$1}->new($operands[0]->value);
914 } elsif ($func =~ /^(SUBJECT|PREDICATE|OBJECT)$/) {
915 0 my $pos = lc($func);
916 0 my $term = $operands[0]->$pos();
917 0 return $term;
918 } elsif ($func =~ /^([UI]RI)$/) {
919 0 my $operand = $operands[0];
920 0 ▶ if ($operand->does('Attean::API::Literal')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($operand->does("Attean::API::Literal")) 0 0 0
921 0 ▶ if ($operand->datatype->value ne 'http://www.w3.org/2001/XMLSchema#string') {
Branch: 1 branch
BranchTrueFalseTotal
if ($operand->datatype->value ne "http://www.w3.org/2001/XMLSchema#string") 0 0 0
922 0 die "TypeError: ${func} called with a datatyped-literal other than xsd:string";
923 }
924 }
925 0 ▶ my @base = $expr->has_base ? (base => $expr->base) : ();
Branch: 1 branch
BranchTrueFalseTotal
$expr->has_base ? : 0 0 0
926 0 return $type_classes{$1}->new(value => $operands[0]->value, @base);
927 } elsif ($func eq 'BNODE') {
928 0 ▶ if (scalar(@operands)) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @operands) 0 0 0
929 0 my $name = $operands[0]->value;
930 0 ▶ if (my $b = $row_cache->{bnodes}{$name}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $b = $row_cache->{'bnodes'}{$name}) { } 0 0 0
931 0 return $b;
932 } else {
933 0 my $b = Attean::Blank->new();
934 0 $row_cache->{bnodes}{$name} = $b;
935 0 return $b;
936 }
937 }
938 0 return Attean::Blank->new();
939 } elsif ($func eq 'LANG') {
940 0 ▶ die "TypeError: LANG" unless ($operands[0]->does('Attean::API::Literal'));
Branch: 1 branch
BranchTrueFalseTotal
unless $operands[0]->does("Attean::API::Literal") 0 0 0
941 0 ▶ return Attean::Literal->new($operands[0]->language // '');
Condition0%0/2
$operands[0]->language // ""
l!l
00
MC/DC0%0/1
$operands[0]->language // ""
$operands[0]->language
Truth table0%0/2
A
A= $operands[0]->language
Aresult
11
00
942 } elsif ($func eq 'LANGMATCHES') {
943 0 my ($lang, $match) = map { $_->value } @operands;
944 0 ▶ if ($match eq '*') {
Branch: 1 branch
BranchTrueFalseTotal
if ($match eq '*') { } 0 0 0
945 # """A language-range of "*" matches any non-empty language-tag string."""
946 0 ▶ return ($lang ? $true : $false);
Branch: 1 branch
BranchTrueFalseTotal
$lang ? : 0 0 0
947 } else {
948 0 ▶ return (I18N::LangTags::is_dialect_of( $lang, $match )) ? $true : $false;
Branch: 1 branch
BranchTrueFalseTotal
I18N::LangTags::is_dialect_of($lang, $match) ? : 0 0 0
949 }
950 } elsif ($func eq 'HASLANG') {
951 0 my ($string) = @operands;
952 0 ▶ return $false unless ($string->does('Attean::API::Literal'));
Branch: 1 branch
BranchTrueFalseTotal
unless $string->does("Attean::API::Literal") 0 0 0
953 0 ▶ return $string->has_language ? $true : $false;
Branch: 1 branch
BranchTrueFalseTotal
$string->has_language ? : 0 0 0
954 } elsif ($func eq 'HASLANGDIR') {
955 0 my ($string) = @operands;
956 0 ▶ return $false unless ($string->does('Attean::API::Literal'));
Branch: 1 branch
BranchTrueFalseTotal
unless $string->does("Attean::API::Literal") 0 0 0
957 0 ▶ return $string->has_base_dir ? $true : $false;
Branch: 1 branch
BranchTrueFalseTotal
$string->has_base_dir ? : 0 0 0
958 } elsif ($func eq 'LANGDIR') {
959 0 my ($string) = @operands;
960 0 ▶ die unless ($string->does('Attean::API::Literal'));
Branch: 1 branch
BranchTrueFalseTotal
unless $string->does("Attean::API::Literal") 0 0 0
961 0 ▶ my $dir = $string->base_dir // '';
Condition0%0/2
$string->base_dir // ""
l!l
00
MC/DC0%0/1
$string->base_dir // ""
$string->base_dir
Truth table0%0/2
A
A= $string->base_dir
Aresult
11
00
962 0 return Attean::Literal->new(value => $dir);
963 } elsif ($func eq 'DATATYPE') {
964 0 return $operands[0]->datatype;
965 } elsif ($func eq 'BOUND') {
966 0 ▶ return $operands[0] ? $true : $false;
Branch: 1 branch
BranchTrueFalseTotal
$operands[0] ? : 0 0 0
967 } elsif ($func eq 'RAND') {
968 0 return Attean::Literal->new( value => rand(), datatype => 'http://www.w3.org/2001/XMLSchema#double' );
969 } elsif ($func eq 'ABS') {
970 0 return Attean::Literal->new( value => abs($operands[0]->value), $operands[0]->construct_args );
971 } elsif ($func =~ /^(?:CEIL|FLOOR)$/) {
972 0 my $v = $operands[0]->value;
973 0 ▶ return Attean::Literal->new( value => (($func eq 'CEIL') ? ceil($v) : floor($v)), $operands[0]->construct_args );
Branch: 1 branch
BranchTrueFalseTotal
$func eq 'CEIL' ? : 0 0 0
974 } elsif ($func eq 'ROUND') {
975 0 return Attean::Literal->new( value => sprintf('%.0f', (0.000000000000001 + $operands[0]->numeric_value)), $operands[0]->construct_args );
976 } elsif ($func eq 'CONCAT') {
977 0 my $lang;
978 my $base_dir;
979 0 ▶ if (scalar(@operands) == 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @operands == 0) 0 0 0
980 0 return Attean::Literal->new(value => '');
981 }
982 0 my $lang_key = $operands[0]->lang_dir();
983 0 foreach my $n (@operands) {
984 0 ▶ die "CONCAT called with a non-literal argument" unless ($n->does('Attean::API::Literal'));
Branch: 1 branch
BranchTrueFalseTotal
unless $n->does("Attean::API::Literal") 0 0 0
985 0 ▶ if ($n->language) {
Branch: 2 branches
BranchTrueFalseTotal
if ($n->language) { } 0 0 0
elsif ($n->datatype->value ne 'http://www.w3.org/2001/XMLSchema#string') { } 0 0 0
986 } elsif ($n->datatype->value ne 'http://www.w3.org/2001/XMLSchema#string') {
987 0 die "CONCAT called with a datatyped-literal other than xsd:string";
988 }
989 0 my $new_lang_key = $n->lang_dir();
990 0 ▶ if ($new_lang_key ne $lang_key) {
Branch: 1 branch
BranchTrueFalseTotal
if ($new_lang_key ne $lang_key) 0 0 0
991 0 $lang_key = '';
992 }
993 }
994 0 my %args;
995 0 ▶ if ($lang_key) {
Branch: 1 branch
BranchTrueFalseTotal
if ($lang_key) 0 0 0
996 0 my ($lang, $dir) = split('--', $lang_key);
997 0 $args{language} = $lang;
998 0 ▶ if ($dir) {
Branch: 1 branch
BranchTrueFalseTotal
if ($dir) 0 0 0
999 0 $args{base_dir} = $dir;
1000 }
1001 }
1002 0 return Attean::Literal->new( value => join('', map { $_->value } @operands), %args );
1003 } elsif ($func eq 'SUBSTR') {
1004 0 my $str = shift(@operands);
1005 0 my @args = map { $_->numeric_value } @operands;
1006 0 ▶ my $v = scalar(@args == 1) ? substr($str->value, $args[0]-1) : substr($str->value, $args[0]-1, $args[1]);
Branch: 1 branch
BranchTrueFalseTotal
scalar(@args == 1) ? : 0 0 0
1007 0 return Attean::Literal->new( value => $v, $str->construct_args );
1008 } elsif ($func eq 'STRLEN') {
1009 0 return Attean::Literal->integer(length($operands[0]->value));
1010 } elsif ($func eq 'REPLACE') {
1011 0 my ($node, $pat, $rep) = @operands;
1012 0 ▶ die "TypeError: REPLACE called without a literal arg1 term" unless (blessed($node) and $node->does('Attean::API::Literal'));
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($node) and $node->does("Attean::API::Literal") 0 0 0
Condition0%0/3
builtin::blessed($node) and $node->does("Attean::API::Literal")
!ll&&!rl&&r
000
MC/DC0%0/2
builtin::blessed($node) and $node->does("Attean::API::Literal")
builtin::blessed($node) $node->does("Attean::API::Literal")
Truth table0%0/3
A and B
A= builtin::blessed($node)B= $node->does("Attean::API::Literal")
ABresult
0X0
100
111
1013 0 ▶ die "TypeError: REPLACE called without a literal arg2 term" unless (blessed($pat) and $pat->does('Attean::API::Literal'));
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($pat) and $pat->does("Attean::API::Literal") 0 0 0
Condition0%0/3
builtin::blessed($pat) and $pat->does("Attean::API::Literal")
!ll&&!rl&&r
000
MC/DC0%0/2
builtin::blessed($pat) and $pat->does("Attean::API::Literal")
builtin::blessed($pat) $pat->does("Attean::API::Literal")
Truth table0%0/3
A and B
A= builtin::blessed($pat)B= $pat->does("Attean::API::Literal")
ABresult
0X0
100
111
1014 0 ▶ die "TypeError: REPLACE called without a literal arg3 term" unless (blessed($rep) and $rep->does('Attean::API::Literal'));
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($rep) and $rep->does("Attean::API::Literal") 0 0 0
Condition0%0/3
builtin::blessed($rep) and $rep->does("Attean::API::Literal")
!ll&&!rl&&r
000
MC/DC0%0/2
builtin::blessed($rep) and $rep->does("Attean::API::Literal")
builtin::blessed($rep) $rep->does("Attean::API::Literal")
Truth table0%0/3
A and B
A= builtin::blessed($rep)B= $rep->does("Attean::API::Literal")
ABresult
0X0
100
111
1015 0 ▶ die "TypeError: REPLACE called with a datatyped (non-xsd:string) literal" if ($node->datatype and $node->datatype->value ne 'http://www.w3.org/2001/XMLSchema#string' and $node->datatype->value ne 'http://www.w3.org/1999/02/22-rdf-syntax-ns#langString');
Branch: 1 branch
BranchTrueFalseTotal
if $node->datatype and $node->datatype->value ne "http://www.w3.org/2001/XMLSchema#string" and $node->datatype->value ne "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString" 0 0 0
Condition0%0/6
$node->datatype and $node->datatype->value ne "http://www.w3.org/2001/XMLSchema#string" and $node->datatype->value ne "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"
!ll&&!rl&&r
000
$node->datatype and $node->datatype->value ne "http://www.w3.org/2001/XMLSchema#string"
!ll&&!rl&&r
000
MC/DC0%0/3
$node->datatype and $node->datatype->value ne "http://www.w3.org/2001/XMLSchema#string" and $node->datatype->value ne "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"
$node->datatype $node->datatype->value ne "http://www.w3.org/2001/XMLSchema#string" $node->datatype->value ne "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"
Truth table0%0/4
A and B and C
A= $node->datatypeB= $node->datatype->value ne "http://www.w3.org/2001/XMLSchema#string"C= $node->datatype->value ne "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"
ABCresult
0XX0
10X0
1100
1111
1016 0 my ($value, $pattern, $replace) = map { $_->value } @operands;
1017 0 my $flags_term = $operands[3];
1018 0 ▶ my $flags = blessed($flags_term) ? $flags_term->value : '';
Branch: 1 branch
BranchTrueFalseTotal
builtin::blessed($flags_term) ? : 0 0 0
1019 0 ▶ die "EvaluationError: REPLACE called with unsafe ?{} match pattern" if (index($pattern, '(?{') != -1 or index($pattern, '(??{') != -1);
Branch: 1 branch
BranchTrueFalseTotal
if index($pattern, "(?{") != -1 or index($pattern, "(??{") != -1 0 0 0
Condition0%0/3
index($pattern, "(?{") != -1 or index($pattern, "(??{") != -1
l!l&&r!l&&!r
000
MC/DC0%0/2
index($pattern, "(?{") != -1 or index($pattern, "(??{") != -1
index($pattern, "(?{") != -1 index($pattern, "(??{") != -1
Truth table0%0/3
A or B
A= index($pattern, "(?{") != -1B= index($pattern, "(??{") != -1
ABresult
1X1
011
000
1020 0 ▶ die "EvaluationError: REPLACE called with unsafe ?{} replace pattern" if (index($replace, '(?{') != -1 or index($replace, '(??{') != -1);
Branch: 1 branch
BranchTrueFalseTotal
if index($replace, "(?{") != -1 or index($replace, "(??{") != -1 0 0 0
Condition0%0/3
index($replace, "(?{") != -1 or index($replace, "(??{") != -1
l!l&&r!l&&!r
000
MC/DC0%0/2
index($replace, "(?{") != -1 or index($replace, "(??{") != -1
index($replace, "(?{") != -1 index($replace, "(??{") != -1
Truth table0%0/3
A or B
A= index($replace, "(?{") != -1B= index($replace, "(??{") != -1
ABresult
1X1
011
000
1021
1022 0 $replace =~ s/\\/\\\\/g;
1023 0 $replace =~ s/\$(\d+)/\$$1/g;
1024 0 $replace =~ s/"/\\"/g;
1025 0 $replace = qq["$replace"];
1026 3 ▶ no warnings 'uninitialized';
Subroutine BEGIN: called CC=1 SCAR=0.0
1027
1028 0 ▶ if ($flags eq 'i') {
Branch: 1 branch
BranchTrueFalseTotal
if ($flags eq "i") 0 0 0
1029 0 $pattern = '(?i)' . $pattern;
1030 }
1031
1032 0 $value =~ s/$pattern/"$replace"/eeg;
1033 0 return Attean::Literal->new(value => $value, $node->construct_args);
1034 } elsif ($func =~ /^[UL]CASE$/) {
1035 0 ▶ return Attean::Literal->new( value => ($func eq 'UCASE' ? uc($operands[0]->value) : lc($operands[0]->value) ), $operands[0]->construct_args );
Branch: 1 branch
BranchTrueFalseTotal
$func eq 'UCASE' ? : 0 0 0
1036 } elsif ($func eq 'ENCODE_FOR_URI') {
1037 0 return Attean::Literal->new( uri_escape_utf8($operands[0]->value) );
1038 } elsif ($func eq 'CONTAINS') {
1039 0 my ($node, $pat) = @operands;
1040 0 my ($lit, $plit) = map { $_->value } @operands;
1041 0 ▶ die "TypeError: CONTAINS" if ($node->language and $pat->language and $node->language ne $pat->language);
Branch: 1 branch
BranchTrueFalseTotal
if $node->language and $pat->language and $node->language ne $pat->language 0 0 0
Condition0%0/6
$node->language and $pat->language and $node->language ne $pat->language
!ll&&!rl&&r
000
$node->language and $pat->language
!ll&&!rl&&r
000
MC/DC0%0/3
$node->language and $pat->language and $node->language ne $pat->language
$node->language $pat->language $node->language ne $pat->language
Truth table0%0/4
A and B and C
A= $node->languageB= $pat->languageC= $node->language ne $pat->language
ABCresult
0XX0
10X0
1100
1111
1042 0 ▶ return (index($lit, $plit) >= 0) ? $true : $false;
Branch: 1 branch
BranchTrueFalseTotal
(index($lit, $plit) != -1) ? : 0 0 0
1043 ▶ } elsif ($func eq 'STRSTARTS' or $func eq 'STRENDS') {
Condition0%0/3
$func eq "STRSTARTS" or $func eq "STRENDS"
l!l&&r!l&&!r
000
MC/DC0%0/2
$func eq "STRSTARTS" or $func eq "STRENDS"
$func eq "STRSTARTS" $func eq "STRENDS"
Truth table0%0/3
A or B
A= $func eq "STRSTARTS"B= $func eq "STRENDS"
ABresult
1X1
011
000
1044 0 my ($lit, $plit) = map { $_->value } @operands;
1045 0 ▶ if ($func eq 'STRENDS') {
Branch: 1 branch
BranchTrueFalseTotal
if ($func eq 'STRENDS') { } 0 0 0
1046 0 my $pos = length($lit) - length($plit);
1047 0 ▶ return (rindex($lit, $plit) == $pos) ? $true : $false;
Branch: 1 branch
BranchTrueFalseTotal
rindex($lit, $plit) == $pos ? : 0 0 0
1048 } else {
1049 0 ▶ return (index($lit, $plit) == 0) ? $true : $false;
Branch: 1 branch
BranchTrueFalseTotal
index($lit, $plit) == 0 ? : 0 0 0
1050 }
1051 ▶ } elsif ($func eq 'STRBEFORE' or $func eq 'STRAFTER') {
Condition0%0/3
$func eq "STRBEFORE" or $func eq "STRAFTER"
l!l&&r!l&&!r
000
MC/DC0%0/2
$func eq "STRBEFORE" or $func eq "STRAFTER"
$func eq "STRBEFORE" $func eq "STRAFTER"
Truth table0%0/3
A or B
A= $func eq "STRBEFORE"B= $func eq "STRAFTER"
ABresult
1X1
011
000
1052 0 my ($node, $substr) = @operands;
1053  
1054 0 ▶ die "$func called without a literal arg1 term" unless (blessed($node) and $node->does('Attean::API::Literal'));
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($node) and $node->does("Attean::API::Literal") 0 0 0
Condition0%0/3
builtin::blessed($node) and $node->does("Attean::API::Literal")
!ll&&!rl&&r
000
MC/DC0%0/2
builtin::blessed($node) and $node->does("Attean::API::Literal")
builtin::blessed($node) $node->does("Attean::API::Literal")
Truth table0%0/3
A and B
A= builtin::blessed($node)B= $node->does("Attean::API::Literal")
ABresult
0X0
100
111
1055 0 ▶ die "$func called without a literal arg2 term" unless (blessed($substr) and $substr->does('Attean::API::Literal'));
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($substr) and $substr->does("Attean::API::Literal") 0 0 0
Condition0%0/3
builtin::blessed($substr) and $substr->does("Attean::API::Literal")
!ll&&!rl&&r
000
MC/DC0%0/2
builtin::blessed($substr) and $substr->does("Attean::API::Literal")
builtin::blessed($substr) $substr->does("Attean::API::Literal")
Truth table0%0/3
A and B
A= builtin::blessed($substr)B= $substr->does("Attean::API::Literal")
ABresult
0X0
100
111
1056 0 ▶ die "$func called with a datatyped (non-xsd:string) literal" if ($node->datatype and $node->datatype->value ne 'http://www.w3.org/2001/XMLSchema#string' and $node->datatype->value ne 'http://www.w3.org/1999/02/22-rdf-syntax-ns#langString');
Branch: 1 branch
BranchTrueFalseTotal
if $node->datatype and $node->datatype->value ne "http://www.w3.org/2001/XMLSchema#string" and $node->datatype->value ne "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString" 0 0 0
Condition0%0/6
$node->datatype and $node->datatype->value ne "http://www.w3.org/2001/XMLSchema#string" and $node->datatype->value ne "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"
!ll&&!rl&&r
000
$node->datatype and $node->datatype->value ne "http://www.w3.org/2001/XMLSchema#string"
!ll&&!rl&&r
000
MC/DC0%0/3
$node->datatype and $node->datatype->value ne "http://www.w3.org/2001/XMLSchema#string" and $node->datatype->value ne "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"
$node->datatype $node->datatype->value ne "http://www.w3.org/2001/XMLSchema#string" $node->datatype->value ne "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"
Truth table0%0/4
A and B and C
A= $node->datatypeB= $node->datatype->value ne "http://www.w3.org/2001/XMLSchema#string"C= $node->datatype->value ne "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"
ABCresult
0XX0
10X0
1100
1111
1057  
1058 0 ▶ my $lhs_simple = (not($node->language) and ($node->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string'));
Condition0%0/3
!$node->language && $node->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string'
!ll&&!rl&&r
000
MC/DC0%0/2
!$node->language && $node->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string'
!$node->language $node->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string'
Truth table0%0/3
not(A) && B
A= !$node->languageB= $node->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string'
ABresult
0X0
100
111
1059 0 ▶ my $rhs_simple = (not($substr->language) and ($substr->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string'));
Condition0%0/3
!$substr->language && $substr->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string'
!ll&&!rl&&r
000
MC/DC0%0/2
!$substr->language && $substr->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string'
!$substr->language $substr->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string'
Truth table0%0/3
not(A) && B
A= !$substr->languageB= $substr->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string'
ABresult
0X0
100
111
1060 0 ▶ if ($lhs_simple and $rhs_simple) {
Branch: 3 branches
BranchTrueFalseTotal
if ($lhs_simple and $rhs_simple) { } 0 0 0
elsif ($node->language and $substr->language and $node->language eq $substr->language) { } 0 0 0
elsif ($node->language and $rhs_simple) { } 0 0 0
Condition0%0/3
$lhs_simple and $rhs_simple
!ll&&!rl&&r
000
MC/DC0%0/2
$lhs_simple and $rhs_simple
$lhs_simple $rhs_simple
Truth table0%0/3
A and B
A= $lhs_simpleB= $rhs_simple
ABresult
0X0
100
111
1061 # ok
1062 ▶ } elsif ($node->language and $substr->language and $node->language eq $substr->language) {
Condition0%0/6
$node->language and $substr->language and $node->language eq $substr->language
!ll&&!rl&&r
000
$node->language and $substr->language
!ll&&!rl&&r
000
MC/DC0%0/3
$node->language and $substr->language and $node->language eq $substr->language
$node->language $substr->language $node->language eq $substr->language
Truth table0%0/4
A and B and C
A= $node->languageB= $substr->languageC= $node->language eq $substr->language
ABCresult
0XX0
10X0
1100
1111
1063 # ok
1064 ▶ } elsif ($node->language and $rhs_simple) {
Condition0%0/3
$node->language and $rhs_simple
!ll&&!rl&&r
000
MC/DC0%0/2
$node->language and $rhs_simple
$node->language $rhs_simple
Truth table0%0/3
A and B
A= $node->languageB= $rhs_simple
ABresult
0X0
100
111
1065 # ok
1066 } else {
1067 0 die "$func called with literals that are not argument compatible";
1068 }
1069
1070 0 my $value = $node->value;
1071 0 my $match = $substr->value;
1072 0 my $i = index($value, $match, 0);
1073 0 ▶ if ($i < 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i < 0) { } 0 0 0
1074 0 return Attean::Literal->new('');
1075 } else {
1076 0 ▶ if ($func eq 'STRBEFORE') {
Branch: 1 branch
BranchTrueFalseTotal
if ($func eq 'STRBEFORE') { } 0 0 0
1077 0 return Attean::Literal->new(value => substr($value, 0, $i), $node->construct_args);
1078 } else {
1079 0 return Attean::Literal->new(value => substr($value, $i+length($match)), $node->construct_args);
1080 }
1081 }
1082 } elsif ($func =~ /^(?:YEAR|MONTH|DAY|HOURS|MINUTES)$/) {
1083 0 my $method = lc($func =~ s/^(HOUR|MINUTE)S$/$1/r);
1084 0 my $dt = $operands[0]->datetime;
1085 0 return Attean::Literal->integer($dt->$method());
1086 } elsif ($func eq 'SECONDS') {
1087 0 my $dt = $operands[0]->datetime;
1088 0 return Attean::Literal->decimal($dt->second());
1089 ▶ } elsif ($func eq 'TZ' or $func eq 'TIMEZONE') {
Condition0%0/3
$func eq "TZ" or $func eq "TIMEZONE"
l!l&&r!l&&!r
000
MC/DC0%0/2
$func eq "TZ" or $func eq "TIMEZONE"
$func eq "TZ" $func eq "TIMEZONE"
Truth table0%0/3
A or B
A= $func eq "TZ"B= $func eq "TIMEZONE"
ABresult
1X1
011
000
1090 0 my $dt = $operands[0]->datetime;
1091 0 my $tz = $dt->time_zone;
1092 0 ▶ if ($tz->is_floating) {
Branch: 1 branch
BranchTrueFalseTotal
if ($tz->is_floating) 0 0 0
1093 0 ▶ return Attean::Literal->new('') if ($func eq 'TZ');
Branch: 1 branch
BranchTrueFalseTotal
if $func eq "TZ" 0 0 0
1094 0 die "TIMEZONE called with a dateTime without a timezone";
1095 }
1096 0 ▶ return Attean::Literal->new('Z') if ($func eq 'TZ' and $tz->is_utc);
Branch: 1 branch
BranchTrueFalseTotal
if $func eq "TZ" and $tz->is_utc 0 0 0
Condition0%0/3
$func eq "TZ" and $tz->is_utc
!ll&&!rl&&r
000
MC/DC0%0/2
$func eq "TZ" and $tz->is_utc
$func eq "TZ" $tz->is_utc
Truth table0%0/3
A and B
A= $func eq "TZ"B= $tz->is_utc
ABresult
0X0
100
111
1097 0 ▶ if ($tz) {
Branch: 1 branch
BranchTrueFalseTotal
if ($tz) { } 0 0 0
1098 0 my $offset = $tz->offset_for_datetime( $dt );
1099 0 my $hours = 0;
1100 0 my $minutes = 0;
1101 0 ▶ my $minus = ($func eq 'TZ') ? '+' : '';
Branch: 1 branch
BranchTrueFalseTotal
$func eq 'TZ' ? : 0 0 0
1102 0 ▶ if ($offset < 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($offset < 0) 0 0 0
1103 0 $minus = '-';
1104 0 $offset = -$offset;
1105 }
1106  
1107 0 my $duration = "${minus}PT";
1108 0 ▶ if ($offset >= 60*60) {
Branch: 1 branch
BranchTrueFalseTotal
if ($offset >= 3600) 0 0 0
1109 0 my $h = int($offset / (60*60));
1110 0 ▶ $duration .= "${h}H" if ($h > 0);
Branch: 1 branch
BranchTrueFalseTotal
if $h > 0 0 0 0
1111 0 $hours = int($offset / (60*60));
1112 0 $offset = $offset % (60*60);
1113 }
1114 0 ▶ if ($offset >= 60) {
Branch: 1 branch
BranchTrueFalseTotal
if ($offset >= 60) 0 0 0
1115 0 my $m = int($offset / 60);
1116 0 ▶ $duration .= "${m}M" if ($m > 0);
Branch: 1 branch
BranchTrueFalseTotal
if $m > 0 0 0 0
1117 0 $minutes = int($offset / 60);
1118 0 $offset = $offset % 60;
1119 }
1120 0 my $seconds = int($offset);
1121 0 my $s = int($offset);
1122 0 ▶ $duration .= "${s}S" if ($s > 0 or $duration eq 'PT');
Branch: 1 branch
BranchTrueFalseTotal
if $s > 0 or $duration eq "PT" 0 0 0
Condition0%0/3
$s > 0 or $duration eq "PT"
l!l&&r!l&&!r
000
MC/DC0%0/2
$s > 0 or $duration eq "PT"
$s > 0 $duration eq "PT"
Truth table0%0/3
A or B
A= $s > 0B= $duration eq "PT"
ABresult
1X1
011
000
1123
1124 0 ▶ return ($func eq 'TZ')
Branch: 1 branch
BranchTrueFalseTotal
$func eq 'TZ' ? : 0 0 0
1125 ? Attean::Literal->new(sprintf('%s%02d:%02d', $minus, $hours, $minutes))
1126 : Attean::Literal->new( value => $duration, datatype => "http://www.w3.org/2001/XMLSchema#dayTimeDuration");
1127 } else {
1128 0 ▶ return Attean::Literal->new('') if ($func eq 'TZ');
Branch: 1 branch
BranchTrueFalseTotal
if $func eq "TZ" 0 0 0
1129 0 die "TIMEZONE called without a valid dateTime";
1130 }
1131 } elsif ($func eq 'NOW') {
1132 0 my $value = DateTime::Format::W3CDTF->new->format_datetime( DateTime->now );
1133 0 return Attean::Literal->new( value => $value, datatype => 'http://www.w3.org/2001/XMLSchema#dateTime' );
1134 } elsif ($func =~ /^(?:STR)?UUID$/) {
1135 0 ▶ return Attean::Literal->new(uc(uuid_to_string(create_uuid()))) if ($func eq 'STRUUID');
Branch: 1 branch
BranchTrueFalseTotal
if $func eq "STRUUID" 0 0 0
1136 0 return Attean::IRI->new('urn:uuid:' . uc(uuid_to_string(create_uuid())));
1137 } elsif ($func =~ /^(MD5|SHA1|SHA256|SHA384|SHA512)$/) {
1138 0 my $hash = $func =~ s/SHA/SHA-/r;
1139 0 my $digest = eval { Digest->new($hash)->add(encode('UTF-8', $operands[0]->value, Encode::FB_CROAK))->hexdigest };
1140 0 return Attean::Literal->new($digest);
1141 } elsif ($func eq 'STRLANG') {
1142 0 my ($str, $lang) = @operands;
1143 0 my @values = map { $_->value } @operands;
1144 0 ▶ die "TypeError: STRLANG must be called with two plain literals" unless (blessed($str) and $str->does('Attean::API::Literal') and blessed($lang) and $lang->does('Attean::API::Literal'));
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($str) and $str->does("Attean::API::Literal") and builtin::blessed($lang) and $lang->does("Attean::API::Literal") 0 0 0
Condition0%0/9
builtin::blessed($str) and $str->does("Attean::API::Literal") and builtin::blessed($lang) and $lang->does("Attean::API::Literal")
!ll&&!rl&&r
000
builtin::blessed($str) and $str->does("Attean::API::Literal") and builtin::blessed($lang)
!ll&&!rl&&r
000
builtin::blessed($str) and $str->does("Attean::API::Literal")
!ll&&!rl&&r
000
MC/DC0%0/4
builtin::blessed($str) and $str->does("Attean::API::Literal") and builtin::blessed($lang) and $lang->does("Attean::API::Literal")
builtin::blessed($str) $str->does("Attean::API::Literal") builtin::blessed($lang) $lang->does("Attean::API::Literal")
Truth table0%0/5
A and B and C and D
A= builtin::blessed($str)B= $str->does("Attean::API::Literal")C= builtin::blessed($lang)D= $lang->does("Attean::API::Literal")
ABCDresult
0XXX0
10XX0
110X0
11100
11111
1145 0 ▶ die "TypeError: STRLANG not called with a simple literal" unless ($str->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string' and not($str->language));
Branch: 1 branch
BranchTrueFalseTotal
unless $str->datatype->value eq "http://www.w3.org/2001/XMLSchema#string" and not $str->language 0 0 0
Condition0%0/3
$str->datatype->value eq "http://www.w3.org/2001/XMLSchema#string" and not $str->language
!ll&&!rl&&r
000
MC/DC0%0/2
$str->datatype->value eq "http://www.w3.org/2001/XMLSchema#string" and not $str->language
$str->datatype->value eq "http://www.w3.org/2001/XMLSchema#string" not $str->language
Truth table0%0/3
A and not(B)
A= $str->datatype->value eq "http://www.w3.org/2001/XMLSchema#string"B= not $str->language
ABresult
0X0
100
111
1146 0 ▶ die unless (length($lang->value));
Branch: 1 branch
BranchTrueFalseTotal
unless length $lang->value 0 0 0
1147 0 return Attean::Literal->new( value => $values[0], language => $values[1] );
1148 } elsif ($func eq 'STRLANGDIR') {
1149 0 my ($term, $lang, $dir) = @operands;
1150 0 ▶ die unless ($term->does('Attean::API::Literal'));
Branch: 1 branch
BranchTrueFalseTotal
unless $term->does("Attean::API::Literal") 0 0 0
1151 0 ▶ die unless ($lang->does('Attean::API::Literal'));
Branch: 1 branch
BranchTrueFalseTotal
unless $lang->does("Attean::API::Literal") 0 0 0
1152 0 ▶ die unless ($dir->does('Attean::API::Literal'));
Branch: 1 branch
BranchTrueFalseTotal
unless $dir->does("Attean::API::Literal") 0 0 0
1153 0 ▶ die unless ($term->datatype->value =~ m<http://www.w3.org/2001/XMLSchema#string>);
Branch: 1 branch
BranchTrueFalseTotal
unless $term->datatype->value =~ m[http://www.w3.org/2001/XMLSchema#string]u 0 0 0
1154 0 ▶ die unless ($lang->value);
Branch: 1 branch
BranchTrueFalseTotal
unless $lang->value 0 0 0
1155 0 ▶ die unless ($dir->value =~ /^(ltr|rtl)$/);
Branch: 1 branch
BranchTrueFalseTotal
unless $dir->value =~ /^(ltr|rtl)$/u 0 0 0
1156 0 my $v = Attean::Literal->new(value => $term->value, language => $lang->value, base_dir => $dir->value);
1157 0 return $v;
1158 } elsif ($func eq 'STRDT') {
1159 0 ▶ die "TypeError: STRDT" unless ($operands[0]->does('Attean::API::Literal') and not($operands[0]->language));
Branch: 1 branch
BranchTrueFalseTotal
unless $operands[0]->does("Attean::API::Literal") and not $operands[0]->language 0 0 0
Condition0%0/3
$operands[0]->does("Attean::API::Literal") and not $operands[0]->language
!ll&&!rl&&r
000
MC/DC0%0/2
$operands[0]->does("Attean::API::Literal") and not $operands[0]->language
$operands[0]->does("Attean::API::Literal") not $operands[0]->language
Truth table0%0/3
A and not(B)
A= $operands[0]->does("Attean::API::Literal")B= not $operands[0]->language
ABresult
0X0
100
111
1160 0 ▶ if (my $dt = $operands[0]->datatype) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $dt = $operands[0]->datatype) 0 0 0
1161 0 ▶ die "TypeError: STRDT" unless ($dt->value eq 'http://www.w3.org/2001/XMLSchema#string');
Branch: 1 branch
BranchTrueFalseTotal
unless $dt->value eq "http://www.w3.org/2001/XMLSchema#string" 0 0 0
1162 }
1163 0 ▶ die "TypeError: STRDT" unless ($operands[1]->does('Attean::API::IRI'));
Branch: 1 branch
BranchTrueFalseTotal
unless $operands[1]->does("Attean::API::IRI") 0 0 0
1164 0 my @values = map { $_->value } @operands;
1165 0 return Attean::Literal->new( value => $values[0], datatype => $values[1] );
1166 } elsif ($func eq 'SAMETERM') {
1167 0 my ($a, $b) = @operands;
1168 0 ▶ die "TypeError: SAMETERM" unless (blessed($operands[0]) and blessed($operands[1]));
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($operands[0]) and builtin::blessed($operands[1]) 0 0 0
Condition0%0/3
builtin::blessed($operands[0]) and builtin::blessed($operands[1])
!ll&&!rl&&r
000
MC/DC0%0/2
builtin::blessed($operands[0]) and builtin::blessed($operands[1])
builtin::blessed($operands[0]) builtin::blessed($operands[1])
Truth table0%0/3
A and B
A= builtin::blessed($operands[0])B= builtin::blessed($operands[1])
ABresult
0X0
100
111
1169 0 my $cmp = eval { $a->compare($b) };
1170 0 ▶ if (not($@) and $cmp) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $@ and $cmp) 0 0 0
Condition0%0/3
not $@ and $cmp
!ll&&!rl&&r
000
MC/DC0%0/2
not $@ and $cmp
not $@ $cmp
Truth table0%0/3
not(A) and B
A= not $@B= $cmp
ABresult
0X0
100
111
1171 0 return $false;
1172 }
1173 0 ▶ if ($a->does('Attean::API::Binding')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($a->does('Attean::API::Binding')) { } 0 0 0
1174 0 my $ok = ($a->sameTerms($b));
1175 0 ▶ return $ok ? $true : $false;
Branch: 1 branch
BranchTrueFalseTotal
$ok ? : 0 0 0
1176 } else {
1177 0 my $ok = ($a->value eq $b->value);
1178 0 ▶ return $ok ? $true : $false;
Branch: 1 branch
BranchTrueFalseTotal
$ok ? : 0 0 0
1179 }
1180 } elsif ($func eq 'TRIPLE') {
1181 0 my ($s, $p, $o) = @operands;
1182 0 ▶ unless ($s->does('Attean::API::BlankOrIRI')) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($s->does("Attean::API::BlankOrIRI")) 0 0 0
1183 0 die 'TRIPLE() constructor failed with bad subject type';
1184 }
1185 0 ▶ unless ($p->does('Attean::API::IRI')) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($p->does("Attean::API::IRI")) 0 0 0
1186 0 die 'TRIPLE() constructor failed with bad predicate type';
1187 }
1188 0 ▶ unless ($o->does('Attean::API::TermOrTriple')) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($o->does("Attean::API::TermOrTriple")) 0 0 0
1189 0 die 'TRIPLE() constructor failed with bad object type';
1190 }
1191 0 return Attean::Triple->new($s, $p, $o);
1192 } elsif ($func =~ /^IS([UI]RI|BLANK|LITERAL|NUMERIC|TRIPLE)$/) {
1193 0 ▶ return $operands[0]->does("Attean::API::$type_roles{$1}") ? $true : $false;
Branch: 1 branch
BranchTrueFalseTotal
$operands[0]->does("Attean::API::$type_roles{$1}") ? : 0 0 0
1194 } elsif ($func eq 'REGEX') {
1195 0 my ($value, $pattern, $flags) = map { $_->value } @operands;
1196 0 ▶ unless ($operands[0]->does('Attean::API::Literal')) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($operands[0]->does("Attean::API::Literal")) 0 0 0
1197 0 die 'REGEX called with non-literal value';
1198 }
1199 0 ▶ unless ($operands[1]->does('Attean::API::Literal')) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($operands[1]->does("Attean::API::Literal")) 0 0 0
1200 0 die 'REGEX called with non-literal pattern';
1201 }
1202 0 my $flag_str = '';
1203 0 ▶ if (defined $flags) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $flags) 0 0 0
1204 0 ▶ $flag_str .= 'i' if ($flags =~ /i/);
Branch: 1 branch
BranchTrueFalseTotal
if $flags =~ /i/u 0 0 0
1205 0 ▶ $flag_str .= 's' if ($flags =~ /s/);
Branch: 1 branch
BranchTrueFalseTotal
if $flags =~ /s/u 0 0 0
1206 0 ▶ $flag_str .= 'm' if ($flags =~ /m/);
Branch: 1 branch
BranchTrueFalseTotal
if $flags =~ /m/u 0 0 0
1207 0 ▶ $flag_str .= 'x' if ($flags =~ /x/);
Branch: 1 branch
BranchTrueFalseTotal
if $flags =~ /x/u 0 0 0
1208 0 ▶ if ($flags =~ /q/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($flags =~ /q/u) 0 0 0
1209 0 $pattern = quotemeta($pattern);
1210 }
1211 }
1212 0 ▶ return ($value =~ /(?${flag_str}:$pattern)/) ? $true : $false;
Branch: 1 branch
BranchTrueFalseTotal
$value =~ /(?$flag_str:$pattern)/u ? : 0 0 0
1213 }
1214 0 die "Unimplemented FunctionExpression evaluation: " . $expr->operator;
1215 }
1216 0 };
1217 } elsif ($expr->isa('Attean::AggregateExpression')) {
1218 0 my $agg = $expr->operator;
1219 0 my ($child) = @{ $expr->children };
1220 0 ▶ if ($agg eq 'COUNT') {
Branch: 3 branches
BranchTrueFalseTotal
if ($agg eq 'COUNT') { } 0 0 0
elsif ($agg =~ /^(?:SAMPLE|MIN|MAX|SUM|AVG|GROUP_CONCAT|FOLD)$/u) { } 0 0 0
elsif ($agg eq 'CUSTOM') { } 0 0 0
1221 0 ▶ if ($child) {
Branch: 1 branch
BranchTrueFalseTotal
if ($child) { } 0 0 0
1222 0 my $impl = $self->impl($child, $active_graph);
1223 0 ▶ return sub {
Subroutine __ANON__: not called CC=2 SCAR=17.9
1224 0 my ($rows, %args) = @_;
1225 0 my @terms = grep { blessed($_) } map { $impl->($_, %args) } @{ $rows };
1226 0 ▶ if ($expr->distinct) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr->distinct) 0 0 0
1227 0 my %seen;
1228 0 @terms = grep { not($seen{$_->as_string}++) } @terms;
1229 }
1230 0 return Attean::Literal->integer(scalar(@terms));
1231 0 };
1232 } else {
1233 0 ▶ return sub {
Subroutine __ANON__: not called CC=1 SCAR=6.9
1234 0 my ($rows, %args) = @_;
1235 0 return Attean::Literal->integer(scalar(@$rows));
1236 0 };
1237 }
1238 } elsif ($agg =~ /^(?:SAMPLE|MIN|MAX|SUM|AVG|GROUP_CONCAT|FOLD)$/) {
1239 0 my $impl = $self->impl($child, $active_graph);
1240 0 ▶ if ($agg eq 'SAMPLE') {
Branch: 5 branches
BranchTrueFalseTotal
if ($agg eq 'SAMPLE') { } 0 0 0
elsif ($agg eq 'MIN' or $agg eq 'MAX') { } 0 0 0
elsif ($agg eq 'SUM' or $agg eq 'AVG') { } 0 0 0
elsif ($agg eq 'GROUP_CONCAT') { } 0 0 0
elsif ($agg eq 'FOLD') { } 0 0 0
1241 0 ▶ return sub {
Subroutine __ANON__: not called CC=1 SCAR=6.9
1242 0 my ($rows, %args) = @_;
1243 0 return $impl->( shift(@$rows), %args )
1244 0 };
1245 ▶ } elsif ($agg eq 'MIN' or $agg eq 'MAX') {
Condition0%0/3
$agg eq "MIN" or $agg eq "MAX"
l!l&&r!l&&!r
000
MC/DC0%0/2
$agg eq "MIN" or $agg eq "MAX"
$agg eq "MIN" $agg eq "MAX"
Truth table0%0/3
A or B
A= $agg eq "MIN"B= $agg eq "MAX"
ABresult
1X1
011
000
1246 0 ▶ my $expect = ($agg eq 'MIN') ? 1 : -1;
Branch: 1 branch
BranchTrueFalseTotal
$agg eq 'MIN' ? : 0 0 0
1247 0 ▶ return sub {
Subroutine __ANON__: not called CC=7 SCAR=40.3
1248 0 my ($rows, %args) = @_;
1249 0 my $extrema;
1250 0 foreach my $r (@$rows) {
1251 0 my $t = $impl->( $r, %args );
1252 0 ▶ return if (not($t) and $agg eq 'MIN'); # unbound is always minimal
Branch: 1 branch
BranchTrueFalseTotal
if not $t and $agg eq "MIN" 0 0 0
Condition0%0/3
not $t and $agg eq "MIN"
!ll&&!rl&&r
000
MC/DC0%0/2
not $t and $agg eq "MIN"
not $t $agg eq "MIN"
Truth table0%0/3
not(A) and B
A= not $tB= $agg eq "MIN"
ABresult
0X0
100
111
1253 0 ▶ next if (not($t)); # unbound need not be considered for MAX
Branch: 1 branch
BranchTrueFalseTotal
unless $t 0 0 0
1254 0 ▶ $extrema = $t if (not($extrema) or $extrema->compare($t) == $expect);
Branch: 1 branch
BranchTrueFalseTotal
if not $extrema or $extrema->compare($t) == $expect 0 0 0
Condition0%0/3
not $extrema or $extrema->compare($t) == $expect
l!l&&r!l&&!r
000
MC/DC0%0/2
not $extrema or $extrema->compare($t) == $expect
not $extrema $extrema->compare($t) == $expect
Truth table0%0/3
not(A) or B
A= not $extremaB= $extrema->compare($t) == $expect
ABresult
1X1
011
000
1255 }
1256 0 return $extrema;
1257 0 };
1258 ▶ } elsif ($agg eq 'SUM' or $agg eq 'AVG') {
Condition0%0/3
$agg eq "SUM" or $agg eq "AVG"
l!l&&r!l&&!r
000
MC/DC0%0/2
$agg eq "SUM" or $agg eq "AVG"
$agg eq "SUM" $agg eq "AVG"
Truth table0%0/3
A or B
A= $agg eq "SUM"B= $agg eq "AVG"
ABresult
1X1
011
000
1259 0 ▶ return sub {
Subroutine __ANON__: not called CC=7 SCAR=40.3
1260 0 my ($rows, %args) = @_;
1261 0 my $count = 0;
1262 0 my $sum = Attean::Literal->integer(0);
1263 0 my %seen;
1264 0 foreach my $r (@$rows) {
1265 0 my $term = $impl->( $r, %args );
1266 0 ▶ if ($expr->distinct) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr->distinct) 0 0 0
1267 0 ▶ next if ($seen{ $term->as_string }++);
Branch: 1 branch
BranchTrueFalseTotal
if $seen{$term->as_string}++ 0 0 0
1268 }
1269 0 ▶ if ($term->does('Attean::API::NumericLiteral')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($term->does('Attean::API::NumericLiteral')) { } 0 0 0
1270 0 $count++;
1271 0 $sum = Attean::Literal->new( value => ($sum->numeric_value + $term->numeric_value), datatype => $sum->binary_promotion_type($term, '+') );
1272 } else {
1273 0 die "TypeError: AVG";
1274 }
1275 }
1276 0 ▶ if ($agg eq 'AVG') {
Branch: 1 branch
BranchTrueFalseTotal
if ($agg eq "AVG") 0 0 0
1277 0 ▶ $sum = not($count) ? Attean::Literal->integer(0) : Attean::Literal->new( value => ($sum->numeric_value / $count), datatype => $sum->binary_promotion_type(Attean::Literal->integer($count), '/') );
Branch: 1 branch
BranchTrueFalseTotal
!$count ? : 0 0 0
1278 }
1279 0 return $sum;
1280 0 };
1281 } elsif ($agg eq 'GROUP_CONCAT') {
1282 0 ▶ my $sep = $expr->scalar_vars->{ 'seperator' } // ' ';
Condition0%0/2
$expr->scalar_vars->{"seperator"} // " "
l!l
00
MC/DC0%0/1
$expr->scalar_vars->{"seperator"} // " "
$expr->scalar_vars->{"seperator"}
Truth table0%0/2
A
A= $expr->scalar_vars->{"seperator"}
Aresult
11
00
1283 0 ▶ return sub {
Subroutine __ANON__: not called CC=6 SCAR=37.4
1284 0 my ($rows, %args) = @_;
1285 0 my %seen;
1286 my @strings;
1287 0 foreach my $r (@$rows) {
1288 0 my $term = eval { $impl->( $r, %args ) };
1289 0 ▶ if ($expr->distinct) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr->distinct) 0 0 0
1290 0 ▶ next if ($seen{ blessed($term) ? $term->as_string : '' }++);
Branch: 2 branches
BranchTrueFalseTotal
if $seen{builtin::blessed($term) ? $term->as_string : ""}++ 0 0 0
builtin::blessed($term) ? : 0 0 0
1291 }
1292 0 ▶ push(@strings, $term->value // '');
Condition0%0/2
$term->value // ""
l!l
00
MC/DC0%0/1
$term->value // ""
$term->value
Truth table0%0/2
A
A= $term->value
Aresult
11
00
1293 }
1294 0 return Attean::Literal->new(join($sep, sort @strings));
1295 0 };
1296 } elsif ($agg eq 'FOLD') {
1297 0 ▶ return sub {
Subroutine __ANON__: not called CC=26 SCAR=65.5
1298 0 my ($rows, %args) = @_;
1299 0 my @children = @{ $expr->children };
1300 0 my @impls = map { $self->impl($_, $active_graph) } @children;
1301  
1302 0 ▶ my $order = $expr->order || [];
Condition0%0/2
$expr->order || []
l!l
00
MC/DC0%0/1
$expr->order || []
$expr->order
Truth table0%0/2
A
A= $expr->order
Aresult
11
00
1303 0 ▶ if (scalar(@$order)) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @$order) 0 0 0
1304 # sort $rows by the order condition
1305 0 my @cmps = @$order;
1306 0 my @exprs = map { $_->[1] } @cmps;
1307 0 my @dirs = map { $_->[0] eq 'ASC' } @cmps;
1308 0 my @sorted = map { $_->[0] } sort {
1309 0 my ($ar, $avalues) = @$a;
1310 0 my ($br, $bvalues) = @$b;
1311 0 my $c = 0;
1312 0 foreach my $i (0 .. $#cmps) {
1313 0 my ($av, $bv) = map { $_->[$i] } ($avalues, $bvalues);
1314 # Mirrors code in Attean::Plan::OrderBy->sort_rows
1315 0 ▶ if (not(blessed($av))) {
Branch: 4 branches
BranchTrueFalseTotal
if (not builtin::blessed($av)) { } 0 0 0
elsif (not builtin::blessed($av)) { } 0 0 0
elsif (builtin::blessed($av) and $av->does('Attean::API::Binding') and not defined $bv && $bv->does('Attean::API::Binding')) { } 0 0 0
elsif (builtin::blessed($bv) and $bv->does('Attean::API::Binding') and not defined $av && $av->does('Attean::API::Binding')) { } 0 0 0
1316 0 $c = -1;
1317 } elsif (not(blessed($av))) {
1318 0 $c = 1;
1319 ▶ } elsif (blessed($av) and $av->does('Attean::API::Binding') and (not(defined($bv)) or not($bv->does('Attean::API::Binding')))) {
Condition0%0/9
builtin::blessed($av) and $av->does("Attean::API::Binding") and not defined $bv && $bv->does("Attean::API::Binding")
!ll&&!rl&&r
000
builtin::blessed($av) and $av->does("Attean::API::Binding")
!ll&&!rl&&r
000
defined $bv && $bv->does('Attean::API::Binding')
!ll&&!rl&&r
000
MC/DC0%0/4
builtin::blessed($av) and $av->does("Attean::API::Binding") and not defined $bv && $bv->does("Attean::API::Binding")
builtin::blessed($av) $av->does("Attean::API::Binding") defined $bv $bv->does('Attean::API::Binding')
Truth table0%0/5
A and B and not(C && D)
A= builtin::blessed($av)B= $av->does("Attean::API::Binding")C= defined $bvD= $bv->does('Attean::API::Binding')
ABCDresult
0XXX0
10XX0
11110
110X1
11101
1320 0 $c = 1;
1321 ▶ } elsif (blessed($bv) and $bv->does('Attean::API::Binding') and (not(defined($av)) or not($av->does('Attean::API::Binding')))) {
Condition0%0/9
builtin::blessed($bv) and $bv->does("Attean::API::Binding") and not defined $av && $av->does("Attean::API::Binding")
!ll&&!rl&&r
000
builtin::blessed($bv) and $bv->does("Attean::API::Binding")
!ll&&!rl&&r
000
defined $av && $av->does('Attean::API::Binding')
!ll&&!rl&&r
000
MC/DC0%0/4
builtin::blessed($bv) and $bv->does("Attean::API::Binding") and not defined $av && $av->does("Attean::API::Binding")
builtin::blessed($bv) $bv->does("Attean::API::Binding") defined $av $av->does('Attean::API::Binding')
Truth table0%0/5
A and B and not(C && D)
A= builtin::blessed($bv)B= $bv->does("Attean::API::Binding")C= defined $avD= $av->does('Attean::API::Binding')
ABCDresult
0XXX0
10XX0
11110
110X1
11101
1322 0 $c = -1;
1323 } else {
1324 0 ▶ $c = eval { $av ? $av->compare($bv) : 1 };
Branch: 1 branch
BranchTrueFalseTotal
$av ? : 0 0 0
1325 0 ▶ if ($@) {
Branch: 1 branch
BranchTrueFalseTotal
if ($@) 0 0 0
1326 0 $c = 1;
1327 }
1328 }
1329 0 ▶ $c *= -1 if ($dirs[$i] == 0);
Branch: 1 branch
BranchTrueFalseTotal
if $dirs[$i] == 0 0 0 0
1330 0 ▶ last unless ($c == 0);
Branch: 1 branch
BranchTrueFalseTotal
unless $c == 0 0 0 0
1331 }
1332 $c
1333 0 } map { my $r = $_; [$r, [map { $self->evaluate_expression( $_, $r, $active_graph, {} ) } @exprs]] } @$rows;
1334 0 $rows = \@sorted;
1335 }
1336
1337
1338 0 ▶ if (scalar(@impls) > 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @impls > 1) { } 0 0 0
1339 0 my @values;
1340 0 foreach my $r (@$rows) {
1341 0 ▶ my ($key, $value) = map { eval { $_->( $r, %args ) } || undef } @impls;
Condition0%0/2
eval { do { &$_($r, %args) } } || undef
l!l
00
MC/DC0%0/1
eval { do { &$_($r, %args) } } || undef
eval { do { &$_($r, %args) } }
Truth table0%0/2
A
A= eval { do { &$_($r, %args) } }
Aresult
11
00
1342 0 ▶ if (defined($key)) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $key) 0 0 0
1343 0 push(@values, $key, $value);
1344 }
1345 }
1346 0 my $func = Attean->get_global_functional_form($AtteanX::Functions::CompositeMaps::MAP_TYPE_IRI);
1347 0 my $m = $func->(undef, undef, @values);
1348 0 return $m;
1349 } else {
1350 0 my %seen;
1351 my @values;
1352 0 foreach my $r (@$rows) {
1353 0 my $term = eval { $impl->( $r, %args ) };
1354 0 ▶ if ($expr->distinct) {
Branch: 1 branch
BranchTrueFalseTotal
if ($expr->distinct) 0 0 0
1355 0 ▶ next if ($seen{ blessed($term) ? $term->as_string : '' }++);
Branch: 2 branches
BranchTrueFalseTotal
if $seen{builtin::blessed($term) ? $term->as_string : ""}++ 0 0 0
builtin::blessed($term) ? : 0 0 0
1356 }
1357 0 push(@values, $term);
1358 }
1359 0 my $func = Attean->get_global_functional_form($AtteanX::Functions::CompositeLists::LIST_TYPE_IRI);
1360 0 my $l = $func->(undef, undef, @values);
1361 0 return $l;
1362 }
1363 0 };
1364 } else {
1365 0 warn "Unexpected aggregate expression: $agg";
1366 }
1367 } elsif ($agg eq 'CUSTOM') {
1368 0 my $iri = $expr->custom_iri;
1369 0 my $data = Attean->get_global_aggregate($iri);
1370 0 ▶ unless ($data) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($data) 0 0 0
1371 0 die "No extension aggregate registered for <$iri>";
1372 }
1373 0 my $start = $data->{'start'};
1374 0 my $process = $data->{'process'};
1375 0 my $finalize = $data->{'finalize'};
1376  
1377 0 my $impl = $self->impl($child, $active_graph);
1378 0 ▶ return sub {
Subroutine __ANON__: not called CC=2 SCAR=17.9
1379 0 my ($rows, %args) = @_;
1380 0 my $thunk = $start->($self->evaluator->model, $active_graph);
1381 0 foreach my $r (@$rows) {
1382 0 my $t = $impl->( $r, %args );
1383 0 $process->($thunk, $t);
1384 }
1385 0 return $finalize->($thunk);
1386 0 };
1387 }
1388 0 die "Unimplemented AggregateExpression evaluation: " . $expr->operator;
1389 } elsif ($expr->isa('Attean::CastExpression')) {
1390 4 my ($child) = @{ $expr->children };
1391 4 my $impl = $self->impl( $child, $active_graph );
1392 4 my $type = $expr->datatype;
1393 4 my $datatype = $expr->datatype->value;
1394 4 ▶ return sub {
Subroutine __ANON__: called CC=38 SCAR=68.2
1395 4 my ($r, %args) = @_;
1396 4 my $term = $impl->($r, %args);
1397  
1398 # TODO: the code below duplicates code in Attean::Plan::Extend. It should be refactored.
1399 # TODO: reformat syntax for xsd:double
1400 4 ▶ if ($datatype =~ m<^http://www.w3.org/2001/XMLSchema#string$>) {
Branch: 4 branches
BranchTrueFalseTotal
if ($datatype =~ m[^http://www.w3.org/2001/XMLSchema#string$]u) { } 0 4 4
elsif ($datatype =~ m[^http://www.w3.org/2001/XMLSchema#(integer|float|double|decimal)]u) { } 4 0 4
elsif ($datatype =~ m[^http://www.w3.org/2001/XMLSchema#boolean$]u) { } 0 0 0
elsif ($datatype =~ m[^http://www.w3.org/2001/XMLSchema#dateTime$]u) { } 0 0 0
1401 0 my $value = $term->value;
1402 0 ▶ if ($term->does('Attean::API::IRI')) {
Branch: 3 branches
BranchTrueFalseTotal
if ($term->does('Attean::API::IRI')) { } 0 0 0
elsif ($term->datatype->value eq 'http://www.w3.org/2001/XMLSchema#boolean') { } 0 0 0
elsif ($term->does('Attean::API::NumericLiteral')) { } 0 0 0
1403 0 return Attean::Literal->new(value => $term->value);
1404 } elsif ($term->datatype->value eq 'http://www.w3.org/2001/XMLSchema#boolean') {
1405 0 ▶ my $v = ($value eq 'true' or $value eq '1') ? 'true' : 'false';
Branch: 1 branch
BranchTrueFalseTotal
$value eq 'true' || $value eq '1' ? : 0 0 0
Condition0%0/3
$value eq "true" or $value eq 1
l!l&&r!l&&!r
000
MC/DC0%0/2
$value eq "true" or $value eq 1
$value eq "true" $value eq 1
Truth table0%0/3
A or B
A= $value eq "true"B= $value eq 1
ABresult
1X1
011
000
1406 0 return Attean::Literal->new(value => $v);
1407 } elsif ($term->does('Attean::API::NumericLiteral')) {
1408 0 my $v = $term->numeric_value();
1409 0 ▶ if ($v == int($v)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($v == int $v) 0 0 0
1410 0 return Attean::Literal->new(value => int($v));
1411 }
1412 }
1413
1414 0 return Attean::Literal->new(value => $value);
1415 } elsif ($datatype =~ m<^http://www.w3.org/2001/XMLSchema#(integer|float|double|decimal)>) {
1416 4 my $value = $term->value;
1417 4 my $num;
1418 4 ▶ if ($datatype eq 'http://www.w3.org/2001/XMLSchema#integer') {
Branch: 3 branches
BranchTrueFalseTotal
if ($datatype eq 'http://www.w3.org/2001/XMLSchema#integer') { } 0 4 4
elsif ($datatype eq 'http://www.w3.org/2001/XMLSchema#decimal') { } 4 0 4
elsif ($datatype =~ m[^http://www.w3.org/2001/XMLSchema#(float|double)$]u) { } 0 0 0
1419 0 ▶ if ($term->datatype->value eq 'http://www.w3.org/2001/XMLSchema#boolean') {
Branch: 3 branches
BranchTrueFalseTotal
if ($term->datatype->value eq 'http://www.w3.org/2001/XMLSchema#boolean') { } 0 0 0
elsif ($term->does('Attean::API::NumericLiteral')) { } 0 0 0
elsif ($value =~ /^[-+]\d+$/u) { } 0 0 0
1420 0 ▶ $value = ($value eq 'true' or $value eq '1') ? '1' : '0';
Branch: 1 branch
BranchTrueFalseTotal
$value eq 'true' || $value eq '1' ? : 0 0 0
Condition0%0/3
$value eq "true" or $value eq 1
l!l&&r!l&&!r
000
MC/DC0%0/2
$value eq "true" or $value eq 1
$value eq "true" $value eq 1
Truth table0%0/3
A or B
A= $value eq "true"B= $value eq 1
ABresult
1X1
011
000
1421 } elsif ($term->does('Attean::API::NumericLiteral')) {
1422 0 my $v = $term->numeric_value();
1423 0 $v =~ s/[.].*$//;
1424 0 $value = int($v);
1425 } elsif ($value =~ /^[-+]\d+$/) {
1426 0 my ($v) = "$value";
1427 0 $v =~ s/[.].*$//;
1428 0 $value = int($v);
1429 }
1430 0 $num = $value;
1431 } elsif ($datatype eq 'http://www.w3.org/2001/XMLSchema#decimal') {
1432 4 ▶ if ($term->datatype->value eq 'http://www.w3.org/2001/XMLSchema#boolean') {
Branch: 3 branches
BranchTrueFalseTotal
if ($term->datatype->value eq 'http://www.w3.org/2001/XMLSchema#boolean') { } 0 4 4
elsif ($term->does('Attean::API::NumericLiteral')) { } 4 0 4
elsif (&looks_like_number($value)) { } 0 0 0
1433 0 ▶ $value = ($value eq 'true') ? '1' : '0';
Branch: 1 branch
BranchTrueFalseTotal
$value eq 'true' ? : 0 0 0
1434 } elsif ($term->does('Attean::API::NumericLiteral')) {
1435 4 $value = $term->numeric_value;
1436 } elsif (looks_like_number($value)) {
1437 0 ▶ if ($value =~ /[eE]/) { # double
Branch: 1 branch
BranchTrueFalseTotal
if ($value =~ /[eE]/u) 0 0 0
1438 0 die "cannot cast to xsd:decimal as precision would be lost";
1439 }
1440 0 $value = +$value;
1441 }
1442 4 $num = "$value";
1443 4 $num =~ s/[.]0+$/.0/;
1444 4 $num =~ s/[.](\d+)0*$/.$1/;
1445 } elsif ($datatype =~ m<^http://www.w3.org/2001/XMLSchema#(float|double)$>) {
1446 0 my $typename = $1;
1447 0 ▶ if ($term->datatype->value eq 'http://www.w3.org/2001/XMLSchema#boolean') {
Branch: 4 branches
BranchTrueFalseTotal
if ($term->datatype->value eq 'http://www.w3.org/2001/XMLSchema#boolean') { } 0 0 0
elsif ($term->does('Attean::API::NumericLiteral')) { } 0 0 0
elsif (&looks_like_number($value)) { } 0 0 0
elsif ($value =~ /^(.*)[eE][-+]?\d+$/u) { } 0 0 0
1448 0 ▶ $value = ($value eq 'true') ? '1.0' : '0.0';
Branch: 1 branch
BranchTrueFalseTotal
$value eq 'true' ? : 0 0 0
1449 } elsif ($term->does('Attean::API::NumericLiteral')) {
1450 # no-op
1451 } elsif (looks_like_number($value)) {
1452 0 $value = +$value;
1453 } elsif ($value =~ /^(.*)[eE][-+]?\d+$/) { #} and looks_like_number($1)) {
1454 0 $value = +$value;
1455 } else {
1456 0 die "cannot cast unrecognized value '$value' to xsd:$typename";
1457 }
1458 0 $num = sprintf("%e", $value);
1459 }
1460 4 my $c = Attean::Literal->new(value => $num, datatype => $expr->datatype);
1461 4 ▶ if (my $term = $c->canonicalized_term_strict()) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $term = $c->canonicalized_term_strict) { } 4 0 4
1462 4 return $term;
1463 } else {
1464 0 die "Term value is not a valid lexical form for $datatype";
1465 }
1466 } elsif ($datatype =~ m<^http://www.w3.org/2001/XMLSchema#boolean$>) {
1467 0 ▶ if ($term->does('Attean::API::NumericLiteral')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($term->does('Attean::API::NumericLiteral')) { } 0 0 0
1468 0 my $value = $term->numeric_value;
1469 0 ▶ return ($value == 0) ? Attean::Literal->false : Attean::Literal->true;
Branch: 1 branch
BranchTrueFalseTotal
$value == 0 ? : 0 0 0
1470 } else {
1471 0 my $value = $term->value;
1472 0 ▶ if ($value =~ m/^(true|false|0|1)$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($value =~ /^(true|false|0|1)$/u) { } 0 0 0
1473 0 ▶ return ($value eq 'true' or $value eq '1') ? Attean::Literal->true : Attean::Literal->false;
Branch: 1 branch
BranchTrueFalseTotal
$value eq 'true' || $value eq '1' ? : 0 0 0
Condition0%0/3
$value eq "true" or $value eq 1
l!l&&r!l&&!r
000
MC/DC0%0/2
$value eq "true" or $value eq 1
$value eq "true" $value eq 1
Truth table0%0/3
A or B
A= $value eq "true"B= $value eq 1
ABresult
1X1
011
000
1474 } else {
1475 0 die "Bad lexical form for xsd:boolean: '$value'";
1476 }
1477 }
1478 } elsif ($datatype =~ m<^http://www.w3.org/2001/XMLSchema#dateTime$>) {
1479 0 my $value = $term->value;
1480 0 my $c = Attean::Literal->new(value => $value, datatype => $expr->datatype);
1481 0 ▶ if ($c->does('Attean::API::DateTimeLiteral') and $c->datetime) {
Branch: 1 branch
BranchTrueFalseTotal
if ($c->does('Attean::API::DateTimeLiteral') and $c->datetime) { } 0 0 0
Condition0%0/3
$c->does("Attean::API::DateTimeLiteral") and $c->datetime
!ll&&!rl&&r
000
MC/DC0%0/2
$c->does("Attean::API::DateTimeLiteral") and $c->datetime
$c->does("Attean::API::DateTimeLiteral") $c->datetime
Truth table0%0/3
A and B
A= $c->does("Attean::API::DateTimeLiteral")B= $c->datetime
ABresult
0X0
100
111
1482 0 return $c;
1483 } else {
1484 0 die "Bad lexical form for xsd:dateTime: '$value'";
1485 }
1486 }
1487  
1488  
1489 0 my $cast = Attean::Literal->new( value => $term->value, datatype => $type );
1490 0 ▶ if ($cast->does('Attean::API::CanonicalizingLiteral')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($cast->does("Attean::API::CanonicalizingLiteral")) 0 0 0
1491 0 return $cast->canonicalized_term_strict();
1492 }
1493 0 return $cast;
1494 }
1495 4 } else {
1496 0 Carp::confess "No impl for expression " . $expr->as_string;
1497 }
1498 }
1499 }
1500  
1501 3 1;
1502  
1503 __END__
« Attean/Plan.pm ↑ Summary Attean/QueryPlanner.pm »