public void testUpdateOneBigRecord() throws IOException {
byte[] bigRecord = new byte[2 * 65536 + 100];
MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast();
mersenneTwisterFast.nextBytes(bigRecord);
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
OPhysicalPosition physicalPosition = paginatedCluster.createRecord(bigRecord, recordVersion, (byte) 1);
Assert.assertEquals(physicalPosition.clusterPosition, OClusterPositionFactory.INSTANCE.valueOf(0));
recordVersion.increment();
bigRecord = new byte[2 * 65536 + 20];
mersenneTwisterFast.nextBytes(bigRecord);
paginatedCluster.updateRecord(physicalPosition.clusterPosition, bigRecord, recordVersion, (byte) 2);
ORawBuffer rawBuffer = paginatedCluster.readRecord(physicalPosition.clusterPosition);
Assert.assertNotNull(rawBuffer);
Assert.assertEquals(rawBuffer.version, recordVersion);
Assert.assertEquals(rawBuffer.buffer, bigRecord);
Assert.assertEquals(rawBuffer.recordType, 2);
}
public void testGetPhysicalPosition() throws IOException {
final int records = 10000;
long seed = System.currentTimeMillis();
MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast(seed);
System.out.println("testGetPhysicalPosition seed : " + seed);
Set<OPhysicalPosition> positions = new HashSet<OPhysicalPosition>();
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
for (int i = 0; i < records; i++) {
int recordSize = mersenneTwisterFast.nextInt(2 * OClusterPage.MAX_RECORD_SIZE) + 1;
byte[] record = new byte[recordSize];
mersenneTwisterFast.nextBytes(record);
recordVersion.increment();
final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(record, recordVersion, (byte) i);
positions.add(physicalPosition);
}
Set<OPhysicalPosition> removedPositions = new HashSet<OPhysicalPosition>();
for (OPhysicalPosition position : positions) {
OPhysicalPosition physicalPosition = new OPhysicalPosition();
physicalPosition.clusterPosition = position.clusterPosition;
physicalPosition = paginatedCluster.getPhysicalPosition(physicalPosition);
Assert.assertEquals(physicalPosition.clusterPosition, position.clusterPosition);
Assert.assertEquals(physicalPosition.recordType, position.recordType);
Assert.assertEquals(physicalPosition.recordSize, position.recordSize);
Assert.assertEquals(physicalPosition.dataSegmentPos, position.dataSegmentPos);
Assert.assertEquals(physicalPosition.dataSegmentId, position.dataSegmentId);
if (mersenneTwisterFast.nextBoolean()) {
paginatedCluster.deleteRecord(position.clusterPosition);
removedPositions.add(position);
}
}
for (OPhysicalPosition position : positions) {
OPhysicalPosition physicalPosition = new OPhysicalPosition();
physicalPosition.clusterPosition = position.clusterPosition;
physicalPosition = paginatedCluster.getPhysicalPosition(physicalPosition);
if (removedPositions.contains(position))
Assert.assertNull(physicalPosition);
else {
Assert.assertEquals(physicalPosition.clusterPosition, position.clusterPosition);
Assert.assertEquals(physicalPosition.recordType, position.recordType);
Assert.assertEquals(physicalPosition.recordSize, position.recordSize);
Assert.assertEquals(physicalPosition.dataSegmentPos, position.dataSegmentPos);
Assert.assertEquals(physicalPosition.dataSegmentId, position.dataSegmentId);
}
}
}
public void testAddManyRecords() throws IOException {
final int records = 10000;
long seed = System.currentTimeMillis();
MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast(seed);
System.out.println("testAddManyRecords seed : " + seed);
Map<OClusterPosition, byte[]> positionRecordMap = new HashMap<OClusterPosition, byte[]>();
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
for (int i = 0; i < records; i++) {
int recordSize = mersenneTwisterFast.nextInt(2 * OClusterPage.MAX_RECORD_SIZE) + 1;
byte[] smallRecord = new byte[recordSize];
mersenneTwisterFast.nextBytes(smallRecord);
final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(smallRecord, recordVersion, (byte) 2);
positionRecordMap.put(physicalPosition.clusterPosition, smallRecord);
}
for (Map.Entry<OClusterPosition, byte[]> entry : positionRecordMap.entrySet()) {
ORawBuffer rawBuffer = paginatedCluster.readRecord(entry.getKey());
Assert.assertNotNull(rawBuffer);
Assert.assertEquals(rawBuffer.version, recordVersion);
Assert.assertEquals(rawBuffer.buffer, entry.getValue());
Assert.assertEquals(rawBuffer.recordType, 2);
}
}
public void testKeyPutRandomUniform() throws Exception {
final NavigableSet<Integer> keys = new TreeSet<Integer>();
long seed = System.currentTimeMillis();
System.out.println("testKeyPutRandomUniform seed : " + seed);
final MersenneTwisterFast random = new MersenneTwisterFast(seed);
while (keys.size() < KEYS_COUNT) {
int key = random.nextInt(Integer.MAX_VALUE);
sbTree.put(key, createValue(key, OSBTreeValuePage.MAX_BINARY_VALUE_SIZE + 4));
keys.add(key);
doReset();
}
Assert.assertEquals(sbTree.firstKey(), keys.first());
doReset();
Assert.assertEquals(sbTree.lastKey(), keys.last());
doReset();
for (int key : keys) {
Assert.assertEquals(
sbTree.get(key), createValue(key, OSBTreeValuePage.MAX_BINARY_VALUE_SIZE + 4));
doReset();
}
}
public void testBackwardIteration() throws IOException {
final int records = 10000;
long seed = System.currentTimeMillis();
MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast(1381162033616L);
System.out.println("testBackwardIteration seed : " + seed);
NavigableMap<OClusterPosition, byte[]> positionRecordMap = new TreeMap<OClusterPosition, byte[]>();
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
for (int i = 0; i < records; i++) {
int recordSize = mersenneTwisterFast.nextInt(2 * OClusterPage.MAX_RECORD_SIZE) + 1;
byte[] record = new byte[recordSize];
mersenneTwisterFast.nextBytes(record);
final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(record, recordVersion, (byte) 2);
positionRecordMap.put(physicalPosition.clusterPosition, record);
}
Iterator<OClusterPosition> positionIterator = positionRecordMap.keySet().iterator();
while (positionIterator.hasNext()) {
OClusterPosition clusterPosition = positionIterator.next();
if (mersenneTwisterFast.nextBoolean()) {
Assert.assertTrue(paginatedCluster.deleteRecord(clusterPosition));
positionIterator.remove();
}
}
OPhysicalPosition physicalPosition = new OPhysicalPosition();
physicalPosition.clusterPosition = OClusterPositionFactory.INSTANCE.valueOf(Long.MAX_VALUE);
OPhysicalPosition[] positions = paginatedCluster.floorPositions(physicalPosition);
Assert.assertTrue(positions.length > 0);
positionIterator = positionRecordMap.descendingKeySet().iterator();
int counter = 0;
while (positionIterator.hasNext()) {
Assert.assertTrue(positions.length > 0);
OClusterPosition testedPosition = positionIterator.next();
Assert.assertEquals(positions[positions.length - 1].clusterPosition, testedPosition);
OPhysicalPosition positionToFind = positions[positions.length - 1];
positions = paginatedCluster.lowerPositions(positionToFind);
counter++;
}
Assert.assertEquals(paginatedCluster.getEntries(), counter);
Assert.assertEquals(paginatedCluster.getFirstPosition(), positionRecordMap.firstKey());
Assert.assertEquals(paginatedCluster.getLastPosition(), positionRecordMap.lastKey());
}
public void testRemoveHalfRecords() throws IOException {
final int records = 10000;
long seed = System.currentTimeMillis();
MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast(seed);
System.out.println("testRemoveHalfRecords seed : " + seed);
Map<OClusterPosition, byte[]> positionRecordMap = new HashMap<OClusterPosition, byte[]>();
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
for (int i = 0; i < records; i++) {
int recordSize = mersenneTwisterFast.nextInt(3 * OClusterPage.MAX_RECORD_SIZE) + 1;
byte[] bigRecord = new byte[recordSize];
mersenneTwisterFast.nextBytes(bigRecord);
final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(bigRecord, recordVersion, (byte) 2);
positionRecordMap.put(physicalPosition.clusterPosition, bigRecord);
}
int deletedRecords = 0;
Assert.assertEquals(records, paginatedCluster.getEntries());
Set<OClusterPosition> deletedPositions = new HashSet<OClusterPosition>();
Iterator<OClusterPosition> positionIterator = positionRecordMap.keySet().iterator();
while (positionIterator.hasNext()) {
OClusterPosition clusterPosition = positionIterator.next();
if (mersenneTwisterFast.nextBoolean()) {
deletedPositions.add(clusterPosition);
Assert.assertTrue(paginatedCluster.deleteRecord(clusterPosition));
deletedRecords++;
Assert.assertEquals(records - deletedRecords, paginatedCluster.getEntries());
positionIterator.remove();
}
}
Assert.assertEquals(paginatedCluster.getEntries(), records - deletedRecords);
for (OClusterPosition deletedPosition : deletedPositions) {
Assert.assertNull(paginatedCluster.readRecord(deletedPosition));
Assert.assertFalse(paginatedCluster.deleteRecord(deletedPosition));
}
for (Map.Entry<OClusterPosition, byte[]> entry : positionRecordMap.entrySet()) {
ORawBuffer rawBuffer = paginatedCluster.readRecord(entry.getKey());
Assert.assertNotNull(rawBuffer);
Assert.assertEquals(rawBuffer.version, recordVersion);
Assert.assertEquals(rawBuffer.buffer, entry.getValue());
Assert.assertEquals(rawBuffer.recordType, 2);
}
}
public byte calculateSignature(OClusterPosition key) {
if (threadLocalRandom.get() == null) {
threadLocalRandom.set(new MersenneTwisterFast());
}
MersenneTwisterFast random = threadLocalRandom.get();
random.setSeed(key.longValue());
return (byte) (random.nextInt() & 0xFF);
}
public void testKeyDeleteRandomGaussian() throws Exception {
NavigableSet<Integer> keys = new TreeSet<Integer>();
long seed = System.currentTimeMillis();
System.out.println("testKeyDeleteRandomGaussian seed : " + seed);
MersenneTwisterFast random = new MersenneTwisterFast(seed);
while (keys.size() < KEYS_COUNT) {
int key = (int) (random.nextGaussian() * Integer.MAX_VALUE / 2 + Integer.MAX_VALUE);
if (key < 0) continue;
sbTree.put(key, createValue(key, OSBTreeValuePage.MAX_BINARY_VALUE_SIZE + 4));
keys.add(key);
Assert.assertEquals(
sbTree.get(key), createValue(key, OSBTreeValuePage.MAX_BINARY_VALUE_SIZE + 4));
doReset();
}
Iterator<Integer> keysIterator = keys.iterator();
while (keysIterator.hasNext()) {
int key = keysIterator.next();
if (key % 3 == 0) {
sbTree.remove(key);
keysIterator.remove();
}
doReset();
}
Assert.assertEquals(sbTree.firstKey(), keys.first());
doReset();
Assert.assertEquals(sbTree.lastKey(), keys.last());
doReset();
for (int key : keys) {
if (key % 3 == 0) {
Assert.assertNull(sbTree.get(key));
} else {
Assert.assertEquals(
sbTree.get(key), createValue(key, OSBTreeValuePage.MAX_BINARY_VALUE_SIZE + 4));
}
doReset();
}
}
public void testUpdateManySmallRecords() throws IOException {
final int records = 10000;
long seed = System.currentTimeMillis();
MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast(seed);
System.out.println("testUpdateManySmallRecords seed : " + seed);
Map<OClusterPosition, byte[]> positionRecordMap = new HashMap<OClusterPosition, byte[]>();
Set<OClusterPosition> updatedPositions = new HashSet<OClusterPosition>();
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
for (int i = 0; i < records; i++) {
int recordSize = mersenneTwisterFast.nextInt(OClusterPage.MAX_RECORD_SIZE - 1) + 1;
byte[] smallRecord = new byte[recordSize];
mersenneTwisterFast.nextBytes(smallRecord);
final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(smallRecord, recordVersion, (byte) 2);
positionRecordMap.put(physicalPosition.clusterPosition, smallRecord);
}
ORecordVersion newRecordVersion = OVersionFactory.instance().createVersion();
newRecordVersion.copyFrom(recordVersion);
newRecordVersion.increment();
for (OClusterPosition clusterPosition : positionRecordMap.keySet()) {
if (mersenneTwisterFast.nextBoolean()) {
int recordSize = mersenneTwisterFast.nextInt(OClusterPage.MAX_RECORD_SIZE - 1) + 1;
byte[] smallRecord = new byte[recordSize];
mersenneTwisterFast.nextBytes(smallRecord);
paginatedCluster.updateRecord(clusterPosition, smallRecord, newRecordVersion, (byte) 3);
positionRecordMap.put(clusterPosition, smallRecord);
updatedPositions.add(clusterPosition);
}
}
for (Map.Entry<OClusterPosition, byte[]> entry : positionRecordMap.entrySet()) {
ORawBuffer rawBuffer = paginatedCluster.readRecord(entry.getKey());
Assert.assertNotNull(rawBuffer);
Assert.assertEquals(rawBuffer.buffer, entry.getValue());
if (updatedPositions.contains(entry.getKey())) {
Assert.assertEquals(rawBuffer.version, newRecordVersion);
Assert.assertEquals(rawBuffer.recordType, 3);
} else {
Assert.assertEquals(rawBuffer.version, recordVersion);
Assert.assertEquals(rawBuffer.recordType, 2);
}
}
}
public void testRemoveHalfRecordsAndAddAnotherHalfAgain() throws IOException {
final int records = 10000;
long seed = System.currentTimeMillis();
MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast(seed);
System.out.println("testRemoveHalfRecordsAndAddAnotherHalfAgain seed : " + seed);
Map<OClusterPosition, byte[]> positionRecordMap = new HashMap<OClusterPosition, byte[]>();
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
for (int i = 0; i < records; i++) {
int recordSize = mersenneTwisterFast.nextInt(3 * OClusterPage.MAX_RECORD_SIZE) + 1;
byte[] bigRecord = new byte[recordSize];
mersenneTwisterFast.nextBytes(bigRecord);
final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(bigRecord, recordVersion, (byte) 2);
positionRecordMap.put(physicalPosition.clusterPosition, bigRecord);
}
int deletedRecords = 0;
Assert.assertEquals(records, paginatedCluster.getEntries());
Iterator<OClusterPosition> positionIterator = positionRecordMap.keySet().iterator();
while (positionIterator.hasNext()) {
OClusterPosition clusterPosition = positionIterator.next();
if (mersenneTwisterFast.nextBoolean()) {
Assert.assertTrue(paginatedCluster.deleteRecord(clusterPosition));
deletedRecords++;
Assert.assertEquals(paginatedCluster.getEntries(), records - deletedRecords);
positionIterator.remove();
}
}
Assert.assertEquals(paginatedCluster.getEntries(), records - deletedRecords);
for (int i = 0; i < records / 2; i++) {
int recordSize = mersenneTwisterFast.nextInt(3 * OClusterPage.MAX_RECORD_SIZE) + 1;
byte[] bigRecord = new byte[recordSize];
mersenneTwisterFast.nextBytes(bigRecord);
final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(bigRecord, recordVersion, (byte) 2);
positionRecordMap.put(physicalPosition.clusterPosition, bigRecord);
}
Assert.assertEquals(paginatedCluster.getEntries(), (long) (1.5 * records - deletedRecords));
}
@Override
@Test(enabled = false)
public void cycle() throws Exception {
String key = "bsadfasfas" + random.nextInt();
hashIndex.put(key, new ORecordId(0, new OClusterPositionLong(0)));
}