File Coverage

blib/lib/RDF/Query/Algebra/Service.pm
Criterion Covered Total %
statement 38 106 35.8
branch 0 18 0.0
condition 0 4 0.0
subroutine 13 27 48.1
pod 14 14 100.0
total 65 169 38.4


line stmt bran cond sub pod time code
1             # RDF::Query::Algebra::Service
2             # -----------------------------------------------------------------------------
3              
4             =head1 NAME
5              
6             RDF::Query::Algebra::Service - Algebra class for SERVICE (federation) patterns
7              
8             =head1 VERSION
9              
10             This document describes RDF::Query::Algebra::Service version 2.915_01.
11              
12             =cut
13              
14             package RDF::Query::Algebra::Service;
15              
16 36     36   182 use strict;
  36         64  
  36         890  
17 36     36   177 use warnings;
  36         66  
  36         942  
18 36     36   178 use base qw(RDF::Query::Algebra);
  36         63  
  36         2466  
19              
20 36     36   189 use Log::Log4perl;
  36         70  
  36         256  
21 36     36   1476 use URI::Escape;
  36         74  
  36         2328  
22 36     36   27507 use MIME::Base64;
  36         26430  
  36         2208  
23 36     36   261 use Data::Dumper;
  36         68  
  36         1593  
24 36     36   194 use RDF::Query::Error;
  36         66  
  36         244  
25 36     36   1685 use Carp qw(carp croak confess);
  36         68  
  36         1969  
26 36     36   185 use Scalar::Util qw(blessed reftype);
  36         65  
  36         1870  
27 36     36   182 use Storable qw(store_fd fd_retrieve);
  36         68  
  36         2095  
28 36     36   197 use RDF::Trine::Iterator qw(sgrep smap swatch);
  36         76  
  36         3172  
