# RDF::Query::Plan::Limit
# -----------------------------------------------------------------------------
=head1 NAME
RDF::Query::Plan::Limit - Executable query plan for Limits.
=head1 VERSION
This document describes RDF::Query::Plan::Limit version 2.918.
=head1 METHODS
Beyond the methods documented below, this class inherits methods from the
L<RDF::Query::Plan> class.
=over 4
=cut
package RDF::Query::Plan::Limit;
use strict;
use warnings;
use base qw(RDF::Query::Plan);
######################################################################
our ($VERSION);
BEGIN {
$VERSION = '2.918';
}
######################################################################
=item C<< new ( $plan, $limit ) >>
=cut
sub new {
my $class = shift;
my $limit = shift;
my $plan = shift;
my $self = $class->SUPER::new( $limit, $plan );
$self->[0]{referenced_variables} = [ $plan->referenced_variables ];
return $self;
}
=item C<< execute ( $execution_context ) >>
=cut
sub execute ($) {
my $self = shift;
my $context = shift;
$self->[0]{delegate} = $context->delegate;
if ($self->state == $self->OPEN) {
throw RDF::Query::Error::ExecutionError -text => "LIMIT plan can't be executed while already open";
}
my $plan = $self->[2];
$plan->execute( $context );
if ($plan->state == $self->OPEN) {
$self->state( $self->OPEN );
$self->[0]{count} = 0;
} else {
warn "could not execute plan in LIMIT";
}
$self;
}
=item C<< next >>
=cut
sub next {
my $self = shift;
unless ($self->state == $self->OPEN) {
throw RDF::Query::Error::ExecutionError -text => "next() cannot be called on an un-open LIMIT";
}
return undef if ($self->[0]{count} >= $self->limit);
my $plan = $self->[2];
my $row = $plan->next;
return undef unless ($row);
$self->[0]{count}++;
if (my $d = $self->delegate) {
$d->log_result( $self, $row );
}
return $row;
}
=item C<< close >>
=cut
sub close {
my $self = shift;
unless ($self->state == $self->OPEN) {
throw RDF::Query::Error::ExecutionError -text => "close() cannot be called on an un-open LIMIT";
}
delete $self->[0]{count};
$self->[2]->close();
$self->SUPER::close();
}
=item C<< pattern >>
Returns the query plan that will be used to produce the data to be filtered.
=cut
sub pattern {
my $self = shift;
return $self->[2];
}
=item C<< limit >>
Returns the limit size.
=cut
sub limit {
my $self = shift;
return $self->[1];
}
=item C<< distinct >>
Returns true if the pattern is guaranteed to return distinct results.
=cut
sub distinct {
my $self = shift;
return $self->pattern->distinct;
}
=item C<< ordered >>
Returns true if the pattern is guaranteed to return ordered results.
=cut
sub ordered {
my $self = shift;
return $self->pattern->ordered;
}
=item C<< plan_node_name >>
Returns the string name of this plan node, suitable for use in serialization.
=cut
sub plan_node_name {
return 'limit';
}
=item C<< plan_prototype >>
Returns a list of scalar identifiers for the type of the content (children)
nodes of this plan node. See L<RDF::Query::Plan> for a list of the allowable
identifiers.
=cut
sub plan_prototype {
my $self = shift;
return qw(i P);
}
=item C<< plan_node_data >>
Returns the data for this plan node that corresponds to the values described by
the signature returned by C<< plan_prototype >>.
=cut
sub plan_node_data {
my $self = shift;
return ($self->limit, $self->pattern);
}
=item C<< graph ( $g ) >>
=cut
sub graph {
my $self = shift;
my $g = shift;
my $c = $self->pattern->graph( $g );
my $limit = $self->limit;
$g->add_node( "$self", label => "Limit ($limit)" . $self->graph_labels );
$g->add_edge( "$self", $c );
return "$self";
}
1;
__END__
=back
=head1 AUTHOR
Gregory Todd Williams <gwilliams@cpan.org>
=cut