Java 类com.google.appengine.api.datastore.PreparedQuery 实例源码

/**
 * Method to retrieve the national high scores 
 * @return
 */
public List<Entity> getNationalHighScores(String countryCode){
    log.info("Retrieving national high scores");

    //create the country code filter
    Filter country = new FilterPredicate(Constants.COUNTRY_CODE,FilterOperator.EQUAL,countryCode);
    //create the query to read the records sorted by score
    Query q = new Query(Constants.RECORD).addSort(Constants.SCORE, SortDirection.DESCENDING);
    //set the filter to the query
    q.setFilter(country);

    PreparedQuery pq = datastore.prepare(q);

    //retrieve and return the list of records   
    return pq.asList(FetchOptions.Builder.withLimit(100));
}

/**
 * Method to retrieve the monthly high scores 
 * @return
 */
public List<Entity> getMonthlyHighScores(){
    log.info("Retrieving monthly high scores");

    //calculate calendar info
    Calendar calendar= Calendar.getInstance();      
    int year=calendar.get(Calendar.YEAR);
    int month=calendar.get(Calendar.MONTH);

    //create filters
    Filter yearFilter = new FilterPredicate(Constants.YEAR,FilterOperator.EQUAL,year);
    Filter monthFilter = new FilterPredicate(Constants.MONTH,FilterOperator.EQUAL,month);

    //create the query to read the records sorted by score
    Query q = new Query(Constants.RECORD).addSort(Constants.SCORE, SortDirection.DESCENDING);
    //set filters to the query
    q.setFilter(yearFilter);
    q.setFilter(monthFilter);

    //prepare query
    PreparedQuery pq = datastore.prepare(q);

    //retrieve and return the list of records   
    return pq.asList(FetchOptions.Builder.withLimit(100));
}

/**
 * Method to retrieve the weekly high scores 
 * @return
 */
public List<Entity> getWeeklyHighScores(){
    log.info("Retrieving weekly high scores");

    //calculate calendar info
    Calendar calendar= Calendar.getInstance();      
    int year=calendar.get(Calendar.YEAR);
    int week=calendar.get(Calendar.WEEK_OF_YEAR);

    //create filters
    Filter yearFilter = new FilterPredicate(Constants.YEAR,FilterOperator.EQUAL,year);
    Filter weekFilter = new FilterPredicate(Constants.WEEK_OF_THE_YEAR,FilterOperator.EQUAL,week);

    //create the query to read the records sorted by score
    Query q = new Query(Constants.RECORD).addSort(Constants.SCORE, SortDirection.DESCENDING);
    //set filters to the query
    q.setFilter(yearFilter);
    q.setFilter(weekFilter);

    //prepare query
    PreparedQuery pq = datastore.prepare(q);

    //retrieve and return the list of records   
    return pq.asList(FetchOptions.Builder.withLimit(100));
}

/**
 * Method to retrieve the daily high scores 
 * @return
 */
public List<Entity> getDailyHighScores(){
    log.info("Retrieving weekly high scores");

    //calculate calendar info
    Calendar calendar= Calendar.getInstance();
    int year=calendar.get(Calendar.YEAR);
    int day=calendar.get(Calendar.DAY_OF_YEAR);

    //create filters
    Filter yearFilter = new FilterPredicate(Constants.YEAR,FilterOperator.EQUAL,year);
    Filter dayFilter = new FilterPredicate(Constants.DAY_OF_THE_YEAR,FilterOperator.EQUAL,day);

    //create the query to read the records sorted by score
    Query q = new Query(Constants.RECORD).addSort(Constants.SCORE, SortDirection.DESCENDING);

    //set filters to the query
    q.setFilter(yearFilter);
    q.setFilter(dayFilter);

    //prepare query
    PreparedQuery pq = datastore.prepare(q);

    //retrieve and return the list of records   
    return pq.asList(FetchOptions.Builder.withLimit(100));
}

