public class PrimaryIndex<PK,E>
extends java.lang.Object
PrimaryIndex objects are thread-safe. Multiple threads may
safely call the methods of a shared PrimaryIndex object.
PrimaryIndex implements EntityIndex to map the primary
key type (PK) to the entity type (E).
The Entity annotation may be used to define an entity class and
the PrimaryKey annotation may be used to define a primary key as
shown in the following example.
@Entity
class Employee {
@PrimaryKey
long id;
String name;
Employee(long id, String name) {
this.id = id;
this.name = name;
}
private Employee() {} // For bindings
}
To obtain the PrimaryIndex for a given entity class, call EntityStore.getPrimaryIndex, passing the
primary key class and the entity class. For example:
EntityStore store = new EntityStore(...);
PrimaryIndex<Long, Employee> primaryIndex =
store.getPrimaryIndex(Long.class, Employee.class);
Note that Long.class is passed as the primary key class, but the
primary key field has the primitive type long. When a primitive
primary key field is used, the corresponding primitive wrapper class is used
to access the primary index. For more information on key field types, see
PrimaryKey.
The PrimaryIndex provides the primary storage and access methods
for the instances of a particular entity class. Entities are inserted and
updated in the PrimaryIndex by calling a method in the family of
put(E) methods. The put(E) method will insert the entity if no
entity with the same primary key already exists. If an entity with the same
primary key does exist, it will update the entity and return the existing
(old) entity. For example:
Employee oldEntity; oldEntity = primaryIndex.put(new Employee(1, "Jane Smith")); // Inserts an entity assert oldEntity == null; oldEntity = primaryIndex.put(new Employee(2, "Joan Smith")); // Inserts an entity assert oldEntity == null; oldEntity = primaryIndex.put(new Employee(2, "Joan M. Smith")); // Updates an entity assert oldEntity != null;
The putNoReturn(E) method can be used to avoid the overhead of
returning the existing entity, when the existing entity is not important to
the application. The return type of putNoReturn(E) is void. For
example:
primaryIndex.putNoReturn(new Employee(1, "Jane Smith")); // Inserts an entity primaryIndex.putNoReturn(new Employee(2, "Joan Smith")); // Inserts an entity primaryIndex.putNoReturn(new Employee(2, "Joan M. Smith")); // Updates an entity
The putNoOverwrite(E) method can be used to ensure that an existing
entity is not overwritten. putNoOverwrite(E) returns true if the
entity was inserted, or false if an existing entity exists and no action was
taken. For example:
boolean inserted; inserted = primaryIndex.putNoOverwrite(new Employee(1, "Jane Smith")); // Inserts an entity assert inserted; inserted = primaryIndex.putNoOverwrite(new Employee(2, "Joan Smith")); // Inserts an entity assert inserted; inserted = primaryIndex.putNoOverwrite(new Employee(2, "Joan M. Smith")); // No action was taken! assert !inserted;
Primary key values must be unique, in other words, each instance of a
given entity class must have a distinct primary key value. Rather than
assigning the unique primary key values yourself, a sequence can be
used to assign sequential integer values automatically, starting with the
value 1 (one). A sequence is defined using the PrimaryKey.sequence()
annotation property. For example:
@Entity
class Employee {
@PrimaryKey(sequence="ID")
long id;
String name;
Employee(String name) {
this.name = name;
}
private Employee() {} // For bindings
}
The name of the sequence used above is "ID". Any name can be used. If
the same sequence name is used in more than one entity class, the sequence
will be shared by those classes, in other words, a single sequence of
integers will be used for all instances of those classes. See PrimaryKey.sequence() for more information.
Any method in the family of put(E) methods may be used to insert
entities where the primary key is assigned from a sequence. When the put(E) method returns, the primary key field of the entity object will be set
to the assigned key value. For example:
Employee employee;
employee = new Employee("Jane Smith");
primaryIndex.putNoReturn(employee); // Inserts an entity
assert employee.id == 1;
employee = new Employee("Joan Smith");
primaryIndex.putNoReturn(employee); // Inserts an entity
assert employee.id == 2;
This begs the question: How do you update an existing entity, without
assigning a new primary key? The answer is that the put(E) methods
will only assign a new key from the sequence if the primary key field is
zero or null (for reference types). If an entity with a non-zero and
non-null key field is passed to a put(E) method, any existing entity
with that primary key value will be updated. For example:
Employee employee;
employee = new Employee("Jane Smith");
primaryIndex.putNoReturn(employee); // Inserts an entity
assert employee.id == 1;
employee = new Employee("Joan Smith");
primaryIndex.putNoReturn(employee); // Inserts an entity
assert employee.id == 2;
employee.name = "Joan M. Smith";
primaryIndex.putNoReturn(employee); // Updates an existing entity
assert employee.id == 2;
Since PrimaryIndex implements the EntityIndex interface,
it shares the common index methods for retrieving and deleting entities,
opening cursors and using transactions. See EntityIndex for more
information on these topics.
Note that when using an index, keys and values are stored and retrieved by value not by reference. In other words, if an entity object is stored and then retrieved, or retrieved twice, each object will be a separate instance. For example, in the code below the assertion will always fail.
MyKey key = ...; MyEntity entity1 = new MyEntity(key, ...); index.put(entity1); MyEntity entity2 = index.get(key); assert entity1 == entity2; // always fails!
| Constructor and Description |
|---|
PrimaryIndex(Database database,
java.lang.Class<PK> keyClass,
EntryBinding<PK> keyBinding,
java.lang.Class<E> entityClass,
EntityBinding<E> entityBinding)
Creates a primary index without using an
EntityStore. |
| Modifier and Type | Method and Description |
|---|---|
boolean |
contains(K key)
Checks for existence of a key in this index.
|
boolean |
contains(Transaction txn,
K key,
LockMode lockMode)
Checks for existence of a key in this index.
|
long |
count()
Returns a non-transactional count of the entities in this index.
|
long |
count(long memoryLimit)
Returns a non-transactional count of the entities in this index.
|
boolean |
delete(K key)
Deletes all entities with a given index key.
|
boolean |
delete(Transaction txn,
K key)
Deletes all entities with a given index key.
|
OperationResult |
delete(Transaction txn,
K key,
WriteOptions options)
Deletes all entities with a given index key, using a WriteOptions
parameter and returning an OperationResult.
|
EntityCursor<E> |
entities()
Opens a cursor for traversing all entities in this index.
|
EntityCursor<E> |
entities(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive)
Opens a cursor for traversing entities in a key range.
|
EntityCursor<E> |
entities(Transaction txn,
CursorConfig config)
Opens a cursor for traversing all entities in this index.
|
EntityCursor<E> |
entities(Transaction txn,
K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive,
CursorConfig config)
Opens a cursor for traversing entities in a key range.
|
E |
get(PK key)
Gets an entity via a key of this index.
|
EntityResult<E> |
get(Transaction txn,
PK key,
Get getType,
ReadOptions options)
Gets an entity via a key of this index, using Get type and ReadOptions
parameters, and returning an EntityResult.
|
E |
get(Transaction txn,
PK key,
LockMode lockMode)
Gets an entity via a key of this index.
|
Database |
getDatabase()
Returns the underlying database for this index.
|
EntityBinding<E> |
getEntityBinding()
Returns the entity binding for this index.
|
java.lang.Class<E> |
getEntityClass()
Returns the entity class for this index.
|
EntryBinding<PK> |
getKeyBinding()
Returns the primary key binding for this index.
|
java.lang.Class<PK> |
getKeyClass()
Returns the primary key class for this index.
|
EntityCursor<K> |
keys()
Opens a cursor for traversing all keys in this index.
|
EntityCursor<K> |
keys(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive)
Opens a cursor for traversing keys in a key range.
|
EntityCursor<K> |
keys(Transaction txn,
CursorConfig config)
Opens a cursor for traversing all keys in this index.
|
EntityCursor<K> |
keys(Transaction txn,
K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive,
CursorConfig config)
Opens a cursor for traversing keys in a key range.
|
java.util.Map<PK,E> |
map()
Returns a standard Java map based on this entity index.
|
E |
put(E entity)
Inserts an entity and returns null, or updates it if the primary key
already exists and returns the existing entity.
|
E |
put(Transaction txn,
E entity)
Inserts an entity and returns null, or updates it if the primary key
already exists and returns the existing entity.
|
OperationResult |
put(Transaction txn,
E entity,
Put putType,
WriteOptions options)
Inserts or updates an entity, using Put type and WriteOptions
parameters, and returning an OperationResult.
|
boolean |
putNoOverwrite(E entity)
Inserts an entity and returns true, or returns false if the primary key
already exists.
|
boolean |
putNoOverwrite(Transaction txn,
E entity)
Inserts an entity and returns true, or returns false if the primary key
already exists.
|
void |
putNoReturn(E entity)
Inserts an entity, or updates it if the primary key already exists (does
not return the existing entity).
|
void |
putNoReturn(Transaction txn,
E entity)
Inserts an entity, or updates it if the primary key already exists (does
not return the existing entity).
|
java.util.SortedMap<PK,E> |
sortedMap()
Returns a standard Java sorted map based on this entity index.
|
public PrimaryIndex(Database database, java.lang.Class<PK> keyClass, EntryBinding<PK> keyBinding, java.lang.Class<E> entityClass, EntityBinding<E> entityBinding) throws DatabaseException
EntityStore.
This constructor is not normally needed and is provided for
applications that wish to use custom bindings along with the Direct
Persistence Layer. Normally, getPrimaryIndex is used instead.
Note that when this constructor is used directly, primary keys cannot
be automatically assigned from a sequence. The key assignment feature
requires knowledge of the primary key field, which is only available if
an EntityStore is used. Of course, primary keys may be
assigned from a sequence manually before calling the put
methods in this class.
database - the primary database.keyClass - the class of the primary key.keyBinding - the binding to be used for primary keys.entityClass - the class of the entities stored in this index.entityBinding - the binding to be used for entities.DatabaseException - the base class for all BDB exceptions.public java.lang.Class<PK> getKeyClass()
public EntryBinding<PK> getKeyBinding()
public java.lang.Class<E> getEntityClass()
public EntityBinding<E> getEntityBinding()
public E put(E entity) throws DatabaseException
If a PrimaryKey.sequence() is used and the primary key field of
the given entity is null or zero, this method will assign the next value
from the sequence to the primary key field of the given entity.
Auto-commit is used implicitly if the store is transactional.
entity - the entity to be inserted or updated.OperationFailureException - if one of the Write
Operation Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.
DatabaseException - the base class for all BDB exceptions.public E put(Transaction txn, E entity) throws DatabaseException
If a PrimaryKey.sequence() is used and the primary key field of
the given entity is null or zero, this method will assign the next value
from the sequence to the primary key field of the given entity.
txn - the transaction used to protect this operation, null to use
auto-commit, or null if the store is non-transactional.entity - the entity to be inserted or updated.OperationFailureException - if one of the Write
Operation Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.
DatabaseException - the base class for all BDB exceptions.public void putNoReturn(E entity) throws DatabaseException
put(Object) to save the overhead of returning the existing
entity.
If a PrimaryKey.sequence() is used and the primary key field of
the given entity is null or zero, this method will assign the next value
from the sequence to the primary key field of the given entity.
Auto-commit is used implicitly if the store is transactional.
entity - the entity to be inserted or updated.
OperationFailureException - if one of the Write
Operation Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.
DatabaseException - the base class for all BDB exceptions.public void putNoReturn(Transaction txn, E entity) throws DatabaseException
put(Transaction,Object) to save the overhead of returning the
existing entity.
If a PrimaryKey.sequence() is used and the primary key field of
the given entity is null or zero, this method will assign the next value
from the sequence to the primary key field of the given entity.
txn - the transaction used to protect this operation, null to use
auto-commit, or null if the store is non-transactional.entity - the entity to be inserted or updated.
OperationFailureException - if one of the Write
Operation Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.
DatabaseException - the base class for all BDB exceptions.public boolean putNoOverwrite(E entity) throws DatabaseException
If a PrimaryKey.sequence() is used and the primary key field of
the given entity is null or zero, this method will assign the next value
from the sequence to the primary key field of the given entity.
Auto-commit is used implicitly if the store is transactional.
entity - the entity to be inserted.OperationFailureException - if one of the Write
Operation Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.
DatabaseException - the base class for all BDB exceptions.public boolean putNoOverwrite(Transaction txn, E entity) throws DatabaseException
If a PrimaryKey.sequence() is used and the primary key field of
the given entity is null or zero, this method will assign the next value
from the sequence to the primary key field of the given entity.
txn - the transaction used to protect this operation, null to use
auto-commit, or null if the store is non-transactional.entity - the entity to be inserted.OperationFailureException - if one of the Write
Operation Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.
DatabaseException - the base class for all BDB exceptions.public OperationResult put(Transaction txn, E entity, Put putType, WriteOptions options)
If a PrimaryKey.sequence() is used and the primary key field of
the given entity is null or zero, this method will assign the next value
from the sequence to the primary key field of the given entity.
txn - the transaction used to protect this operation, null to use
auto-commit, or null if the store is non-transactional.entity - the entity to be inserted.putType - is Put.OVERWRITE or Put.NO_OVERWRITE.options - the WriteOptions, or null to use default options.Put.NO_OVERWRITE is used, null is returned if an entity with the
same primary key is already present. If Put.OVERWRITE is used,
null is never returned.OperationFailureException - if one of the Write
Operation Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.DatabaseException - the base class for all BDB exceptions.public E get(PK key) throws DatabaseException
EntityIndexThe operation will not be transaction protected, and LockMode.DEFAULT is used implicitly.
key - the key to search for.OperationFailureException - if one of the Read Operation
Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.
DatabaseException - the base class for all BDB exceptions.public E get(Transaction txn, PK key, LockMode lockMode) throws DatabaseException
EntityIndextxn - the transaction used to protect this operation, or null
if the operation should not be transaction protected.key - the key to search for.lockMode - the lock mode to use for this operation, or null to
use LockMode.DEFAULT.OperationFailureException - if one of the Read Operation
Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.
DatabaseException - the base class for all BDB exceptions.public EntityResult<E> get(Transaction txn, PK key, Get getType, ReadOptions options) throws DatabaseException
EntityIndextxn - the transaction used to protect this operation, or null
if the operation should not be transaction protected.key - the key to search for.getType - must be Get.SEARCH.options - the ReadOptions, or null to use default options.OperationFailureException - if one of the Read Operation
Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.DatabaseException - the base class for all BDB exceptions.public java.util.Map<PK,E> map()
EntityIndexStoredMap returned is defined by the Collections API. Stored collections conform
to the standard Java collections framework interface.public java.util.SortedMap<PK,E> sortedMap()
EntityIndexStoredSortedMap returned is defined by the Collections API. Stored collections conform
to the standard Java collections framework interface.public Database getDatabase()
EntityIndexgetDatabase in interface EntityIndex<K,E>public boolean contains(K key)
throws DatabaseException
EntityIndexThe operation will not be transaction protected, and LockMode.DEFAULT is used implicitly.
READ_UNCOMMITTED can be used with this method to reduce I/O,
since the record data item will not be read. This is the same benefit
as described in Key Cursor
Optimization with READ_UNCOMMITTED
contains in interface EntityIndex<K,E>key - the key to search for.OperationFailureException - if one of the Read Operation
Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.
DatabaseException - the base class for all BDB exceptions.public boolean contains(Transaction txn, K key, LockMode lockMode) throws DatabaseException
EntityIndexREAD_UNCOMMITTED can be used with this method to reduce I/O,
since the record data item will not be read. This is the same benefit
as described in Key Cursor
Optimization with READ_UNCOMMITTED
contains in interface EntityIndex<K,E>txn - the transaction used to protect this operation, or null
if the operation should not be transaction protected.key - the key to search for.lockMode - the lock mode to use for this operation, or null to
use LockMode.DEFAULT.OperationFailureException - if one of the Read Operation
Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.
DatabaseException - the base class for all BDB exceptions.public long count()
throws DatabaseException
EntityIndexThis operation is faster than obtaining a count by scanning the index manually, and will not perturb the current contents of the cache. However, the count is not guaranteed to be accurate if there are concurrent updates. Note that this method does scan a significant portion of the index and should be considered a fairly expensive operation.
This operation will disable deletion of log files by the JE log
cleaner during its execution and will consume a certain amount of
memory (but without affecting the memory that is available for the
JE cache). To avoid excessive memory consumption (and a potential
OutOfMemoryError) this method places an internal limit on
its memory consumption. If this limit is reached, the method will
still work properly, but its performance will degrade. To specify
a different memory limit than the one used by this method, use the
EntityIndex.count(long memoryLimit) method.
count in interface EntityIndex<K,E>OperationFailureException - if one of the Read Operation
Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.
DatabaseException - the base class for all BDB exceptions.public long count(long memoryLimit)
throws DatabaseException
EntityIndexThis operation is faster than obtaining a count by scanning the index manually, and will not perturb the current contents of the cache. However, the count is not guaranteed to be accurate if there are concurrent updates. Note that this method does scan a significant portion of the index and should be considered a fairly expensive operation.
This operation will disable deletion of log files by the JE log
cleaner during its execution and will consume a certain amount of
memory (but without affecting the memory that is available for the
JE cache). To avoid excessive memory consumption (and a potential
OutOfMemoryError) this method takes as input an upper bound
on the memory it may consume. If this limit is reached, the method
will still work properly, but its performance will degrade.
count in interface EntityIndex<K,E>OperationFailureException - if one of the Read Operation
Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.DatabaseException - the base class for all BDB exceptions.public boolean delete(K key)
throws DatabaseException
EntityIndexAuto-commit is used implicitly if the store is transactional.
delete in interface EntityIndex<K,E>key - the key to search for.OperationFailureException - if one of the Write
Operation Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.
DatabaseException - the base class for all BDB exceptions.public boolean delete(Transaction txn, K key) throws DatabaseException
EntityIndexdelete in interface EntityIndex<K,E>txn - the transaction used to protect this operation, null to use
auto-commit, or null if the store is non-transactional.key - the key to search for.OperationFailureException - if one of the Write
Operation Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.
DatabaseException - the base class for all BDB exceptions.public OperationResult delete(Transaction txn, K key, WriteOptions options) throws DatabaseException
EntityIndexdelete in interface EntityIndex<K,E>txn - the transaction used to protect this operation, null to use
auto-commit, or null if the store is non-transactional.key - the key to search for.options - the WriteOptions, or null to use default options.OperationFailureException - if one of the Write
Operation Failures occurs.EnvironmentFailureException - if an unexpected, internal or
environment-wide failure occurs.DatabaseException - the base class for all BDB exceptions.public EntityCursor<K> keys() throws DatabaseException
EntityIndexThe operations performed with the cursor will not be transaction
protected, and CursorConfig.DEFAULT is used implicitly. If the
store is transactional, the cursor may not be used to update or delete
entities.
Note that READ_UNCOMMITTED can be used with a key cursor to
reduce I/O, potentially providing significant performance benefits. See
Key Cursor Optimization with
READ_UNCOMMITTED
keys in interface EntityIndex<K,E>DatabaseException - the base class for all BDB exceptions.public EntityCursor<K> keys(Transaction txn, CursorConfig config) throws DatabaseException
EntityIndexNote that READ_UNCOMMITTED can be used with a key cursor to
reduce I/O, potentially providing significant performance benefits. See
Key Cursor Optimization with
READ_UNCOMMITTED
keys in interface EntityIndex<K,E>txn - the transaction used to protect all operations performed with
the cursor, or null if the operations should not be transaction
protected. If the store is non-transactional, null must be specified.
For a transactional store the transaction is optional for read-only
access and required for read-write access.config - the cursor configuration that determines the default lock
mode used for all cursor operations, or null to implicitly use CursorConfig.DEFAULT.DatabaseException - the base class for all BDB exceptions.public EntityCursor<E> entities() throws DatabaseException
EntityIndexThe operations performed with the cursor will not be transaction
protected, and CursorConfig.DEFAULT is used implicitly. If the
store is transactional, the cursor may not be used to update or delete
entities.
entities in interface EntityIndex<K,E>DatabaseException - the base class for all BDB exceptions.public EntityCursor<E> entities(Transaction txn, CursorConfig config) throws DatabaseException
EntityIndexentities in interface EntityIndex<K,E>txn - the transaction used to protect all operations performed with
the cursor, or null if the operations should not be transaction
protected. If the store is non-transactional, null must be specified.
For a transactional store the transaction is optional for read-only
access and required for read-write access.config - the cursor configuration that determines the default lock
mode used for all cursor operations, or null to implicitly use CursorConfig.DEFAULT.DatabaseException - the base class for all BDB exceptions.public EntityCursor<K> keys(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) throws DatabaseException
EntityIndexThe operations performed with the cursor will not be transaction
protected, and CursorConfig.DEFAULT is used implicitly. If the
store is transactional, the cursor may not be used to update or delete
entities.
Note that READ_UNCOMMITTED can be used with a key cursor to
reduce I/O, potentially providing significant performance benefits. See
Key Cursor Optimization with
READ_UNCOMMITTED
keys in interface EntityIndex<K,E>fromKey - is the lower bound of the key range, or null if the range
has no lower bound.fromInclusive - is true if keys greater than or equal to fromKey
should be included in the key range, or false if only keys greater than
fromKey should be included.toKey - is the upper bound of the key range, or null if the range
has no upper bound.toInclusive - is true if keys less than or equal to toKey should be
included in the key range, or false if only keys less than toKey should
be included.DatabaseException - the base class for all BDB exceptions.public EntityCursor<K> keys(Transaction txn, K fromKey, boolean fromInclusive, K toKey, boolean toInclusive, CursorConfig config) throws DatabaseException
EntityIndexUsing a key cursor potentially has a large performance benefit when
the READ_UNCOMMITTED isolation mode is used. In this case, if
the record data is not in the JE cache, it will not be read from disk.
The performance benefit is potentially large because random access disk
reads may be reduced. Examples are:
READ_UNCOMMITTED isolation is acceptable.READ_UNCOMMITTED isolation.For other isolation modes (READ_COMMITTED, REPEATABLE_READ and SERIALIZABLE), the performance benefit of a
key cursor is not as significant. In this case, the data item must be
read into the JE cache if it is not already present, in order to lock
the record. The only performance benefit is that the data will not be
copied from the JE cache to the application's entry parameter, and will
not be unmarshalled into an entity object.
For information on specifying isolation modes, see LockMode,
CursorConfig and TransactionConfig.
keys in interface EntityIndex<K,E>txn - the transaction used to protect all operations performed with
the cursor, or null if the operations should not be transaction
protected. If the store is non-transactional, null must be specified.
For a transactional store the transaction is optional for read-only
access and required for read-write access.fromKey - is the lower bound of the key range, or null if the range
has no lower bound.fromInclusive - is true if keys greater than or equal to fromKey
should be included in the key range, or false if only keys greater than
fromKey should be included.toKey - is the upper bound of the key range, or null if the range
has no upper bound.toInclusive - is true if keys less than or equal to toKey should be
included in the key range, or false if only keys less than toKey should
be included.config - the cursor configuration that determines the default lock
mode used for all cursor operations, or null to implicitly use CursorConfig.DEFAULT.DatabaseException - the base class for all BDB exceptions.public EntityCursor<E> entities(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) throws DatabaseException
EntityIndexThe operations performed with the cursor will not be transaction
protected, and CursorConfig.DEFAULT is used implicitly. If the
store is transactional, the cursor may not be used to update or delete
entities.
entities in interface EntityIndex<K,E>fromKey - is the lower bound of the key range, or null if the range
has no lower bound.fromInclusive - is true if keys greater than or equal to fromKey
should be included in the key range, or false if only keys greater than
fromKey should be included.toKey - is the upper bound of the key range, or null if the range
has no upper bound.toInclusive - is true if keys less than or equal to toKey should be
included in the key range, or false if only keys less than toKey should
be included.DatabaseException - the base class for all BDB exceptions.public EntityCursor<E> entities(Transaction txn, K fromKey, boolean fromInclusive, K toKey, boolean toInclusive, CursorConfig config) throws DatabaseException
EntityIndexentities in interface EntityIndex<K,E>txn - the transaction used to protect all operations performed with
the cursor, or null if the operations should not be transaction
protected. If the store is non-transactional, null must be specified.
For a transactional store the transaction is optional for read-only
access and required for read-write access.fromKey - is the lower bound of the key range, or null if the range
has no lower bound.fromInclusive - is true if keys greater than or equal to fromKey
should be included in the key range, or false if only keys greater than
fromKey should be included.toKey - is the upper bound of the key range, or null if the range
has no upper bound.toInclusive - is true if keys less than or equal to toKey should be
included in the key range, or false if only keys less than toKey should
be included.config - the cursor configuration that determines the default lock
mode used for all cursor operations, or null to implicitly use CursorConfig.DEFAULT.DatabaseException - the base class for all BDB exceptions.Copyright (c) 2002, 2017 Oracle and/or its affiliates. All rights reserved.