RDF::Trine::Model::Dataset - Model for SPARQL datasets

# RDF::Trine::Model::Dataset
# -----------------------------------------------------------------------------

package RDF::Trine::Model::Dataset;

use strict;
use warnings;
no warnings 'redefine';
use base qw(RDF::Trine::Model);
use Scalar::Util qw(blessed);

use RDF::Trine::Model;

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

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

sub new {
	my $class	= shift;
	my $model	= shift;
	my $self	= bless({ model => $model, stack => [] }, $class);
}

sub push_dataset {
	my $self	= shift;
	my %dataset	= @_;
	
	my @dgraphs	= @{ $dataset{ default } || [] };
	unshift(@{ $self->{ stack } }, { default => {}, named => {} });
	foreach my $graph (@dgraphs) {
		my $name	= blessed($graph) ? $graph->uri_value : $graph;
		$graph		= blessed($graph) ? $graph : RDF::Trine::Node::Resource->new( $graph );
		$self->{stack}[0]{default}{$name}	= $graph;
	}
	
	my @ngraphs	= @{ $dataset{ named } || [] };
	foreach my $graph (@ngraphs) {
		my $name	= blessed($graph) ? $graph->uri_value : $graph;
		$graph		= blessed($graph) ? $graph : RDF::Trine::Node::Resource->new( $graph );
		$self->{stack}[0]{named}{$name}	= $graph;
	}
	
	return 1;
}

sub pop_dataset {
	my $self	= shift;
	shift(@{ $self->{ stack } });
	return 1;
}

 
sub temporary_model {
	my $class	= shift;
	my $model	= RDF::Trine::Model->temporary_model;
	return $class->new( $model );
}

sub add_hashref {
	my $self	= shift;
	return $self->model->add_hashref( @_ );
}

sub size {
	my $self	= shift;
	return $self->count_statements( undef, undef, undef, undef );
}

sub supports {
	my $self	= shift;
	my $store	= $self->_store;
	if ($store) {
		return $store->supports( @_ );
	}
	return;
}

sub count_statements {
	my $self	= shift;
	return $self->model->count_statements( @_ ) unless (scalar(@{ $self->{stack} }));
	my $use_quad	= (scalar(@_) >= 4);
	if ($use_quad) {
# 		warn "counting quads with dataset";
		my $quad	= $_[3];
		if (blessed($quad) and $quad->isa('RDF::Trine::Node::Nil')) {
# 			warn "- default graph query";
# 			warn "- " . join(', ', keys %{ $self->{stack}[0] });
			my $count	= 0;
			foreach my $g (values %{ $self->{stack}[0]{default} }) {
				$count	+= $self->model->count_statements( @_[0..2], $g );
# 				warn "$count statments in graph " . $g->uri_value;
			}
			return $count;
		} elsif (not(defined($quad)) or (blessed($quad) and $quad->isa('RDF::Trine::Node::Variable'))) {
			my $iter	= $self->get_contexts;
			my $count	= 0;
			while (my $g = $iter->next) {
				$count	+= $self->model->count_statements( @_[0..2], $g );
			}
			return $count;
		} else {
			my $name	= blessed($quad) ? $quad->uri_value : $quad;
			if ($self->{stack}[0]{named}{ $name }) {
				return $self->model->count_statements( @_[0..2], $quad );
			} else {
				return 0;
			}
		}
	} else {
		my %seen;
		my $count	= 0;
		my $iter	= $self->get_statements( @_[0..2], undef );
		while (my $st = $iter->next) {
			warn 'counting triples in dataset: ' . $st->as_string;
			$count++ unless ($seen{ join(' ', map { $_->as_string } (map { $st->$_() } qw(subject predicate object)) ) }++);
		}
		return $count;
	}
}

 
sub add_statement {
	my $self	= shift;
	return $self->model->add_statement( @_ );
}

sub remove_statement {
	my $self	= shift;
	return $self->model->remove_statement( @_ );
}

sub remove_statements {
	my $self	= shift;
	return $self->model->remove_statements( @_ );
}

