RDF::Query::Plan::Limit - Executable query plan for Limits.

RDF-Query documentation Contained in the RDF-Query distribution.

Index

Code Index:

NAME

Top

RDF::Query::Plan::Limit - Executable query plan for Limits.

VERSION

Top

This document describes RDF::Query::Plan::Limit version 2.907.

METHODS

Top

Beyond the methods documented below, this class inherits methods from the RDF::Query::Plan class.

new ( $plan, $limit )
execute ( $execution_context )
next
close
pattern

Returns the query plan that will be used to produce the data to be filtered.

limit

Returns the limit size.

distinct

Returns true if the pattern is guaranteed to return distinct results.

ordered

Returns true if the pattern is guaranteed to return ordered results.

plan_node_name

Returns the string name of this plan node, suitable for use in serialization.

plan_prototype

Returns a list of scalar identifiers for the type of the content (children) nodes of this plan node. See RDF::Query::Plan for a list of the allowable identifiers.

plan_node_data

Returns the data for this plan node that corresponds to the values described by the signature returned by plan_prototype.

graph ( $g )

AUTHOR

Top

 Gregory Todd Williams <gwilliams@cpan.org>
RDF-Query documentation Contained in the RDF-Query distribution. 
# RDF::Query::Plan::Limit
# -----------------------------------------------------------------------------


package RDF::Query::Plan::Limit;

use strict;
use warnings;
use base qw(RDF::Query::Plan);

######################################################################

our ($VERSION);
BEGIN {
	$VERSION	= '2.907';
}

######################################################################


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;
}


sub execute ($) {
	my $self	= shift;
	my $context	= shift;
	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;
}


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}++;
	return $row;
}


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();
}


sub pattern {
	my $self	= shift;
	return $self->[2];
}


sub limit {
	my $self	= shift;
	return $self->[1];
}


sub distinct {
	my $self	= shift;
	return $self->pattern->distinct;
}


sub ordered {
	my $self	= shift;
	return $self->pattern->ordered;
}


sub plan_node_name {
	return 'limit';
}


sub plan_prototype {
	my $self	= shift;
	return qw(i P);
}


sub plan_node_data {
	my $self	= shift;
	return ($self->limit, $self->pattern);
}


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__