—
—
—
—
—
—
—
—
—
—
—
—
—
—

              
# RDF::Query::Algebra::Distinct
# -----------------------------------------------------------------------------
HideShow 10 lines of Pod
=head1 NAME
RDF::Query::Algebra::Distinct - Algebra class for distinct query results
=head1 VERSION
This document describes RDF::Query::Algebra::Distinct version 2.906.
=cut
package RDF::Query::Algebra::Distinct;
use strict;
use warnings;
no warnings 'redefine';
use base qw(RDF::Query::Algebra);
use Data::Dumper;
use Set::Scalar;
use Scalar::Util qw(blessed);
use Carp qw(carp croak confess);
use RDF::Trine::Iterator qw(sgrep);
######################################################################
our ($VERSION);
BEGIN {
        $VERSION        = '2.906';
}
######################################################################
HideShow 15 lines of Pod
=head1 METHODS
Beyond the methods documented below, this class inherits methods from the
L<RDF::Query::Algebra> class.
=over 4
=cut
=item C<< new ( $pattern ) >>
Returns a new Sort structure.
=cut
sub new {
        my $class       = shift;
        my $pattern     = shift;
        return bless( [ $pattern ], $class );
}
HideShow 7 lines of Pod
=item C<< construct_args >>
Returns a list of arguments that, passed to this class' constructor,
will produce a clone of this algebra pattern.
=cut
sub construct_args {
        my $self        = shift;
        my $pattern     = $self->pattern;
        return ($pattern);
}
HideShow 6 lines of Pod
=item C<< pattern >>
Returns the pattern to be sorted.
=cut
sub pattern {
        my $self        = shift;
        if (@_) {
                $self->[0]   = shift;
        }
        return $self->[0];
}
HideShow 6 lines of Pod
=item C<< sse >>
Returns the SSE string for this algebra expression.
=cut
sub sse {
        my $self        = shift;
        my $context     = shift;
        my $prefix      = shift || '';
        my $indent      = $context->{indent} || '  ';
         
        return sprintf(
                "(distinct\n${prefix}${indent}%s)",
                $self->pattern->sse( $context, "${prefix}${indent}" ),
        );
}
HideShow 6 lines of Pod
=item C<< as_sparql >>
Returns the SPARQL string for this algebra expression.
=cut
sub as_sparql {
        my $self        = shift;
        my $context     = shift;
        my $indent      = shift;
         
        return 'DISTINCT ' . $self->pattern->as_sparql( $context, $indent );
}
HideShow 6 lines of Pod
=item C<< as_hash >>
Returns the query as a nested set of plain data structures (no objects).
=cut
sub as_hash {
        my $self        = shift;
        my $context     = shift;
        return {
                type            => lc($self->type),
                pattern         => $self->pattern->as_hash,
        };
}
HideShow 7 lines of Pod
=item C<< as_spin ( $model ) >>
Adds statements to the given model to represent this algebra object in the
SPARQL Inferencing Notation (L<http://www.spinrdf.org/>).
=cut
sub as_spin {
        my $self        = shift;
        my $model       = shift;
        my $spin        = RDF::Trine::Namespace->new('http://spinrdf.org/spin#');
        my $xsd         = RDF::Trine::Namespace->new('http://www.w3.org/2001/XMLSchema#');
        my $q           = $self->pattern->as_spin( $model );
         
        $model->add_statement( RDF::Trine::Statement->new($q, $spin->distinct, RDF::Query::Node::Literal->new('true', undef, $xsd->boolean)) );
         
        return $q;
}
HideShow 6 lines of Pod
=item C<< type >>
Returns the type of this algebra expression.
=cut
sub type {
        return 'DISTINCT';
}
HideShow 6 lines of Pod
=item C<< referenced_variables >>
Returns a list of the variable names used in this algebra expression.
=cut
sub referenced_variables {
        my $self        = shift;
        return RDF::Query::_uniq($self->pattern->referenced_variables);
}
HideShow 7 lines of Pod
=item C<< potentially_bound >>
Returns a list of the variable names used in this algebra expression that will
bind values during execution.
=cut
sub potentially_bound {
        my $self        = shift;
        return $self->pattern->potentially_bound;
}
HideShow 6 lines of Pod
=item C<< definite_variables >>
Returns a list of the variable names that will be bound after evaluating this algebra expression.
=cut
sub definite_variables {
        my $self        = shift;
        return $self->pattern->definite_variables;
}
HideShow 6 lines of Pod
=item C<< is_solution_modifier >>
Returns true if this node is a solution modifier.
=cut
sub is_solution_modifier {
        return 1;
}
1;
__END__
HideShow 8 lines of Pod
=back
=head1 AUTHOR
 Gregory Todd Williams <gwilliams@cpan.org>
=cut