@Override
public Result<Book> listBooks(String startCursorString) {
  FetchOptions fetchOptions = FetchOptions.Builder.withLimit(10); // Only show 10 at a time
  if (startCursorString != null && !startCursorString.equals("")) {
    fetchOptions.startCursor(Cursor.fromWebSafeString(startCursorString)); // Where we left off
  }
  Query query = new Query(BOOK_KIND) // We only care about Books
      .addSort(Book.TITLE, SortDirection.ASCENDING); // Use default Index "title"
  PreparedQuery preparedQuery = datastore.prepare(query);
  QueryResultIterator<Entity> results = preparedQuery.asQueryResultIterator(fetchOptions);

  List<Book> resultBooks = entitiesToBooks(results);     // Retrieve and convert Entities
  Cursor cursor = results.getCursor();              // Where to start next time
  if (cursor != null && resultBooks.size() == 10) {         // Are we paging? Save Cursor
    String cursorString = cursor.toWebSafeString();               // Cursors are WebSafe
    return new Result<>(resultBooks, cursorString);
  } else {
    return new Result<>(resultBooks);
  }
}

@Override
public Result<Book> listBooksByUser(String userId, String startCursorString) {
  FetchOptions fetchOptions = FetchOptions.Builder.withLimit(10); // Only show 10 at a time
  if (startCursorString != null && !startCursorString.equals("")) {
    fetchOptions.startCursor(Cursor.fromWebSafeString(startCursorString)); // Where we left off
  }
  Query query = new Query(BOOK_KIND) // We only care about Books
      // Only for this user
      .setFilter(new Query.FilterPredicate(
          Book.CREATED_BY_ID, Query.FilterOperator.EQUAL, userId))
      // a custom datastore index is required since you are filtering by one property
      // but ordering by another
      .addSort(Book.TITLE, SortDirection.ASCENDING);
  PreparedQuery preparedQuery = datastore.prepare(query);
  QueryResultIterator<Entity> results = preparedQuery.asQueryResultIterator(fetchOptions);

  List<Book> resultBooks = entitiesToBooks(results);     // Retrieve and convert Entities
  Cursor cursor = results.getCursor();              // Where to start next time
  if (cursor != null && resultBooks.size() == 10) {         // Are we paging? Save Cursor
    String cursorString = cursor.toWebSafeString();               // Cursors are WebSafe
    return new Result<>(resultBooks, cursorString);
  } else {
    return new Result<>(resultBooks);
  }
}

@Override
public Result<Book> listBooks(String startCursorString) {
  FetchOptions fetchOptions = FetchOptions.Builder.withLimit(10); // Only show 10 at a time
  if (startCursorString != null && !startCursorString.equals("")) {
    fetchOptions.startCursor(Cursor.fromWebSafeString(startCursorString)); // Where we left off
  }
  Query query = new Query(BOOK_KIND) // We only care about Books
      .addSort(Book.TITLE, SortDirection.ASCENDING); // Use default Index "title"
  PreparedQuery preparedQuery = datastore.prepare(query);
  QueryResultIterator<Entity> results = preparedQuery.asQueryResultIterator(fetchOptions);

  List<Book> resultBooks = entitiesToBooks(results);     // Retrieve and convert Entities
  Cursor cursor = results.getCursor();              // Where to start next time
  if (cursor != null && resultBooks.size() == 10) {         // Are we paging? Save Cursor
    String cursorString = cursor.toWebSafeString();               // Cursors are WebSafe
    return new Result<>(resultBooks, cursorString);
  } else {
    return new Result<>(resultBooks);
  }
}

