com.google.appengine.api.datastore.KeyRange Java Examples

@Test
public void testCheckKeyRange() throws Exception {
    long initialValue = getInitialValue("OtherKind");

    KeyRange kr1 = new KeyRange(null, "OtherKind", 1 + initialValue, 5 + initialValue);
    DatastoreService.KeyRangeState state1 = service.allocateIdRange(kr1);
    Assert.assertNotNull(state1);
    // imo, it could be either -- depending on the impl
    Assert.assertTrue(DatastoreService.KeyRangeState.CONTENTION == state1 || DatastoreService.KeyRangeState.EMPTY == state1);

    KeyRange kr2 = service.allocateIds("OtherKind", 6);
    Assert.assertNotNull(kr2);

    KeyRange kr3 = new KeyRange(null, "OtherKind", 2 + initialValue, 5 + initialValue);
    DatastoreService.KeyRangeState state2 = service.allocateIdRange(kr3);
    Assert.assertNotNull(state2);
    // can it be both, depending on the impl?
    Assert.assertTrue(DatastoreService.KeyRangeState.COLLISION == state2 || DatastoreService.KeyRangeState.CONTENTION == state2);
}
 

@Test
public void testOutOfRangeEntity() throws Exception {
    final long allocateNum = 5;

    // Range default namespace
    KeyRange range = service.allocateIds(ALLOCATE_IDS_ENTITY, allocateNum);

    Entity noParent = createTestEntity(ALLOCATE_IDS_ENTITY);
    assertEntityNotInRange(noParent, range);

    // Range with specified parent
    Entity parent = new Entity(ALLOCATE_IDS_ENTITY);
    Key parentKey = service.put(parent);
    KeyRange range2 = service.allocateIds(parentKey, ALLOCATE_IDS_ENTITY, allocateNum);

    Entity entity = createTestEntity(ALLOCATE_IDS_ENTITY, parentKey);
    assertEntityNotInRange(entity, range2);

    // In Range entity should have same parent
    Entity child = new Entity(range2.getStart());
    Key childKey = service.put(child);
    // child with allocated key should have correct parent.
    Assert.assertEquals(parentKey, childKey.getParent());
}
 

private boolean rangeOverlap(KeyRange kr1, KeyRange kr2) {
    long firstStart = kr1.getStart().getId();
    long firstEnd = kr1.getEnd().getId();
    long secondStart = kr2.getStart().getId();
    long secondEnd = kr2.getStart().getId();

    if ((firstStart == secondStart) || (firstEnd == secondEnd)) {
        return true;
    }
    if ((firstStart == secondEnd) || (firstEnd == secondStart)) {
        return true;
    }
    if ((firstStart < secondStart) && (firstEnd > secondStart)) {
        return true;
    }
    if ((firstStart > secondStart) && (secondEnd > firstStart)) {
        return true;
    }
    return false;
}
 

@Test
public void identifiers_autoId_setsUnallocatedId() throws Exception {
  KeyRange keys = datastore.allocateIds("Employee", 1);
  long usedId = keys.getStart().getId();

  // [START identifiers_2]
  Entity employee = new Entity("Employee");
  // [END identifiers_2]
  datastore.put(employee);

  assertWithMessage("key id").that(employee.getKey().getId()).isNotEqualTo(usedId);
}
 

@Test
public void testAllocateId() throws Exception {
    KeyRange firstBlock = service.allocateIds(ALLOCATE_IDS_ENTITY, 10L);

    Assert.assertNotNull(firstBlock);
    Assert.assertEquals(10, firstBlock.getEnd().getId() - firstBlock.getStart().getId() + 1);
    Assert.assertEquals(10, firstBlock.getSize());

    KeyRange secondBlock = service.allocateIds(ALLOCATE_IDS_ENTITY, 10L);
    Assert.assertNotNull(secondBlock);
    Assert.assertFalse("Allocated key ranges should not overlap.", rangeOverlap(firstBlock, secondBlock));
}
 

@Test
public void testAllocateChild() {
    Entity parent = new Entity(ALLOCATE_IDS_ENTITY);
    parent.setProperty("name", "parent-" + System.currentTimeMillis());
    Key parentKey = service.put(parent);

    final int allocateSize = 10;
    KeyRange range = service.allocateIds(parentKey, ALLOCATE_IDS_ENTITY, allocateSize);

    Entity child = new Entity(range.getStart());
    Key key = service.put(child);

    // child with allocated key should have correct parent.
    Assert.assertEquals(parentKey, key.getParent());
}
 

@Test
public void testDataAllocate() throws Exception {
    final long allocateNum = 5;

    // Range default namespace
    Future<KeyRange> futureRange = asyncService.allocateIds(ASYNC_ENTITY, allocateNum);
    KeyRange range = futureRange.get();
    assertTaskIsDoneAndNotCancelled(futureRange);

    Entity noParent = createTestEntity(ASYNC_ENTITY);
    assertEntityNotInRange(noParent, range);

    // Range with specified parent
    Entity parent = new Entity(ASYNC_ENTITY);
    parent.setProperty("name", "parent" + new Date());
    Key parentKey = service.put(parent);
    Future<KeyRange> futureRange2 = asyncService.allocateIds(parentKey, ASYNC_ENTITY, allocateNum);
    KeyRange range2 = futureRange2.get();
    assertTaskIsDoneAndNotCancelled(futureRange2);

    Entity noParent2 = createTestEntity(ASYNC_ENTITY, parentKey);
    assertEntityNotInRange(noParent2, range2);

    // In Range entity should have same parent
    Entity child = new Entity(range2.getStart());
    child.setProperty("name", "second" + new Date());
    Key childKey = service.put(child);
    // child with allocated key should have correct parent.
    assertEquals(parentKey, childKey.getParent());
}
 

@Override
public Future<KeyRange> allocateIds(String kind, long num) {
  return delegate.allocateIds(kind, num);
}
 

@Override
public Future<KeyRange> allocateIds(Key parent, String kind, long num) {
  return delegate.allocateIds(parent, kind, num);
}
 

protected void assertEntityNotInRange(Entity entity, KeyRange range) {
    // allocated key should not be re-used.
    Assert.assertTrue(entity.getKey().getId() > range.getEnd().getId() ||
        entity.getKey().getId() < range.getStart().getId());
}