RDF::Query::Plan::Distinct - Executable query plan for Distincts.

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

Index

Code Index:

NAME

Top

RDF::Query::Plan::Distinct - Executable query plan for Distincts.

VERSION

Top

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

METHODS

Top

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

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

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

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::Distinct
# -----------------------------------------------------------------------------


package RDF::Query::Plan::Distinct;

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

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

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

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


sub new {
	my $class	= shift;
	my $plan	= shift;
	my $self	= $class->SUPER::new( $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 => "DISTINCT plan can't be executed while already open";
	}
	my $plan	= $self->[1];
	$plan->execute( $context );

	if ($plan->state == $self->OPEN) {
		$self->[0]{seen}	= {};
		$self->state( $self->OPEN );
	} else {
		warn "could not execute plan in distinct";
	}
	$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 DISTINCT";
	}
	my $plan	= $self->[1];
	while (1) {
		my $row	= $plan->next;
		return undef unless ($row);
		if (not $self->[0]{seen}{ $row->as_string }++) {
			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 DISTINCT";
	}
	delete $self->[0]{seen};
	$self->[1]->close();
	$self->SUPER::close();
}


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


sub distinct {
	return 1;
}


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


sub plan_node_name {
	return 'distinct';
}


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


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


sub graph {
	my $self	= shift;
	my $g		= shift;
	my $c		= $self->pattern->graph( $g );
	$g->add_node( "$self", label => "Distinct" . $self->graph_labels );
	$g->add_edge( "$self", $c );
	return "$self";
}


1;

__END__