@Override
public Result<Book> listBooks(String startCursorString) {
  FetchOptions fetchOptions = FetchOptions.Builder.withLimit(10); // Only show 10 at a time
  if (startCursorString != null && !startCursorString.equals("")) {
    fetchOptions.startCursor(Cursor.fromWebSafeString(startCursorString)); // Where we left off
  }
  Query query = new Query(BOOK_KIND) // We only care about Books
      .addSort(Book.TITLE, SortDirection.ASCENDING); // Use default Index "title"
  PreparedQuery preparedQuery = datastore.prepare(query);
  QueryResultIterator<Entity> results = preparedQuery.asQueryResultIterator(fetchOptions);

  List<Book> resultBooks = entitiesToBooks(results);     // Retrieve and convert Entities
  Cursor cursor = results.getCursor();              // Where to start next time
  if (cursor != null && resultBooks.size() == 10) {         // Are we paging? Save Cursor
    String cursorString = cursor.toWebSafeString();               // Cursors are WebSafe
    return new Result<>(resultBooks, cursorString);
  } else {
    return new Result<>(resultBooks);
  }
}

@Override
public Result<Book> listBooks(String startCursorString) {
  FetchOptions fetchOptions = FetchOptions.Builder.withLimit(10); // Only show 10 at a time
  if (startCursorString != null && !startCursorString.equals("")) {
    fetchOptions.startCursor(Cursor.fromWebSafeString(startCursorString)); // Where we left off
  }
  Query query = new Query(BOOK_KIND) // We only care about Books
      .addSort(Book.TITLE, SortDirection.ASCENDING); // Use default Index "title"
  PreparedQuery preparedQuery = datastore.prepare(query);
  QueryResultIterator<Entity> results = preparedQuery.asQueryResultIterator(fetchOptions);

  List<Book> resultBooks = entitiesToBooks(results);     // Retrieve and convert Entities
  Cursor cursor = results.getCursor();              // Where to start next time
  if (cursor != null && resultBooks.size() == 10) {         // Are we paging? Save Cursor
    String cursorString = cursor.toWebSafeString();               // Cursors are WebSafe
    return new Result<>(resultBooks, cursorString);
  } else {
    return new Result<>(resultBooks);
  }
}

@Override
public Result<Book> listBooksByUser(String userId, String startCursorString) {
  FetchOptions fetchOptions = FetchOptions.Builder.withLimit(10); // Only show 10 at a time
  if (startCursorString != null && !startCursorString.equals("")) {
    fetchOptions.startCursor(Cursor.fromWebSafeString(startCursorString)); // Where we left off
  }
  Query query = new Query(BOOK_KIND) // We only care about Books
      // Only for this user
      .setFilter(new Query.FilterPredicate(
          Book.CREATED_BY_ID, Query.FilterOperator.EQUAL, userId))
      // a custom datastore index is required since you are filtering by one property
      // but ordering by another
      .addSort(Book.TITLE, SortDirection.ASCENDING);
  PreparedQuery preparedQuery = datastore.prepare(query);
  QueryResultIterator<Entity> results = preparedQuery.asQueryResultIterator(fetchOptions);

  List<Book> resultBooks = entitiesToBooks(results);     // Retrieve and convert Entities
  Cursor cursor = results.getCursor();              // Where to start next time
  if (cursor != null && resultBooks.size() == 10) {         // Are we paging? Save Cursor
    String cursorString = cursor.toWebSafeString();               // Cursors are WebSafe
    return new Result<>(resultBooks, cursorString);
  } else {
    return new Result<>(resultBooks);
  }
}

/**
 * Determine whether this relation already exists.
 * 
 * @return false because we don't care about naming collisions.
 * @throws ODKDatastoreException 
 */
@Override
public boolean hasRelation(String schema, String tableName, User user) throws ODKDatastoreException {
  List<com.google.appengine.api.datastore.Entity> gaeKeys = null;
  try {
    com.google.appengine.api.datastore.Query query = new com.google.appengine.api.datastore.Query(
        schema + "." + tableName);
    query.setKeysOnly();
    PreparedQuery preparedQuery = ds.prepare(query);
    gaeKeys = preparedQuery.asList(FetchOptions.Builder.withLimit(2));
  } catch (OverQuotaException e) {
    throw new ODKOverQuotaException(e);
  } catch (Exception ex) {
    // No-op
  }
  if (gaeKeys == null || gaeKeys.size() == 0)
    return false;
  return true;
}

