public void testSeparateSequence() throws DatabaseException {
open();
PrimaryIndex<Integer, SeparateSequenceEntity1> priIndex1 =
store.getPrimaryIndex(Integer.class, SeparateSequenceEntity1.class);
PrimaryIndex<Integer, SeparateSequenceEntity2> priIndex2 =
store.getPrimaryIndex(Integer.class, SeparateSequenceEntity2.class);
Transaction txn = txnBegin();
SeparateSequenceEntity1 e1 = new SeparateSequenceEntity1();
SeparateSequenceEntity2 e2 = new SeparateSequenceEntity2();
priIndex1.put(txn, e1);
assertEquals(1, e1.key);
priIndex2.putNoOverwrite(txn, e2);
assertEquals(Integer.valueOf(1), e2.key);
e1.key = 0;
priIndex1.putNoOverwrite(txn, e1);
assertEquals(2, e1.key);
e2.key = null;
priIndex2.put(txn, e2);
assertEquals(Integer.valueOf(2), e2.key);
txnCommit(txn);
close();
}
/** Primary keys: {0, 1, 2, 3, 4} */
@Test
public void testPrimary() throws DatabaseException {
SortedMap<Integer, SortedSet<Integer>> expected = new TreeMap<Integer, SortedSet<Integer>>();
for (int priKey = 0; priKey < N_RECORDS; priKey += 1) {
SortedSet<Integer> values = new TreeSet<Integer>();
values.add(priKey);
expected.put(priKey, values);
}
open();
addEntities(primary);
checkIndex(primary, expected, keyGetter, entityGetter);
checkIndex(primaryRaw, expected, rawKeyGetter, rawEntityGetter);
/* Close and reopen, then recheck indices. */
close();
open();
checkIndex(primary, expected, keyGetter, entityGetter);
checkIndex(primaryRaw, expected, rawKeyGetter, rawEntityGetter);
/* Check primary delete, last key first for variety. */
for (int priKey = N_RECORDS - 1; priKey >= 0; priKey -= 1) {
boolean useRaw = ((priKey & 1) != 0);
Transaction txn = txnBegin();
if (useRaw) {
primaryRaw.delete(txn, priKey);
} else {
primary.delete(txn, priKey);
}
txnCommit(txn);
expected.remove(priKey);
checkIndex(primary, expected, keyGetter, entityGetter);
}
checkAllEmpty();
/* Check PrimaryIndex put operations. */
MyEntity e;
Transaction txn = txnBegin();
/* put() */
e = primary.put(txn, new MyEntity(1));
assertNull(e);
e = primary.get(txn, 1, null);
assertEquals(1, e.key);
/* putNoReturn() */
primary.putNoReturn(txn, new MyEntity(2));
e = primary.get(txn, 2, null);
assertEquals(2, e.key);
/* putNoOverwrite */
assertTrue(!primary.putNoOverwrite(txn, new MyEntity(1)));
assertTrue(!primary.putNoOverwrite(txn, new MyEntity(2)));
assertTrue(primary.putNoOverwrite(txn, new MyEntity(3)));
e = primary.get(txn, 3, null);
assertEquals(3, e.key);
txnCommit(txn);
close();
}
public synchronized <K, E> boolean putNoOverwrite(PrimaryIndex<K, E> index, E entity) {
try {
return index.putNoOverwrite(getDbTransaction(), entity);
} catch (DatabaseException e) {
throw getPersistenceManager().convertDatabaseException(e);
}
}
public void testCompositeSequence() throws DatabaseException {
open();
PrimaryIndex<CompositeSequenceEntity1.Key, CompositeSequenceEntity1> priIndex1 =
store.getPrimaryIndex(CompositeSequenceEntity1.Key.class, CompositeSequenceEntity1.class);
PrimaryIndex<CompositeSequenceEntity2.Key, CompositeSequenceEntity2> priIndex2 =
store.getPrimaryIndex(CompositeSequenceEntity2.Key.class, CompositeSequenceEntity2.class);
Transaction txn = txnBegin();
CompositeSequenceEntity1 e1 = new CompositeSequenceEntity1();
CompositeSequenceEntity2 e2 = new CompositeSequenceEntity2();
priIndex1.put(txn, e1);
assertEquals(1, e1.key.key);
priIndex2.putNoOverwrite(txn, e2);
assertEquals(Integer.valueOf(1), e2.key.key);
e1.key = null;
priIndex1.putNoOverwrite(txn, e1);
assertEquals(2, e1.key.key);
e2.key = null;
priIndex2.put(txn, e2);
assertEquals(Integer.valueOf(2), e2.key.key);
txnCommit(txn);
EntityCursor<CompositeSequenceEntity1> c1 = priIndex1.entities();
e1 = c1.next();
assertEquals(2, e1.key.key);
e1 = c1.next();
assertEquals(1, e1.key.key);
e1 = c1.next();
assertNull(e1);
c1.close();
EntityCursor<CompositeSequenceEntity2> c2 = priIndex2.entities();
e2 = c2.next();
assertEquals(Integer.valueOf(2), e2.key.key);
e2 = c2.next();
assertEquals(Integer.valueOf(1), e2.key.key);
e2 = c2.next();
assertNull(e2);
c2.close();
close();
}
public void testCustomCompare() throws DatabaseException {
open();
PrimaryIndex<ReverseIntKey, CustomCompareEntity> priIndex =
store.getPrimaryIndex(ReverseIntKey.class, CustomCompareEntity.class);
SecondaryIndex<ReverseIntKey, ReverseIntKey, CustomCompareEntity> secIndex1 =
store.getSecondaryIndex(priIndex, ReverseIntKey.class, "secKey1");
SecondaryIndex<ReverseIntKey, ReverseIntKey, CustomCompareEntity> secIndex2 =
store.getSecondaryIndex(priIndex, ReverseIntKey.class, "secKey2");
Transaction txn = txnBegin();
for (int i = 1; i <= 5; i += 1) {
assertTrue(priIndex.putNoOverwrite(txn, new CustomCompareEntity(i)));
}
txnCommit(txn);
txn = txnBeginCursor();
EntityCursor<CustomCompareEntity> c = priIndex.entities(txn, null);
for (int i = 5; i >= 1; i -= 1) {
CustomCompareEntity e = c.next();
assertNotNull(e);
assertEquals(new ReverseIntKey(i), e.key);
}
c.close();
txnCommit(txn);
txn = txnBeginCursor();
c = secIndex1.entities(txn, null);
for (int i = -1; i >= -5; i -= 1) {
CustomCompareEntity e = c.next();
assertNotNull(e);
assertEquals(new ReverseIntKey(-i), e.key);
assertEquals(new ReverseIntKey(i), e.secKey1);
}
c.close();
txnCommit(txn);
txn = txnBeginCursor();
c = secIndex2.entities(txn, null);
for (int i = -1; i >= -5; i -= 1) {
CustomCompareEntity e = c.next();
assertNotNull(e);
assertEquals(new ReverseIntKey(-i), e.key);
assertTrue(e.secKey2.contains(new ReverseIntKey(i)));
}
c.close();
txnCommit(txn);
close();
}
