com.bigdata.rdf.inf
Class BackchainOwlSameAsPropertiesSPIterator

java.lang.Object
  com.bigdata.rdf.inf.BackchainOwlSameAsIterator
      com.bigdata.rdf.inf.BackchainOwlSameAsPropertiesSPIterator

All Implemented Interfaces:

IChunkedIterator<ISPO>, IChunkedOrderedIterator<ISPO>, ICloseableIterator<ISPO>, Iterator<ISPO>

public class BackchainOwlSameAsPropertiesSPIterator
extends BackchainOwlSameAsIterator

Provides backward chaining for property collection on owl:sameAs for the SP? and S?? access paths.

Note: This is a simple properties query: we know s and we want to know all {p,o} tuples that constitute the properties for s.

Author:

Mike Personick

See Also:

InferenceEngine, InferenceEngine.Options

Field Summary

Fields inherited from class com.bigdata.rdf.inf.BackchainOwlSameAsIterator

copyOnly, db, log, NULL, sameAs, src

Fields inherited from interface com.bigdata.striterator.IChunkedIterator

DEFAULT_CHUNK_SIZE

Constructor Summary

BackchainOwlSameAsPropertiesSPIterator(IChunkedOrderedIterator<ISPO> src, long s, long p, AbstractTripleStore db, long sameAs)
Create an iterator that will visit all statements in the source iterator and also backchain any entailments that would have resulted from owl:sameAs {2,3}.

Method Summary

void	close() Closes the iterator, releasing any associated resources.
IKeyOrder<ISPO>	getKeyOrder() The natural order in which elements are being visited.
boolean	hasNext()
ISPO	next() First iterate the source iterator and then iterate the sameAs{2} iterator, which was fully populated in the ctor.
ISPO[]	nextChunk() Return the next "chunk" from the iterator.
ISPO[]	nextChunk(IKeyOrder<ISPO> keyOrder) Return the next "chunk" of elements.
void	remove() Removes the last element visited by IChunkedIterator.next() (optional operation).

Methods inherited from class com.bigdata.rdf.inf.BackchainOwlSameAsIterator

createTempTripleStore, dumpSPO, getSames, getSames, getSelfAndSames

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

BackchainOwlSameAsPropertiesSPIterator

public BackchainOwlSameAsPropertiesSPIterator(IChunkedOrderedIterator<ISPO> src,
                                              long s,
                                              long p,
                                              AbstractTripleStore db,
                                              long sameAs)

Create an iterator that will visit all statements in the source iterator and also backchain any entailments that would have resulted from owl:sameAs {2,3}.

Parameters:

src - The source iterator. nextChunk() will sort statements into the IKeyOrder reported by this iterator (as long as the IKeyOrder is non-null).

s - The subject of the triple pattern. Cannot be null.

p - The predicate of the triple pattern. Can be null.

db - The database from which we will read the distinct subject identifiers (iff this is an all unbound triple pattern).

sameAs - The term identifier that corresponds to owl:sameAs for the database.

Method Detail

getKeyOrder

public IKeyOrder<ISPO> getKeyOrder()

Description copied from interface: IChunkedOrderedIterator

The natural order in which elements are being visited.

Returns:

The natural order in which the elements are being visited -or- null if not known.

hasNext

public boolean hasNext()

next

public ISPO next()

First iterate the source iterator and then iterate the sameAs{2} iterator, which was fully populated in the ctor. Along the way, collect up the sameAs{3} inferences, which will then be iterated once the first two iterators are complete.

nextChunk

public ISPO[] nextChunk()

Description copied from interface: IChunkedIterator

Return the next "chunk" from the iterator.

Returns:

The next chunk.

nextChunk

public ISPO[] nextChunk(IKeyOrder<ISPO> keyOrder)

Description copied from interface: IChunkedOrderedIterator

Return the next "chunk" of elements. The elements will be in the specified order. If IChunkedOrderedIterator.getKeyOrder() would return non-null and the request order corresponds to the value that would be returned by IChunkedOrderedIterator.getKeyOrder() then the elements in the next chunk are NOT sorted. Otherwise the elements in the next chunk are sorted before they are returned. The size of the chunk is up to the implementation.

Parameters:

keyOrder - The natural order for the elements in the chunk.

Returns:

The next chunk of elements in the specified order.

close

public void close()

Description copied from interface: ICloseableIterator

Closes the iterator, releasing any associated resources. This method MAY be invoked safely if the iterator is already closed.

Note: Implementations that support Iterator.remove() MUST NOT eagerly close the iterator when it is exhausted since that would make it impossible to remove the last visited statement. Instead they MUST wait for an explicit ICloseableIterator.close() by the application.

remove

public void remove()

Description copied from interface: IChunkedIterator

Removes the last element visited by IChunkedIterator.next() (optional operation).

Note: This method is not readily suited for use with IChunkedIterator.nextChunk() since the latter has already visited everything in the chunk and IChunkedIterator.remove() would only remove the last item in the chunk. Normally you will want to accumulate items to be removed in a buffer and then submit the buffer to some batch api operation when it overflows. Alternatively, the IRangeQuery.REMOVEALL flag may be used with the source iterator to remove elements from the index as they are visited.