RDF::Query::Algebra::Union - Algebra class for Union patterns

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

Index

Code Index:

NAME

Top

RDF::Query::Algebra::Union - Algebra class for Union patterns

VERSION

Top

This document describes RDF::Query::Algebra::Union version 2.907.

METHODS

Top

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

new ( $left, $right )

Returns a new Union structure.

construct_args

Returns a list of arguments that, passed to this class' constructor, will produce a clone of this algebra pattern.

first

Returns the first pattern (LHS) of the union.

second

Returns the second pattern (RHS) of the union.

patterns

Returns the two patterns belonging to the UNION pattern.

sse

Returns the SSE string for this algebra expression.

as_sparql

Returns the SPARQL string for this algebra expression.

as_hash

Returns the query as a nested set of plain data structures (no objects).

type

Returns the type of this algebra expression.

referenced_variables

Returns a list of the variable names used in this algebra expression.

potentially_bound

Returns a list of the variable names used in this algebra expression that will bind values during execution.

definite_variables

Returns a list of the variable names that will be bound after evaluating this algebra expression.

AUTHOR

Top

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


package RDF::Query::Algebra::Union;

use strict;
use warnings;
no warnings 'redefine';
use base qw(RDF::Query::Algebra);

use Data::Dumper;
use Set::Scalar;
use Log::Log4perl;
use Scalar::Util qw(blessed);
use Carp qw(carp croak confess);

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

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

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


sub new {
	my $class	= shift;
	my $left	= shift;
	my $right	= shift;
	return bless( [ 'UNION', $left, $right ], $class );
}


sub construct_args {
	my $self	= shift;
	return ($self->first, $self->second);
}


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


sub patterns {
	my $self	= shift;
	return ($self->first, $self->second);
}

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


sub sse {
	my $self	= shift;
	my $context	= shift;
	my $prefix	= shift || '';
	my $indent	= $context->{indent} || '  ';
	
	return sprintf(
		"(union\n${prefix}${indent}%s\n${prefix}${indent}%s)",
		$self->first->sse( $context, "${prefix}${indent}" ),
		$self->second->sse( $context, "${prefix}${indent}" )
	);
}


sub as_sparql {
	my $self	= shift;
	my $context	= shift;
	my $indent	= shift;
	my $string	= sprintf(
		"%s\n${indent}UNION\n${indent}%s",
		$self->first->as_sparql( { %$context, force_ggp_braces => 1 }, $indent ),
		$self->second->as_sparql( { %$context, force_ggp_braces => 1 }, $indent ),
	);
	return $string;
}


sub as_hash {
	my $self	= shift;
	my $context	= shift;
	return {
		type 		=> lc($self->type),
		patterns	=> [ map { $_->as_hash } $self->patterns ],
	};
}


sub type {
	return 'UNION';
}


sub referenced_variables {
	my $self	= shift;
	return RDF::Query::_uniq($self->first->referenced_variables, $self->second->referenced_variables);
}


sub potentially_bound {
	my $self	= shift;
	return RDF::Query::_uniq($self->first->potentially_bound, $self->second->potentially_bound);
}


sub definite_variables {
	my $self	= shift;
	my $seta	= Set::Scalar->new( $self->first->definite_variables );
	my $setb	= Set::Scalar->new( $self->second->definite_variables );
	return $seta->intersection( $setb )->members;
}

1;

__END__