sub get_statements {
	my $self		= shift;
	return $self->model->get_statements( @_ ) unless (scalar(@{ $self->{stack} }));
	my $bound		= 0;
	my $use_quad	= (scalar(@_) >= 4);
	my $nil			= RDF::Trine::Node::Nil->new();
	if ($use_quad) {
		my $quad	= $_[3];
		if (blessed($quad) and not($quad->isa('RDF::Trine::Node::Variable')) and not($quad->isa('RDF::Trine::Node::Nil'))) {
			if (exists($self->{stack}[0]{named}{$quad->uri_value})) {
				return $self->model->get_statements( @_ );
			} else {
				return RDF::Trine::Iterator::Graph->new([]);
			}
		} else {
			my @iters;
			foreach my $g (values %{ $self->{stack}[0]{default} }) {
				my $iter	= $self->model->get_statements( @_[0..2], $g );
				my $code	= sub {
					my $st	= $iter->next;
					return unless $st;
					my @nodes	= $st->nodes;
					$nodes[3]	= $nil;
					my $quad	= RDF::Trine::Statement::Quad->new( @nodes );
					return $quad;
				};
				push(@iters, RDF::Trine::Iterator::Graph->new( $code ));
			}
			if (not(defined($quad)) or $quad->isa('RDF::Trine::Node::Variable')) {
				my $graphs	= $self->get_contexts;
				while (my $g = $graphs->next) {
					next if ($g->isa('RDF::Trine::Node::Nil'));
					push(@iters, $self->model->get_statements( @_[0..2], $g ));
				}
			}
			my %seen;
			my $code	= sub {
				while (1) {
					return unless scalar(@iters);
					my $st	= $iters[0]->next;
					if ($st) {
						if ($seen{ $st->as_string }++) {
							next;
						}
						return $st;
					} else {
						shift(@iters);
					}
				}
			};
			my $iter	= RDF::Trine::Iterator::Graph->new( $code );
			return $iter;
		}
	} else {
		my %seen;
		my @iters;
		my $iter	= $self->get_statements( @_[0..2], $nil );
		push(@iters, $iter);
		my $giter	= $self->get_contexts;
		while (my $g = $giter->next) {
			my $iter	= $self->get_statements( @_[0..2], $g );
			push(@iters, $iter);
		}
		
		my $code	= sub {
			while (1) {
				return unless scalar(@iters);
				my $st	= $iters[0]->next;
				if ($st) {
					my @nodes	= (map { $st->$_() } qw(subject predicate object));
					next if ($seen{ join(' ', map { $_->as_string } @nodes ) }++);
					return RDF::Trine::Statement->new( @nodes );
				} else {
					shift(@iters);
				}
			}
		};
		return RDF::Trine::Iterator::Graph->new( $code );
	}
}

sub get_pattern {
	my $self	= shift;
	return $self->model->get_pattern( @_ ) unless (scalar(@{ $self->{stack} }));
	my $use_quad	= (scalar(@_) >= 4);
	if ($use_quad) {
		my $quad	= $_[3];
		if (blessed($quad) and not($quad->isa('RDF::Trine::Node::Variable')) and not($quad->isa('RDF::Trine::Node::Nil'))) {
			return $self->model->get_pattern( @_ );
		} else {
			return $self->SUPER::get_pattern( @_ );
		}
	} else {
		return $self->model->get_pattern( @_ );
	}
}

sub get_sparql {
	my $self	= shift;
	return $self->model->get_sparql( @_ ) unless (scalar(@{ $self->{stack} }));
	throw RDF::Trine::Error::UnimplementedError -text => "Cannot execute SPARQL queries against a complex dataset model";
}

sub get_contexts {
	my $self	= shift;
	return $self->model->get_contexts unless (scalar(@{ $self->{stack} }));
	my @nodes	= values %{ $self->{stack}[0]{named} };
	if (wantarray) {
		return @nodes;
	} else {
		return RDF::Trine::Iterator->new( \@nodes );
	}
}

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

sub _store {
	my $self	= shift;
	return $self->model->_store;
}

1;

__END__