コード例 #1
0
  /** Create a PreparedQuery that fetches keys only, relevant to our current state. */
  private PreparedQuery prepareKeysOnly() {
    // Can't modify the query, we might need to use it again
    com.google.appengine.api.datastore.Query cloned = this.cloneRawQuery(this.actual);
    cloned.setKeysOnly();

    return this.ofy.getDatastore().prepare(this.ofy.getTxn(), cloned);
  }
コード例 #2
0
ファイル: CachingService.java プロジェクト: hanzojr/sc2gears
  /**
   * Returns the Account key associated with the specified authorization key.
   *
   * @param pm reference to the persistence manager
   * @param authorizationKey authorization key to return the account key for
   * @return the Account key associated with the specified authorization key; or <code>null</code>
   *     if the authorization key is invalid
   */
  public static Key getAccountKeyByAuthKey(
      final PersistenceManager pm, final String authorizationKey) {
    final String memcacheKey = CACHE_KEY_AUTH_KEY_ACCOUNT_KEY_PREFIX + authorizationKey;
    final String accountKeyString = (String) memcacheService.get(memcacheKey);
    if (accountKeyString != null) return KeyFactory.stringToKey(accountKeyString);

    final Query q = new Query(Account.class.getSimpleName());
    q.setFilter(new FilterPredicate("authorizationKey", FilterOperator.EQUAL, authorizationKey));
    q.setKeysOnly();
    final List<Entity> entityList =
        DatastoreServiceFactory.getDatastoreService()
            .prepare(q)
            .asList(FetchOptions.Builder.withDefaults());
    if (entityList.isEmpty()) return null;

    final Key accountKey = entityList.get(0).getKey();
    try {
      memcacheService.put(memcacheKey, KeyFactory.keyToString(accountKey));
    } catch (final MemcacheServiceException mse) {
      LOGGER.log(Level.WARNING, "Failed to put key to memcache: " + memcacheKey, mse);
      // Ignore memcache errors, do not prevent serving user request
    }

    return accountKey;
  }
コード例 #3
0
 public List<Entry<String, Entity>> scan(
     String start, String end, int max, SortDirection direction, boolean keysOnly) {
   Preconditions.checkNotNull(start);
   Preconditions.checkNotNull(end);
   Preconditions.checkArgument(max > -1);
   if (max == 0) {
     return Lists.newArrayList();
   }
   Query query = new Query(kind);
   query.addFilter(
       "__key__", FilterOperator.GREATER_THAN_OR_EQUAL, KeyFactory.createKey(kind, escape(start)));
   query.addFilter("__key__", FilterOperator.LESS_THAN, KeyFactory.createKey(kind, escape(end)));
   query.addSort("__key__", direction);
   if (keysOnly) {
     query.setKeysOnly();
   }
   PreparedQuery preparedQuery = service.prepare(query);
   List<Entry<String, Entity>> result = Lists.newArrayList();
   for (Entity entity : preparedQuery.asIterable(FetchOptions.Builder.withLimit(max))) {
     if (keysOnly) {
       result.add(Maps.immutableEntry(unescape(entity.getKey().getName()), (Entity) null));
     } else {
       result.add(Maps.immutableEntry(unescape(entity.getKey().getName()), entity));
     }
   }
   return result;
 }
コード例 #4
0
 @Override
 public Iterator<String> getAllEntityKeys(Class<?> entityClass, String lastKey) {
   DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
   com.google.appengine.api.datastore.Query q =
       new com.google.appengine.api.datastore.Query(entityClass.getName());
   q.setKeysOnly();
   if (lastKey != null) {
     q.addFilter("name", FilterOperator.GREATER_THAN, lastKey);
   }
   PreparedQuery pq = datastore.prepare(q);
   FetchOptions fetchOptions = FetchOptions.Builder.withOffset(0);
   return new ExtractingKeyIterable(pq.asIterator(fetchOptions));
 }
コード例 #5
0
  /**
   * Counts the rows of the specified table
   *
   * @param searchIn the kind of entity (table) to search in
   * @param parent search for all entities with this parent
   * @param filters all properties to search for
   * @return number of rows
   */
  public static int count(String searchIn, Key parent, FilterWrapper... filters) {
    Query query = new Query(searchIn);
    query.setKeysOnly();

    if (parent != null) {
      query.setAncestor(parent);
    }

    setFilterProperties(query, filters);

    PreparedQuery preparedQuery = mDatastore.prepare(query);
    return preparedQuery.countEntities(FetchOptions.Builder.withDefaults());
  }
コード例 #6
0
  /** Make a new Query object that is exactly like the old. Too bad Query isn't Cloneable. */
  protected com.google.appengine.api.datastore.Query cloneRawQuery(
      com.google.appengine.api.datastore.Query orig) {
    com.google.appengine.api.datastore.Query copy =
        new com.google.appengine.api.datastore.Query(orig.getKind(), orig.getAncestor());

    for (FilterPredicate filter : orig.getFilterPredicates())
      copy.addFilter(filter.getPropertyName(), filter.getOperator(), filter.getValue());

    for (SortPredicate sort : orig.getSortPredicates())
      copy.addSort(sort.getPropertyName(), sort.getDirection());

    // This should be impossible but who knows what might happen in the future
    if (orig.isKeysOnly()) copy.setKeysOnly();

    return copy;
  }
コード例 #7
0
  /**
   * Searches for an existing entity
   *
   * @param searchIn what kind of entity to search in
   * @param parent the parent of the entity to find, set to null to skip
   * @param onlyKeys will only retrieve keys for the found entity
   * @param filters property name and values to search for
   * @return found entity, null if none or more than 1 was found
   */
  private static Entity getSingleEntity(
      String searchIn, Key parent, boolean onlyKeys, FilterWrapper... filters) {
    Query query = new Query(searchIn);

    if (onlyKeys) {
      query.setKeysOnly();
    }

    setFilterProperties(query, filters);

    if (parent != null) {
      query.setAncestor(parent);
    }

    try {
      return mDatastore.prepare(query).asSingleEntity();
    } catch (TooManyResultsException e) {
      // Does nothing
    }
    return null;
  }
コード例 #8
0
  /**
   * Get all entities (with only keys) with the specified parent and properties
   *
   * @param searchIn what kind of entity (table) to search in
   * @param parent search for all entities with this parent
   * @param filters all properties to search for
   * @return an array list of all found entities with the specified parent
   */
  public static List<Key> getKeys(String searchIn, Key parent, FilterWrapper... filters) {
    Query query = new Query(searchIn);

    query.setKeysOnly();

    // Parent
    if (parent != null) {
      query.setAncestor(parent);
    }

    // Search by properties
    setFilterProperties(query, filters);

    PreparedQuery preparedQuery = mDatastore.prepare(query);

    ArrayList<Key> keys = new ArrayList<>();
    for (Entity entity : preparedQuery.asIterable()) {
      keys.add(entity.getKey());
    }

    return keys;
  }