public static List<StoryPage> getPagesWrittenBy(final String authorId,
        final int start, final int end) {
    final DatastoreQuery query = new DatastoreQuery(KIND_NAME);
    query.addSort(BEGINNING_NUMBER_PROPERTY);
    query.addSort(ID_NUMBER_PROPERTY);
    query.addSort(ID_VERSION_PROPERTY);
    final Filter filter = getAuthorIdFilter(authorId);
    query.setFilter(filter);
    final Store store = new Store();
    final PreparedQuery preparedQuery = store.prepare(query);
    final int limit = end - start;
    final FetchOptions fetchOptions = FetchOptions.Builder.withLimit(limit);
    final int offset = start;
    fetchOptions.offset(offset);
    final List<DatastoreEntity> entities = DatastoreEntity
            .fromPreparedQuery(preparedQuery, fetchOptions);
    final List<StoryPage> pages = getPagesFromEntities(entities);
    return pages;
}

@Override
public Set<String> getRootPipelinesDisplayName() {
  Query query = new Query(JobRecord.DATA_STORE_KIND);
  query.addProjection(
      new PropertyProjection(JobRecord.ROOT_JOB_DISPLAY_NAME, String.class));
  query.setDistinct(true);
  final PreparedQuery preparedQuery = dataStore.prepare(query);
  return tryFiveTimes(new Operation<Set<String>>("getRootPipelinesDisplayName") {
    @Override
    public Set<String> call() {
      Set<String> pipelines = new LinkedHashSet<>();
      for (Entity entity : preparedQuery.asIterable()) {
        pipelines.add((String) entity.getProperty(JobRecord.ROOT_JOB_DISPLAY_NAME));
      }
      return pipelines;
    }
  });
}

private void deleteAll(final String kind, final Key rootJobKey) {
  logger.info("Deleting all " + kind + " with rootJobKey=" + rootJobKey);
  final int chunkSize = 100;
  final FetchOptions fetchOptions = FetchOptions.Builder.withChunkSize(chunkSize);
  final PreparedQuery preparedQuery = dataStore.prepare(new Query(kind).setKeysOnly().setFilter(
      new FilterPredicate(ROOT_JOB_KEY_PROPERTY, EQUAL, rootJobKey)));
  tryFiveTimes(new Operation<Void>("delete") {
    @Override
    public Void call() {
      Iterator<Entity> iter = preparedQuery.asIterator(fetchOptions);
      while (iter.hasNext()) {
        ArrayList<Key> keys = new ArrayList<>(chunkSize);
        for (int i = 0; i < chunkSize && iter.hasNext(); i++) {
          keys.add(iter.next().getKey());
        }
        logger.info("Deleting  " + keys.size() + " " + kind + "s with rootJobKey=" + rootJobKey);
        dataStore.delete(null, keys);
      }
      return null;
    }
  });
}

