|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Packages that use IIndex | |
|---|---|
| com.bigdata.bfs | This package provides a scale-out content repository (aka distributed file system) suitable as the backend for a REST-ful service using the bigdata architecture. |
| com.bigdata.btree |
The BTree is a scalable B+-Tree with copy-on-write
semantics mapping variable length unsigned byte[] keys to variable
length byte[] values (null values are allowed). |
| com.bigdata.btree.filter | |
| com.bigdata.btree.isolation | |
| com.bigdata.btree.proc | |
| com.bigdata.btree.view | |
| com.bigdata.counters.store | This package provides a persistence mechanism for performance counters. |
| com.bigdata.journal | The journal is an append-only persistence capable data structure supporting atomic commit, named indices, and transactions. |
| com.bigdata.mdi | This package provides a metadata index and range partitioned indices managed by that metadata index. |
| com.bigdata.rdf.inf | This package provides an eager closure inference engine for most of the RDF and RDFS entailments and can be used to realize entailments for owl:sameAs, owl:equivilentClass, and owl:equivilentProperty. |
| com.bigdata.rdf.lexicon | |
| com.bigdata.rdf.rules | |
| com.bigdata.rdf.spo | This package defines a statement model using long term identifiers rather than RDF Value objects. |
| com.bigdata.relation | This package includes an abstraction layer for relations. |
| com.bigdata.relation.accesspath | This package includes an abstraction layer for efficient access paths, including chunked iterators, blocking buffers, and an abstraction corresponding to the natural order of an index. |
| com.bigdata.resources |
This package provides the logic to managed the live journal and the
historical journals and index segments for a DataService. |
| com.bigdata.search | This package provides full text indexing and search. |
| com.bigdata.service | This package provides implementations of bigdata services (metadata service, data service, transaction manager service. |
| com.bigdata.service.ndx | |
| com.bigdata.sparse | This package provides support for treating normal B+Trees using a "sparse row store" pattern and can be applied to both local B+Trees and scale-out indices. |
| Uses of IIndex in com.bigdata.bfs |
|---|
| Methods in com.bigdata.bfs that return IIndex | |
|---|---|
IIndex |
BigdataFileSystem.getFileDataIndex()
The index in which the file blocks are stored (the index must exist). |
| Methods in com.bigdata.bfs with parameters of type IIndex | |
|---|---|
Object |
AtomicBlockAppendProc.apply(IIndex ndx)
This procedure runs on the unisolated index. |
Object |
AtomicBlockWriteProc.apply(IIndex ndx)
This procedure runs on the unisolated index. |
protected long |
AtomicBlockAppendProc.getNextBlockIdentifierInFileVersion(IIndex ndx,
IKeyBuilder keyBuilder)
Find the key for the last block written for this file version. |
protected long |
AtomicBlockAppendProc.getNextBlockIdentifierInFileVersion2(IIndex ndx,
IKeyBuilder keyBuilder)
Find the key for the last block written for this file version. |
protected void |
FileVersionDeleter.update(IIndex ndx,
ITuple<TPS.TPV> tuple)
Appends a new tuple into the index whose key uses the FileVersionDeleter.choosenTimestamp and whose value is an encoded null. |
| Uses of IIndex in com.bigdata.btree |
|---|
| Subinterfaces of IIndex in com.bigdata.btree | |
|---|---|
interface |
ILocalBTreeView
Interface indicates that the index is local rather than remote. |
| Classes in com.bigdata.btree that implement IIndex | |
|---|---|
class |
AbstractBTree
Base class for mutable and immutable B+-Tree implementations. |
class |
BTree
This class implements a variant of a B+Tree in which all values are stored in leaves, but the leaves are not connected with prior-next links. |
class |
DelegateIndex
An object that delegates its IIndex interface. |
class |
IndexSegment
An index segment is read-only btree corresponding to some key range of a potentially distributed index. |
class |
ReadCommittedView
A view of a named index that replaces its view for each high-level request if there has been an intervening commit on the backing store. |
class |
ReadOnlyIndex
A fly-weight wrapper that does not permit write operations and reads through onto an underlying IIndex. |
class |
UnisolatedReadWriteIndex
A view onto an unisolated index partition which enforces the constraint that either concurrent writers -or- a single writer may have access to the unisolated index at any given time. |
| Fields in com.bigdata.btree declared as IIndex | |
|---|---|
protected IIndex |
ChunkedLocalRangeIterator.ndx
The backing IIndex. |
| Methods in com.bigdata.btree that return IIndex | |
|---|---|
IIndex |
ITupleCursor.getIndex()
The backing index being traversed by the ITupleCursor. |
IIndex |
BigdataMap.getIndex()
The backing index. |
| Methods in com.bigdata.btree with parameters of type IIndex | |
|---|---|
long |
AbstractBTree.rangeCopy(IIndex src,
byte[] fromKey,
byte[] toKey,
boolean overflow)
Copy all data, including deleted index entry markers and timestamps iff supported by the source and target. |
| Constructors in com.bigdata.btree with parameters of type IIndex | |
|---|---|
BigdataMap(IIndex ndx)
Wrap an index as a SortedMap. |
|
BigdataSet(IIndex ndx)
|
|
ChunkedLocalRangeIterator(IIndex ndx,
byte[] fromKey,
byte[] toKey,
int capacity,
int flags,
IFilter filter)
|
|
DelegateIndex(IIndex delegate)
|
|
ReadOnlyIndex(IIndex src)
|
|
ResultSet(IIndex ndx,
int flags)
The basic approach is: Create a new ResultSet
Invoke ResultSet.init(int) to setup the internal buffers.
Apply the source ITupleIterator, using
ResultSet.copyTuple(ITuple) to copy data into those buffers.
Signal completion using ResultSet.done(boolean, byte[])
|
|
ResultSet(IIndex ndx,
int capacity,
int flags,
ITupleIterator itr)
Constructor used to populate the ResultSet directly from an
iterator. |
|
| Uses of IIndex in com.bigdata.btree.filter |
|---|
| Methods in com.bigdata.btree.filter that return IIndex | |
|---|---|
IIndex |
Reverserator.getIndex()
|
| Methods in com.bigdata.btree.filter with parameters of type IIndex | |
|---|---|
protected abstract void |
TupleUpdater.update(IIndex ndx,
ITuple<E> tuple)
You may implement this method to update the state of the visited tuple in the backing index. |
| Uses of IIndex in com.bigdata.btree.isolation |
|---|
| Classes in com.bigdata.btree.isolation that implement IIndex | |
|---|---|
class |
IsolatedFusedView
An index (or index partition) that has been isolated by a transaction. |
| Methods in com.bigdata.btree.isolation with parameters of type IIndex | |
|---|---|
boolean |
IConflictResolver.resolveConflict(IIndex writeSet,
ITuple txTuple,
ITuple currentTuple)
Resolve a write-write conflict between a committed version on the journal and the current version within a transaction that is validating. |
boolean |
NoConflictResolver.resolveConflict(IIndex writeSet,
ITuple txTuple,
ITuple currentTuple)
|
| Uses of IIndex in com.bigdata.btree.proc |
|---|
| Methods in com.bigdata.btree.proc with parameters of type IIndex | |
|---|---|
Object |
IIndexProcedure.apply(IIndex ndx)
Run the procedure. |
Object |
BatchContains.apply(IIndex ndx)
Applies the operation using ISimpleBTree.contains(byte[]). |
Object |
BatchLookup.apply(IIndex ndx)
|
Object |
BatchRemove.apply(IIndex ndx)
Applies the operation. |
Object |
RangeCountProcedure.apply(IIndex ndx)
Range count of entries in a key range for the index. |
AbstractKeyArrayIndexProcedure.ResultBuffer |
BatchInsert.apply(IIndex ndx)
Applies the operator using ISimpleBTree#insert(Object, Object) |
protected IKeyBuilder |
AbstractIndexProcedure.getKeyBuilder(IIndex ndx)
Return the thread-local key builder configured for the IIndex |
T |
AbstractKeyArrayIndexProcedureConstructor.newInstance(IIndex ndx,
int fromIndex,
int toIndex,
byte[][] keys,
byte[][] vals)
Uses the ITupleSerializer reported by IndexMetadata for
the IIndex. |
| Uses of IIndex in com.bigdata.btree.view |
|---|
| Classes in com.bigdata.btree.view that implement IIndex | |
|---|---|
class |
FusedView
A fused view providing read-write operations on multiple B+-Trees mapping variable length unsigned byte[] keys to arbitrary values. |
| Methods in com.bigdata.btree.view that return IIndex | |
|---|---|
IIndex |
FusedTupleCursor.getIndex()
|
| Constructors in com.bigdata.btree.view with parameters of type IIndex | |
|---|---|
FusedTupleCursor(int flags,
boolean deleted,
ITupleCursor<E>[] srcs,
IIndex ndx)
|
|
| Uses of IIndex in com.bigdata.counters.store |
|---|
| Classes in com.bigdata.counters.store that implement IIndex | |
|---|---|
class |
CounterSetBTree
An API encapsulating for writing and querying counter sets. |
| Uses of IIndex in com.bigdata.journal |
|---|
| Classes in com.bigdata.journal that implement IIndex | |
|---|---|
class |
CommitRecordIndex
BTree mapping commit times to ICommitRecords. |
class |
Name2Addr
Name2Addr is a BTree mapping index names to an Name2Addr.Entry
containing the last Checkpoint record committed for the named index
and the timestamp of that commit. |
| Methods in com.bigdata.journal that return IIndex | |
|---|---|
IIndex |
JournalDelegate.getIndex(String name)
|
IIndex |
ITask.getIndex(String name)
Return an appropriate view of the named index for the operation. |
IIndex |
IBTreeManager.getIndex(String name)
Return the unisolated view of the named index (the mutable view of the live index object). |
IIndex |
AbstractTask.DelegateTask.getIndex(String name)
|
IIndex |
JournalDelegate.getIndex(String name,
long timestamp)
|
IIndex |
AbstractJournal.getIndex(String name,
long commitTime)
Return a view of the named index as of the specified timestamp. |
IIndex |
IIndexStore.getIndex(String name,
long timestamp)
Return a view of the named index as of the specified timestamp. |
IIndex |
AbstractJournal.getName2Addr()
A read-only view of the Name2Addr object mapping index names to
the most recent committed Name2Addr.Entry for the named index. |
IIndex |
AbstractJournal.getName2Addr(long commitTime)
Return a read-only view of the Name2Addr object as of the
specified commit time. |
IIndex |
AbstractJournal.getReadOnlyCommitRecordIndex()
Return a read-only view of the last committed state of the CommitRecordIndex. |
IIndex |
JournalDelegate.registerIndex(String name,
BTree btree)
|
IIndex |
IBTreeManager.registerIndex(String name,
BTree btree)
Register a named index. |
IIndex |
AbstractTask.registerIndex(String name,
BTree btree)
Registers an index |
IIndex |
JournalDelegate.registerIndex(String name,
IndexMetadata indexMetadata)
|
IIndex |
IBTreeManager.registerIndex(String name,
IndexMetadata indexMetadata)
Register a named index. |
| Uses of IIndex in com.bigdata.mdi |
|---|
| Classes in com.bigdata.mdi that implement IIndex | |
|---|---|
class |
MetadataIndex
A metadata index for the partitions of a distributed index. |
class |
MetadataIndexView
The extension semantics for the IMetadataIndex are implemented by
this class. |
| Uses of IIndex in com.bigdata.rdf.inf |
|---|
| Constructors in com.bigdata.rdf.inf with parameters of type IIndex | |
|---|---|
JustificationIterator(IIndexManager indexManager,
IIndex ndx,
int capacity)
Deprecated. Create an iterator reading from the justifications index. |
|
| Uses of IIndex in com.bigdata.rdf.lexicon |
|---|
| Methods in com.bigdata.rdf.lexicon that return IIndex | |
|---|---|
IIndex |
LexiconRelation.getBlobsIndex()
|
IIndex |
LexiconRelation.getId2TermIndex()
|
IIndex |
BigdataSubjectCentricFullTextIndex.getIndex()
The index used to associate term identifiers with tokens parsed from documents. |
IIndex |
LexiconRelation.getIndex(IKeyOrder<? extends BigdataValue> keyOrder)
Overridden to use local cache of the index reference. |
IIndex |
LexiconRelation.getTerm2IdIndex()
|
| Methods in com.bigdata.rdf.lexicon with parameters of type IIndex | |
|---|---|
int |
BlobsIndexHelper.addBNode(IIndex ndx,
IKeyBuilder keyBuilder,
byte[] baseKey,
byte[] val,
byte[] tmp)
Add an entry for a BNode to the TERMS index (do NOT use when told
blank node semantics apply). |
Object |
Term2IdWriteProc.apply(IIndex ndx)
For each term whose serialized key is mapped to the current index partition, lookup the term in the terms index. |
Object |
BlobsWriteProc.apply(IIndex ndx)
For each term whose serialized key is mapped to the current index partition, lookup the term in the terms index. |
Object |
Id2TermWriteProc.apply(IIndex ndx)
Conditionally inserts each key-value pair into the index. |
static Appendable |
DumpLexicon.dumpBlobs(String namespace,
IIndex ndx)
Dump the BLOBS index. |
static void |
DumpLexicon.dumpBlobs(Writer w,
boolean showEntries,
String namespace,
IIndex ndx)
Core implementation for dumping the BLOBS index. |
byte[] |
BlobsIndexHelper.lookup(IIndex ndx,
BlobIV<?> iv,
IKeyBuilder keyBuilder)
Return the value associated with the BlobIV in the TERMS index. |
int |
BlobsIndexHelper.resolveOrAddValue(IIndex termsIndex,
boolean readOnly,
IKeyBuilder keyBuilder,
byte[] baseKey,
byte[] val,
byte[] tmp,
AtomicInteger bucketSize)
Resolve an existing record in the TERMS index and insert the record if none is found. |
| Constructors in com.bigdata.rdf.lexicon with parameters of type IIndex | |
|---|---|
BlobsWriteTask(IIndex ndx,
BigdataValueFactory valueFactory,
boolean readOnly,
boolean storeBlankNodes,
int numTerms,
BigdataValue[] terms,
WriteTaskStats stats)
|
|
ReverseIndexWriterTask(IIndex idTermIndex,
BigdataValueFactory valueFactory,
KVO<BigdataValue>[] a,
int ndistinct,
boolean storeBlankNodes)
|
|
Term2IdWriteTask(IIndex termIdIndex,
boolean readOnly,
boolean storeBlankNodes,
int termIdBitsToReverse,
int numTerms,
BigdataValue[] terms,
WriteTaskStats stats)
|
|
| Uses of IIndex in com.bigdata.rdf.rules |
|---|
| Methods in com.bigdata.rdf.rules that return IIndex | |
|---|---|
IIndex |
BackchainAccessPath.getIndex()
The IIndex for the source IAccessPath. |
| Uses of IIndex in com.bigdata.rdf.spo |
|---|
| Methods in com.bigdata.rdf.spo that return IIndex | |
|---|---|
IIndex |
SPORelation.getIndex(IKeyOrder<? extends ISPO> keyOrder)
Overridden to return the hard reference for the index, which is cached the first time it is resolved. |
IIndex |
SPORelation.getJustificationIndex()
The optional index on which Justifications are stored. |
IIndex |
SPORelation.getPrimaryIndex()
|
| Methods in com.bigdata.rdf.spo with parameters of type IIndex | |
|---|---|
Object |
JustIndexWriteProc.apply(IIndex ndx)
|
Object |
SPOIndexWriteProc.apply(IIndex ndx)
|
| Constructors in com.bigdata.rdf.spo with parameters of type IIndex | |
|---|---|
BulkCompleteConverter(IIndex ndx)
|
|
BulkFilterConverter(IIndex ndx,
boolean present)
|
|
| Uses of IIndex in com.bigdata.relation |
|---|
| Methods in com.bigdata.relation that return IIndex | |
|---|---|
static IIndex |
AbstractRelation.getIndex(IIndexManager indexManager,
String fqn,
long timestamp)
Return the named index using the timestamp for this view of the relation. |
IIndex |
IRelation.getIndex(IKeyOrder<? extends E> keyOrder)
Return the index for associated with the specified IKeyOrder this
view of the relation. |
IIndex |
RelationFusedView.getIndex(IKeyOrder<? extends E> keyOrder)
Deprecated. |
IIndex |
AbstractRelation.getIndex(IKeyOrder<? extends E> keyOrder)
Return the index for the IKeyOrder the timestamp for this view of
the relation. |
IIndex |
AbstractRelation.getIndex(String fqn)
Return the named index using the timestamp for this view of the relation. |
| Uses of IIndex in com.bigdata.relation.accesspath |
|---|
| Fields in com.bigdata.relation.accesspath declared as IIndex | |
|---|---|
protected IIndex |
AccessPath.ndx
The index. |
| Methods in com.bigdata.relation.accesspath that return IIndex | |
|---|---|
IIndex |
AccessPath.getIndex()
|
IIndex |
AccessPathFusedView.getIndex()
Deprecated. |
IIndex |
EmptyAccessPath.getIndex()
|
IIndex |
IAccessPath.getIndex()
The index selected for the access path. |
IIndex |
ArrayAccessPath.getIndex()
|
| Uses of IIndex in com.bigdata.resources |
|---|
| Classes in com.bigdata.resources that implement IIndex | |
|---|---|
class |
IndexSegmentIndex
BTree mapping IndexSegmentStore createTimes to
IResourceMetadata records. |
class |
JournalIndex
BTree mapping IJournal createTimes (long integers)
to JournalMetadata records describing the IJournal. |
| Methods in com.bigdata.resources with parameters of type IIndex | |
|---|---|
static void |
SplitUtility.validateSplits(IIndex src,
Split[] splits)
Validate splits, including: that the separator keys are strictly ascending, that the separator keys perfectly cover the source key range without overlap, that the rightSeparator for each split is the leftSeparator for the prior split, that the fromIndex offsets are strictly ascending, etc. |
| Uses of IIndex in com.bigdata.search |
|---|
| Methods in com.bigdata.search that return IIndex | |
|---|---|
IIndex |
FullTextIndex.getIndex()
The index used to associate term identifiers with tokens parsed from documents. |
| Methods in com.bigdata.search with parameters of type IIndex | |
|---|---|
Object |
TextIndexWriteProc.apply(IIndex ndx)
|
| Uses of IIndex in com.bigdata.service |
|---|
| Classes in com.bigdata.service that implement IIndex | |
|---|---|
class |
CommitTimeIndex
BTree whose keys are commit times. |
static class |
EventReceiver.EventBTree
A BTree whose keys are event start times and whose values are the
serialized Events. |
class |
TxId2CommitTimeIndex
BTree whose keys are commit times. |
| Uses of IIndex in com.bigdata.service.ndx |
|---|
| Subinterfaces of IIndex in com.bigdata.service.ndx | |
|---|---|
interface |
IClientIndex
IBigdataClient-side IIndex interface. |
interface |
IScaleOutClientIndex
A client-side view of a scale-out index. |
| Classes in com.bigdata.service.ndx that implement IIndex | |
|---|---|
class |
AbstractScaleOutClientIndexView
Abstract base class for the IScaleOutClientIndex implementation(s). |
class |
AbstractScaleOutClientIndexView2
Abstract class encapsulating MOST of the logic for executing tasks corresponding to client index operations. |
class |
ClientIndexView
A client-side view of a scale-out index as of some timestamp. |
class |
ClientIndexViewRefactor
A client-side view of a scale-out index as of some timestamp. |
| Uses of IIndex in com.bigdata.sparse |
|---|
| Methods in com.bigdata.sparse that return IIndex | |
|---|---|
IIndex |
SparseRowStore.getIndex()
The backing index. |
| Methods in com.bigdata.sparse with parameters of type IIndex | |
|---|---|
TPS |
AtomicRowWriteRead.apply(IIndex ndx)
If a property set was specified then do an atomic write of the property set. |
TPS |
AtomicRowDelete.apply(IIndex ndx)
An atomic read of the matching properties is performed and those properties are then deleted atomically. |
TPS |
AtomicRowRead.apply(IIndex ndx)
Atomic read. |
protected static TPS |
AbstractAtomicRowReadOrWrite.atomicRead(IIndex ndx,
byte[] fromKey,
Schema schema,
long fromTime,
long toTime,
INameFilter filter,
TPS tps)
Alternative form useful when you have the raw key (unsigned byte[]) rather than a primary key (application object). |
protected static TPS |
AbstractAtomicRowReadOrWrite.atomicRead(IIndex ndx,
Schema schema,
Object primaryKey,
long fromTime,
long toTime,
long writeTime,
INameFilter filter)
Atomic read on the index. |
protected void |
AtomicRowWriteRead.atomicWrite(IIndex ndx,
Schema schema,
Object primaryKey,
Map<String,Object> propertySet,
long writeTime)
|
static long |
TimestampChooser.chooseTimestamp(IIndex ndx,
long timestamp)
Choose the timestamp for TPS.TPV tuples to written on the sparse row
store. |
protected static ITPV |
AbstractAtomicRowReadOrWrite.getCurrentValue(IIndex ndx,
Schema schema,
Object primaryKey,
String name)
Return the current binding for the named property. |
protected long |
AtomicRowWriteRead.inc(IIndex ndx,
Schema schema,
Object primaryKey,
long timestamp,
String col)
Return the increment of the named property value. |
| Constructors in com.bigdata.sparse with parameters of type IIndex | |
|---|---|
SparseRowStore(IIndex ndx)
Create a client-side abstraction that treats an IIndex as a
SparseRowStore. |
|
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||