# RDF::Query::Plan::Constant # ----------------------------------------------------------------------------- =head1 NAME RDF::Query::Plan::Constant - Executable query plan for Constants. =head1 VERSION This document describes RDF::Query::Plan::Constant version 2.919. =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::Constant; use strict; use warnings; use base qw(RDF::Query::Plan); ###################################################################### our ($VERSION); BEGIN { $VERSION = '2.919'; } ###################################################################### =item C<< new ( @variable_bindings ) >> =cut sub new { my $class = shift; my @binds = @_; my $self = $class->SUPER::new( \@binds ); $self->[0]{referenced_variables} = [ keys %{ $binds[0] } ]; 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 => "CONSTANT plan can't be executed while already open"; } $self->[0]{'index'} = 0; $self->state( $self->OPEN ); $self; } =item C<< bindings >> Returns a list of the variable bindings for this constant result set. =cut sub bindings { my $self = shift; my $binds = $self->[1] || []; return @$binds; } =item C<< is_unit >> Returns true if this constant result set is comprised of a single, empty variable binding. =cut sub is_unit { my $self = shift; my @binds = $self->bindings; return 0 unless scalar(@binds) == 1; my @keys = keys %{ $binds[0] }; return not(scalar(@keys)); } =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 CONSTANT"; } my $binds = $self->[1]; if ($self->[0]{'index'} > $#{ $binds }) { return; } my $row = $binds->[ $self->[0]{'index'}++ ]; if ($row) { my $bindings = RDF::Query::VariableBindings->new( $row ); if (my $d = $self->delegate) { $d->log_result( $self, $bindings ); } return $bindings; } else { return; } } =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 CONSTANT"; } delete $self->[0]{'index'}; $self->SUPER::close(); } =item C<< size >> =cut sub size { my $self = shift; return scalar( @{ $self->[1] } ); } =item C<< distinct >> Returns true if the pattern is guaranteed to return distinct results. =cut sub distinct { # XXX could check constant data to determine if it's unique return 0; } =item C<< ordered >> Returns true if the pattern is guaranteed to return ordered results. =cut sub ordered { # XXX could check constant data to determine if it's ordered return []; } =item C<< plan_node_name >> Returns the string name of this plan node, suitable for use in serialization. =cut sub plan_node_name { return 'table'; } =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(*V); } =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; my $binds = $self->[1]; return @$binds; } 1; __END__ =back =head1 AUTHOR Gregory Todd Williams <gwilliams@cpan.org> =cut