@Override
public Map<String, SessionData> getAllSessions() {
  final String originalNamespace = NamespaceManager.get();
  NamespaceManager.set("");
  try {
    DatastoreService ds = DatastoreServiceFactory.getDatastoreService();
    PreparedQuery pq = ds.prepare(new Query(SESSION_ENTITY_TYPE));
    Map<String, SessionData> sessions = new HashMap<>();
    for (Entity entity : pq.asIterable()) {
      sessions.put(entity.getKey().getName(), createSessionFromEntity(entity));
    }
    return sessions;
  } finally {
    NamespaceManager.set(originalNamespace);
  }
}

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    /* prepare users */
    DatastoreService service = DatastoreServiceFactory.getDatastoreService();
    Query query = new Query("User");
    PreparedQuery pq = service.prepare(query);
    ArrayList<User> users = new ArrayList<User>();
    for(Entity entity : pq.asIterable()) {
        User user = new User(entity);
        users.add(user);
    }
    req.setAttribute("users", users);

    RequestDispatcher dispatcher = getServletContext().getRequestDispatcher("/WEB-INF/backend/users.jsp");
    dispatcher.forward(req, resp);
}

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    /* prepare remarks */
    UserDomain domain = UserDomain.getInstance();
    DatastoreService service = DatastoreServiceFactory.getDatastoreService();
    Query query = new Query("Remark");
    query.addSort("createdAt", Query.SortDirection.DESCENDING);
    PreparedQuery pq = service.prepare(query);
    ArrayList<Remark> remarks = new ArrayList<Remark>();
    for (Entity entity : pq.asIterable()) {
        Remark remark = new Remark(entity);
        remarks.add(remark);
    }
    req.setAttribute("remarks", remarks);

    RequestDispatcher dispatcher = getServletContext().getRequestDispatcher("/WEB-INF/backend/remarks.jsp");
    dispatcher.forward(req, resp);
}

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    /* prepare talks */
    UserDomain domain = UserDomain.getInstance();
    DatastoreService service = DatastoreServiceFactory.getDatastoreService();
    Query query = new Query("Talk");
    query.addSort("createdAt", Query.SortDirection.DESCENDING);
    PreparedQuery pq = service.prepare(query);
    ArrayList<Talk> talks = new ArrayList<Talk>();
    for (Entity talk : pq.asIterable()) {
        Talk talkValue = new Talk(talk);
        talks.add(talkValue);
    }
    req.setAttribute("talks", talks);

    RequestDispatcher dispatcher = getServletContext().getRequestDispatcher("/WEB-INF/backend/talks.jsp");
    dispatcher.forward(req, resp);
}

public List<Patient> getPatients(List<String> patientIdList) {
    Query.Filter userIdFilter = new Query.FilterPredicate("userId", Query.FilterOperator.IN, patientIdList);
    Query.Filter roleFilter = new Query.FilterPredicate("role", Query.FilterOperator.EQUAL, RoleType.PATIENT.name());
    Query query = new Query("User").setFilter(Query.CompositeFilterOperator.and(userIdFilter, roleFilter));
    DatastoreService service = DatastoreServiceFactory.getDatastoreService();
    PreparedQuery preparedQuery = service.prepare(query);
    ArrayList<Patient> patients = new ArrayList<Patient>();
    for(Entity entity : preparedQuery.asIterable()) {
        User user = new User(entity);
        Patient patient = new Patient();
        patient.setUserId(user.getUserId());
        patient.setFirstName(user.getFirstName());
        patient.setLastName(user.getLastName());
        patients.add(patient);
    }
    return patients;

}

private static Entity findDeviceByRegId(String regId) {
  Query query = new Query(DEVICE_TYPE)
      .addFilter(DEVICE_REG_ID_PROPERTY, FilterOperator.EQUAL, regId);
  PreparedQuery preparedQuery = datastore.prepare(query);
  List<Entity> entities = preparedQuery.asList(DEFAULT_FETCH_OPTIONS);
  Entity entity = null;
  if (!entities.isEmpty()) {
    entity = entities.get(0);
  }
  int size = entities.size();
  if (size > 0) {
    logger.severe(
        "Found " + size + " entities for regId " + regId + ": " + entities);
  }
  return entity;
}

/**
 * Finds the {@code TestReport} with the given build type id ordered by build id in the descendant order.
 *
 * @param buildTypeId      the build type id.
 * @param limit            the optional fetch limit, by default {@link com.google.appengine.tck.site.endpoints.TestReport#DEFAULT_FETCH_LIMIT}.
 * @param reports          the reports entry point
 * @return the matching test reports list or an empty one if none.
 */
