Java PreparedQuery.asSingleEntity方法代码示例

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
@Test
public void testKeysOnly() throws Exception {
    Entity parent = createTestEntityWithUniqueMethodNameKey("Person", "testKeysOnly");
    Key key = parent.getKey();

    Entity john = createEntity("Person", key)
        .withProperty("name", "John")
        .withProperty("surname", "Doe")
        .store();

    Query query = new Query("Person")
        .setAncestor(key)
        .setKeysOnly();

    PreparedQuery preparedQuery = service.prepare(query);

    Entity entity = preparedQuery.asSingleEntity();
    assertEquals(john.getKey(), entity.getKey());
    assertNull(entity.getProperty("name"));
    assertNull(entity.getProperty("surname"));
}
 

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
@Test
public void testProjectionsWithoutType() throws Exception {
    String methodName = "testProjectionsWithoutType";
    Entity parent = createTestEntityWithUniqueMethodNameKey("Product", methodName);
    Key key = parent.getKey();

    Entity e = createEntity("Product", key)
        .withProperty("long", 123L)
        .store();

    Query query = new Query("Product")
        .setAncestor(key)
        .addProjection(new PropertyProjection("long", null));

    PreparedQuery preparedQuery = service.prepare(query);
    Entity result = preparedQuery.asSingleEntity();
    assertEquals(e.getKey(), result.getKey());

    RawValue rawValue = (RawValue) result.getProperty("long");
    assertEquals(Long.valueOf(123L), rawValue.asType(Long.class));
    assertEquals(Long.valueOf(123L), rawValue.asStrictType(Long.class));
}
 

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
@Test
public void singleEntityThrowsTooManyResultsExceptionWhenMoreThanOneResult() throws Exception {
    String methodName = "singleEntityThrowsTooManyResultsExceptionWhenMoreThanOneResult";
    Key parentKey = createQueryBasicsTestParent(methodName);

    createEntity("Person", parentKey).store();
    createEntity("Person", parentKey).store();

    PreparedQuery preparedQuery = service.prepare(new Query("Person"));
    try {
        preparedQuery.asSingleEntity();
        fail("Expected PreparedQuery.TooManyResultsException");
    } catch (PreparedQuery.TooManyResultsException e) {
        // pass
    }
}
 

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
@Test
public void putStoresEntity() throws Exception {
    DatastoreService ds = DatastoreServiceFactory.getDatastoreService();
    Entity client = new Entity("Client");
    client.setProperty("username", "alesj");
    client.setProperty("password", "password");
    final Key key = ds.put(client);
    try {
        Query query = new Query("Client");
        query.setFilter(new Query.FilterPredicate("username", Query.FilterOperator.EQUAL, "alesj"));
        PreparedQuery pq = ds.prepare(query);
        Entity result = pq.asSingleEntity();
        Assert.assertNotNull(result);
        Assert.assertEquals(key, result.getKey());
        Assert.assertEquals("alesj", result.getProperty("username"));
        Assert.assertEquals("password", result.getProperty("password"));
    } finally {
        ds.delete(key);
    }
}
 

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
@Test
public void createSaveObject() throws Exception {

  Greeting g = new Greeting("default", TEST_CONTENT);
  ObjectifyService.ofy().save().entity(g).now();

  Query query = new Query("Greeting")
      .setAncestor(new KeyFactory.Builder("Guestbook", "default").getKey());
  PreparedQuery pq = ds.prepare(query);
  Entity greeting = pq.asSingleEntity();    // Should only be one at this point.
  assertEquals(greeting.getProperty("content"), TEST_CONTENT);
}
 

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
@Test
public void doPost_userNotLoggedIn() throws Exception {
  servletUnderTest.doPost(mockRequest, mockResponse);

  Query query = new Query("Greeting")
      .setAncestor(new KeyFactory.Builder("Guestbook", "default").getKey());
  PreparedQuery pq = ds.prepare(query);

  Entity greeting = pq.asSingleEntity();    // Should only be one at this point.
  assertEquals(greeting.getProperty("content"), testPhrase);
}
 

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
private Entity retrievePersonWithLastName(String targetLastName) {
  // [START single_retrieval_example]
  Query q =
      new Query("Person")
          .setFilter(new FilterPredicate("lastName", FilterOperator.EQUAL, targetLastName));

  PreparedQuery pq = datastore.prepare(q);
  Entity result = pq.asSingleEntity();
  // [END single_retrieval_example]
  return result;
}
 

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
@Test
public void createSaveObject() throws Exception {

  Greeting g = new Greeting("default", TEST_CONTENT);
  ObjectifyService.ofy().save().entity(g).now();

  Query query =
      new Query("Greeting").setAncestor(new KeyFactory.Builder("Guestbook", "default").getKey());
  PreparedQuery pq = ds.prepare(query);
  Entity greeting = pq.asSingleEntity(); // Should only be one at this point.
  assertEquals(greeting.getProperty("content"), TEST_CONTENT);
}
 

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
@Test
public void doPost_userNotLoggedIn() throws Exception {
  servletUnderTest.doPost(mockRequest, mockResponse);

  Query query =
      new Query("Greeting").setAncestor(new KeyFactory.Builder("Guestbook", "default").getKey());
  PreparedQuery pq = ds.prepare(query);

  Entity greeting = pq.asSingleEntity(); // Should only be one at this point.
  assertEquals(greeting.getProperty("content"), testPhrase);
}
 

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
private User getUserImpl(String userId) {
    /* TODO: キャッシュを使うようにすること */
    Query.Filter filter = new Query.FilterPredicate("userId", Query.FilterOperator.EQUAL, userId);
    Query query = new Query("User").setFilter(filter);
    DatastoreService service = DatastoreServiceFactory.getDatastoreService();
    PreparedQuery preparedQuery = service.prepare(query);
    Entity entity = preparedQuery.asSingleEntity();

    User user = new User(entity);
    return user;
}
 

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
protected void assertSingleResult(Entity expectedEntity, Query query) {
    PreparedQuery preparedQuery = service.prepare(query);
    assertEquals("number of results", 1, preparedQuery.countEntities(withDefaults()));

    Entity entityFromQuery = preparedQuery.asSingleEntity();
    assertEquals(expectedEntity, entityFromQuery);
}
 

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
@Test
public void testQueryOnSomePropertyWithKeyInDifferentNamespace() {
    NamespaceManager.set("one");
    Key keyInNamespaceOne = KeyFactory.createKey("kind", 1);

    NamespaceManager.set("two");
    Query query = new Query("kind").setFilter(new Query.FilterPredicate("someProperty", EQUAL, keyInNamespaceOne));
    PreparedQuery preparedQuery = service.prepare(query);
    preparedQuery.asSingleEntity();    // should not throw IllegalArgumentException as in previous test
    preparedQuery.asIterator().hasNext();    // should not throw IllegalArgumentException as in previous test
    preparedQuery.asList(withDefaults()).size();    // should not throw IllegalArgumentException as in previous test
}
 

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
@Test
public void testProjections() throws Exception {
    Entity parent = createTestEntityWithUniqueMethodNameKey("Product", "testProjections");
    Key key = parent.getKey();

    Entity e = createEntity("Product", key)
        .withProperty("price", 123L)
        .withProperty("percent", 0.123)
        .withProperty("x", -0.321)
        .withProperty("diff", -5L)
        .withProperty("weight", 10L)
        .store();

    Query query = new Query("Product")
        .setAncestor(key)
        .addProjection(new PropertyProjection("price", Long.class))
        .addProjection(new PropertyProjection("percent", Double.class))
        .addProjection(new PropertyProjection("x", Double.class))
        .addProjection(new PropertyProjection("diff", Long.class));

    PreparedQuery preparedQuery = service.prepare(query);
    Entity result = preparedQuery.asSingleEntity();
    assertEquals(e.getKey(), result.getKey());
    assertEquals(e.getProperty("price"), result.getProperty("price"));
    assertEquals(e.getProperty("percent"), result.getProperty("percent"));
    assertEquals(e.getProperty("x"), result.getProperty("x"));
    assertEquals(e.getProperty("diff"), result.getProperty("diff"));
    assertNull(result.getProperty("weight"));
}
 

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
private void assertIAEWhenGettingSingleEntity(PreparedQuery preparedQuery) {
    try {
        preparedQuery.asSingleEntity();
        fail("Expected IllegalArgumentException");
    } catch (IllegalArgumentException ex) {
        // pass
    }
}
 

import com.google.appengine.api.datastore.PreparedQuery; //导入方法依赖的package包/类
/**
 * Gets device entity for a given player and device id.
 *
 * @param playerKey the entity key of the player.
 * @param deviceId the id of the device to retrieve.
 * @return the retrieved device entity or null if there is no device entity for this playerKey and
 *         deviceId.
 */
private Entity getDevice(Key playerKey, String deviceId) {
  Filter deviceIdFilter =
      new FilterPredicate(DeviceEntity.DEVICEID_PROPERTY, FilterOperator.EQUAL, deviceId);

  Query query = new Query(DeviceEntity.KIND, playerKey).setFilter(deviceIdFilter).setKeysOnly();

  PreparedQuery preparedQuery = dataStore.prepare(query);

  return preparedQuery.asSingleEntity();
}