29              
30             ######################################################################
31              
32             our ($VERSION, $BLOOM_FILTER_ERROR_RATE);
33             BEGIN {
34 36     36   85 $BLOOM_FILTER_ERROR_RATE = 0.1;
35 36         37880 $VERSION = '2.915_01';
36             }
37              
38             ######################################################################
39              
40             =head1 METHODS
41              
42             Beyond the methods documented below, this class inherits methods from the
43             L<RDF::Query::Algebra> class.
44              
45             =over 4
46              
47             =cut
48              
49             =item C<new ( $endpoint, $pattern, $silent )>
50              
51             Returns a new Service structure.
52              
53             =cut
54              
55             sub new {
56 0     0 1   my $class = shift;
57 0           my $endpoint = shift;
58 0           my $pattern = shift;
59 0   0       my $silent = shift || 0;
60 0           my $ggp = shift;
61 0           return bless( [ 'SERVICE', $endpoint, $pattern, $silent, $ggp ], $class );
62             }
63              
64             =item C<< construct_args >>
65              
66             Returns a list of arguments that, passed to this class' constructor,
67             will produce a clone of this algebra pattern.
68              
69             =cut
70              
71             sub construct_args {
72 0     0 1   my $self = shift;
73 0           return ($self->endpoint, $self->pattern, $self->silent, $self->lhs);
74             }
75              
76             =item C<< endpoint >>
77              
78             Returns the endpoint resource of the named graph expression.
79              
80             =cut
81              
82             sub endpoint {
83 0     0 1   my $self = shift;
84 0 0         if (@_) {
85 0           my $endpoint = shift;
86 0           $self->[1] = $endpoint;
87             }
88 0           my $endpoint = $self->[1];
89 0           return $endpoint;
90             }
91              
92             =item C<< pattern >>
93              
94             Returns the graph pattern of the named graph expression.
95              
96             =cut
97              
98             sub pattern {
99 0     0 1   my $self = shift;
100 0 0         if (@_) {
101 0           my $pattern = shift;
102 0           $self->[2] = $pattern;
103             }
104 0           return $self->[2];
105             }
106              
107             =item C<< silent >>
108              
109             Returns true if the service operation is to ignore errors during execution.
110              
111             =cut
112              
113             sub silent {
114 0     0 1   my $self = shift;
115 0           return $self->[3];
116             }
117              
118             =item C<< lhs >>
119              
120             If the SERVCE operation uses a variable endpoint, then it is considered a binary
121             operator, executing the left-hand-side pattern first, and using results from it
122             to bind endpoint URL values to use in SERVICE evaluation.
123              
124             =cut
125              
126             sub lhs {
127 0     0 1   my $self = shift;
128 0           return $self->[4];
129             }
130              
131             =item C<< sse >>
132              
133             Returns the SSE string for this algebra expression.
134              
135             =cut
136              
137             sub sse {
138 0     0 1   my $self = shift;
139 0           my $context = shift;
140 0   0       my $prefix = shift || '';
141 0           my $indent = $context->{indent};
142            
143 0 0         if (my $ggp = $self->lhs) {
144 0           return sprintf(
145             "(service\n${prefix}${indent}%s\n${prefix}${indent}%s\n${prefix}${indent}%s)",
146             $self->lhs->sse( $context, "${prefix}${indent}" ),
147             $self->endpoint->sse( $context, "${prefix}${indent}" ),
148             $self->pattern->sse( $context, "${prefix}${indent}" )
149             );
150             } else {
151 0           return sprintf(
152             "(service\n${prefix}${indent}%s\n${prefix}${indent}%s)",
153             $self->endpoint->sse( $context, "${prefix}${indent}" ),
154             $self->pattern->sse( $context, "${prefix}${indent}" )
155             );
156             }
157             }
158              
159             =item C<< as_sparql >>
160              
161             Returns the SPARQL string for this algebra expression.
162              
163             =cut
164              
165             sub as_sparql {
166 0     0 1   my $self = shift;
167 0           my $context = shift;
168 0           my $indent = shift;
169 0 0         my $op = ($self->silent) ? 'SERVICE SILENT' : 'SERVICE';
170 0 0         if (my $ggp = $self->lhs) {
171 0           local($context->{skip_filter}) = 0;
172 0           my $string = sprintf(
173             "%s\n${indent}%s %s %s",
174             $ggp->as_sparql( $context, $indent ),
175             $op,
176             $self->endpoint->as_sparql( $context, $indent ),
177             $self->pattern->as_sparql( { %$context, force_ggp_braces => 1 }, $indent ),
178             );
179 0           return $string;
180             } else {
181 0           my $string = sprintf(
182             "%s %s %s",
183             $op,
184             $self->endpoint->as_sparql( $context, $indent ),
185             $self->pattern->as_sparql( { %$context, force_ggp_braces => 1 }, $indent ),
186             );
187 0           return $string;
188             }
189             }
190              
191             =item C<< as_hash >>
192              
193             Returns the query as a nested set of plain data structures (no objects).
194              
195             =cut
196              
197             sub as_hash {
198 0     0 1   my $self = shift;
199 0           my $context = shift;
200             return {
201 0           type => lc($self->type),
202             endpoint => $self->endpoint,
203             pattern => $self->pattern->as_hash,
204             lhs => $self->lhs->as_hash,
205             };
206             }
207              
208             =item C<< type >>
209              
210             Returns the type of this algebra expression.
211              
212             =cut
213              
214             sub type {
215 0     0 1   return 'SERVICE';
216             }
217              
218             =item C<< referenced_variables >>
219              
220             Returns a list of the variable names used in this algebra expression.
221              
222             =cut
223              
224             sub referenced_variables {
225 0     0 1   my $self = shift;
226 0           my @list = $self->pattern->referenced_variables;
227 0 0         push(@list, $self->lhs->referenced_variables) if ($self->lhs);
228 0           return RDF::Query::_uniq(@list);
229             }
230              
231             =item C<< potentially_bound >>
232              
233             Returns a list of the variable names used in this algebra expression that will
234             bind values during execution.
235              
236             =cut
237              
238             sub potentially_bound {
239 0     0 1   my $self = shift;
240 0           my @list = RDF::Query::_uniq($self->pattern->potentially_bound);
241 0 0         if ($self->lhs) {
242 0           push(@list, $self->lhs->potentially_bound);
243             }
244 0           return @list;
245             }
246              
247             =item C<< definite_variables >>
248              
249             Returns a list of the variable names that will be bound after evaluating this algebra expression.
250              
251             =cut
252              
253             sub definite_variables {
254 0     0 1   my $self = shift;
255             return RDF::Query::_uniq(
256 0 0         map { $_->name } grep { $_->isa('RDF::Query::Node::Variable') } ($self->graph),
  0            
  0            
257             $self->pattern->definite_variables,
258             ($self->lhs ? $self->lhs->definite_variables : ()),
259             );
260             }
261              
262              
263             =item C<< qualify_uris ( \%namespaces, $base_uri ) >>
264              
265             Returns a new algebra pattern where all referenced Resource nodes representing
266             QNames (ns:local) are qualified using the supplied %namespaces.
267              
268             =cut
269              
270             sub qualify_uris {
271 0     0 1   my $self = shift;
272 0           my $class = ref($self);
273 0           my $ns = shift;
274 0           my $base_uri = shift;
275            
276 0           my $pattern = $self->pattern->qualify_uris( $ns, $base_uri );
277 0           my $endpoint = $self->endpoint;
278 0           my $silent = $self->silent;
279 0           my $uri = $endpoint->uri;
280 0 0         if (my $ggp = $self->lhs) {
281 0           return $class->new( $endpoint, $pattern, $silent, $ggp->qualify_uris($ns, $base_uri) );
282             } else {
283 0           return $class->new( $endpoint, $pattern, $silent );
284             }
285             }
286              
287             1;
288              
289             __END__
290              
291             =back
292              
293             =head1 AUTHOR
294              
295             Gregory Todd Williams <gwilliams@cpan.org>
296              
297             =cut