@SuppressWarnings("unchecked")
public static List<TestReport> findByBuildTypeIdOrderByBuildIdDesc(String buildTypeId, Optional<Integer> limit, Reports reports) {
    final MemcacheService memcacheService = reports.getMemcacheService();
    List<TestReport> results = (List<TestReport>) memcacheService.get(buildTypeId);
    if (results == null) {
        final Filter buildTypeFilter = new Query.FilterPredicate("buildTypeId", FilterOperator.EQUAL, buildTypeId);
        final Query query = new Query(TEST_REPORT).setFilter(buildTypeFilter).addSort("buildId", DESCENDING);

        final DatastoreService datastoreService = reports.getDatastoreService();
        final PreparedQuery preparedQuery = datastoreService.prepare(query);
        final List<Entity> entities = preparedQuery.asList(FetchOptions.Builder.withLimit(limit.or(DEFAULT_FETCH_LIMIT)));

        results = new ArrayList<>();
        for (Entity oneEntity : entities) {
            final TestReport report = from(oneEntity);
            results.add(report);
        }

        memcacheService.put(buildTypeId, results);
    }
    return results;
}

@Test
public void testCursor() 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);
    QueryResultIterator<Entity> iter = preparedQuery.asQueryResultIterator();
    Assert.assertNotNull(iter.next());
    Cursor cursor = iter.getCursor();

    iter = service.prepare(query).asQueryResultIterator(FetchOptions.Builder.withStartCursor(cursor));
    Assert.assertFalse(iter.hasNext());
}

@Test
public void testIndexListFromIterator() throws Exception {
    Entity parent = createTestEntityWithUniqueMethodNameKey("Person", "testKeysOnly");
    Key key = parent.getKey();

    Entity tom = createEntity("Person", key)
        .withProperty("name", "Tom")
        .withProperty("surname", "Foe")
        .store();

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

    PreparedQuery preparedQuery = service.prepare(query);
    QueryResultIterator<Entity> iter = preparedQuery.asQueryResultIterator();
    List<Index> indexes = iter.getIndexList();
    if (indexes != null) {
        // TODO -- something useful
        System.out.println("indexes = " + indexes);
    }
}

@Test
public void testIndexListFromList() throws Exception {
    Entity parent = createTestEntityWithUniqueMethodNameKey("Person", "testKeysOnly");
    Key key = parent.getKey();

    Entity joe = createEntity("Person", key)
        .withProperty("name", "Joe")
        .withProperty("surname", "Moe")
        .store();

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

    PreparedQuery preparedQuery = service.prepare(query);
    QueryResultList<Entity> list = preparedQuery.asQueryResultList(FetchOptions.Builder.withDefaults());
    List<Index> indexes = list.getIndexList();
    if (indexes != null) {
        // TODO -- something useful
        System.out.println("indexes = " + indexes);
    }
}

private void assertRollbackSucceedsWhenResultFetchedWith(ResultFetcher resultFetcher) throws EntityNotFoundException {
    String methodName = "assertRollbackSucceedsWhenResultFetchedWith";
    Entity entity = createTestEntityWithUniqueMethodNameKey(TRANSACTION_TEST_ENTITY, methodName);
    Key parentKey = entity.getKey();
    entity.setProperty("name", "original");
    Key key = service.put(entity);
    try {
        Transaction tx = service.beginTransaction();
        PreparedQuery preparedQuery = service.prepare(new Query(TRANSACTION_TEST_ENTITY).setAncestor(parentKey));
        Entity entity2 = resultFetcher.fetchResult(preparedQuery);
        entity2.setProperty("name", "modified");
        service.put(tx, entity2);
        tx.rollback();

        Entity entity3 = service.get(key);
        assertEquals("original", entity3.getProperty("name"));
    } finally {
        service.delete(entity.getKey());
    }
}

@Test
public void testFilterByEntityKey() {
    Entity parentEntity = createTestEntityWithUniqueMethodNameKey(TEST_ENTITY_KIND, "testFilterByEntityKey");
    Key parentKey = parentEntity.getKey();

    Key fooKey = KeyFactory.createKey(parentKey, "foo", 1);
    Entity fooEntity = new Entity(fooKey);
    service.put(fooEntity);

    Query query = new Query("foo")
        .setAncestor(parentKey)
        .setFilter(new Query.FilterPredicate(Entity.KEY_RESERVED_PROPERTY, EQUAL, fooKey));

    PreparedQuery preparedQuery = service.prepare(query);
    List<Entity> results = preparedQuery.asList(FetchOptions.Builder.withDefaults());

    assertEquals(1, results.size());
    assertEquals(fooEntity, results.get(0));
}

@Test
public void testQueryConsidersCurrentNamespaceWhenCreatedNotWhenPreparedOrExecuted() {
    deleteNsKinds("one", "foo");
    deleteNsKinds("two", "foo");
    sync();

    NamespaceManager.set("one");
    Entity fooOne = new Entity("foo");
    service.put(fooOne);

    NamespaceManager.set("two");
    Entity fooTwo = new Entity("foo");
    service.put(fooTwo);
    sync();

    Query query = new Query("foo").setAncestor(fooTwo.getKey()); // query created in namespace "two"

    NamespaceManager.set("one");
    PreparedQuery preparedQuery = service.prepare(query);
    assertEquals(fooTwo, preparedQuery.asSingleEntity());

    service.delete(fooOne.getKey());
    service.delete(fooTwo.getKey());
}

@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"));
}

@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));
}

@Test
public void testQueryWithoutAnyConstraints() throws Exception {
    Key parentKey = createQueryBasicsTestParent("testQueryWithoutAnyConstraints");

    Entity person = new Entity("Person", parentKey);
    service.put(person);

    Entity address = new Entity("Address", parentKey);
    service.put(address);

    PreparedQuery preparedQuery = service.prepare(new Query().setAncestor(parentKey));
    assertTrue(preparedQuery.countEntities(withDefaults()) >= 2);

    List<Entity> results = preparedQuery.asList(withDefaults());
    assertTrue(results.containsAll(Arrays.asList(person, address)));
}

@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
    }
}

@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);
    }
}

private static <T extends TempData> List<T> getAllTempData(Class<T> type, boolean unreadOnly) {
    try {
        DatastoreService ds = DatastoreServiceFactory.getDatastoreService();
        String kind = getKind(type);
        Query query = new Query(kind);
        if (unreadOnly) {
            query.setFilter(new Query.FilterPredicate(TEMP_DATA_READ_PROPERTY, Query.FilterOperator.EQUAL, false));
        } else {
            query.addSort("timestamp", Query.SortDirection.ASCENDING);
        }
        PreparedQuery pq = ds.prepare(query);
        Iterator<Entity> iter = pq.asIterator();
        List<T> result = new ArrayList<>();
        while (iter.hasNext()) {
            Entity entity = iter.next();
            T data = readTempData(type, entity, ds);
            result.add(data);
        }
        return result;
    } catch (Exception e) {
        throw new IllegalStateException(e);
    }
}

public static <T extends TempData> T getLastTempData(Class<T> type) {
    try {
        DatastoreService ds = DatastoreServiceFactory.getDatastoreService();
        String kind = getKind(type);
        PreparedQuery pq = ds.prepare(new Query(kind).addSort("timestamp", Query.SortDirection.DESCENDING));
        Iterator<Entity> iter = pq.asIterator();
        if (iter.hasNext()) {
            Entity entity = iter.next();
            return readTempData(type, entity, ds);
        } else {
            return null;
        }
    } catch (Exception e) {
        throw new IllegalStateException(e);
    }
}

private static Entity findDeviceByRegId(String regId) {
  Query query = new Query(DEVICE_TYPE)
      .addFilter(DEVICE_REG_ID_PROPERTY, FilterOperator.EQUAL, regId);
  PreparedQuery preparedQuery = datastore.prepare(query);
  List<Entity> entities = preparedQuery.asList(DEFAULT_FETCH_OPTIONS);
  Entity entity = null;
  if (!entities.isEmpty()) {
    entity = entities.get(0);
  }
  int size = entities.size();
  if (size > 0) {
    logger.severe(
        "Found " + size + " entities for regId " + regId + ": " + entities);
  }
  return entity;
}

/**
 * Gets a not null list of device entities by device id.
 *
 * @param deviceId the id of the device.
 */
protected List<DeviceEntity> getByDeviceId(String deviceId) {
  List<DeviceEntity> result = new ArrayList<DeviceEntity>();

  Filter deviceIdFilter =
      new FilterPredicate(DeviceEntity.DEVICEID_PROPERTY, FilterOperator.EQUAL, deviceId);

  Query query = new Query(DeviceEntity.KIND).setFilter(deviceIdFilter);
  PreparedQuery preparedQuery = dataStore.prepare(query);

  for (Entity entity : preparedQuery.asIterable()) {
    result.add(new DeviceEntity(entity));
  }

  return result;
}

/**
 * Gets all GamePlay entities for a given game.
 *
 */
private List<GamePlayEntity> getGamePlayEntities(long gameId) {
  List<GamePlayEntity> gamePlays = new ArrayList<GamePlayEntity>();

  // All GamePlay entities for a given game belong to the same entity group rooted at the game
  // entity.
  Key ancestorKey = KeyFactory.createKey(GameEntity.KIND, gameId);
  Query query = new Query(GamePlayEntity.KIND).setAncestor(ancestorKey);
  PreparedQuery preparedQuery = dataStore.prepare(query);

  for (Entity gamePlayEntity : preparedQuery.asIterable()) {
    gamePlays.add(new GamePlayEntity(gamePlayEntity));
  }

  return gamePlays;
}

/**
 * Gets a list of players that a given user can play with. This implementation simply returns the
 * list of all players other than the current user.
 *
 * @param user user making the request.
 */
public List<Player> getPlayers(User user) {
  List<Player> results = new ArrayList<Player>();

  Filter activePlayersFilter =
      new FilterPredicate(PlayerEntity.ACTIVE_PROPERTY, FilterOperator.EQUAL, true);
  Query query = new Query(PlayerEntity.KIND).setFilter(activePlayersFilter);
  PreparedQuery preparedQuery = dataStore.prepare(query);

  for (Entity entity : preparedQuery.asIterable()) {
    PlayerEntity playerEntity = new PlayerEntity(entity);
    if (!playerEntity.getEmail().equalsIgnoreCase(user.getEmail())) {
      results.add(new Player(playerEntity.getId(), playerEntity.getNickname()));
    }
  }

  return results;
}

/**
 * Returns the device object with the given registration ID.
 */
private static Entity findDeviceByRegId(String regId) {
    Query query = new Query(DEVICE_TYPE)
            .addFilter(DEVICE_REG_ID_PROPERTY, FilterOperator.EQUAL, regId);
    PreparedQuery preparedQuery = ds.prepare(query);
    List<Entity> entities = preparedQuery.asList(DEFAULT_FETCH_OPTIONS);
    Entity entity = null;
    if (!entities.isEmpty()) {
        entity = entities.get(0);
    }
    int size = entities.size();
    if (size > 0) {
        logger.severe(
                "Found " + size + " entities for regId " + regId + ": " + entities);
    }
    return entity;
}

public List<ShortTextDataStore> getShortTexts() {
    Filter filter = new FilterPredicate("user",
            FilterOperator.EQUAL,
            UserServiceFactory.getUserService()
                    .getCurrentUser().getNickname());
    Query query = getQuery().setFilter(filter)
            .addSort("date", SortDirection.DESCENDING);
    PreparedQuery pq = getPreparedQuery(query);
    List<ShortTextDataStore> data = new ArrayList<>();
    for (Entity textEntity: pq.asIterable()) {
        data.add(new ShortTextDataStore(textEntity));
    }
    return data;
}