SimpleQueryWrapper (Objectify App Engine 5.0 API)

java.lang.Object
- com.googlecode.objectify.util.cmd.SimpleQueryWrapper<H,T>

All Implemented Interfaces:

com.google.appengine.api.datastore.QueryResultIterable<T>, QueryExecute<T>, SimpleQuery<T>, Cloneable, Iterable<T>

Direct Known Subclasses:

QueryWrapper
```
public class SimpleQueryWrapper<H extends SimpleQueryWrapper<H,T>,T>
extends Object
implements SimpleQuery<T>, Cloneable
```
Simple wrapper/decorator for a SimpleQuery. Use it like this: class MySimpleQuery<T> extends SimpleQueryWrapper<MyQuery<T>, T>

Author:

Jeff Schnitzer

Constructor Summary

Constructors
Constructor and Description

SimpleQueryWrapper(SimpleQuery<T> base)

Constructors
Constructor and Description
`SimpleQueryWrapper(SimpleQuery<T> base)`

Method Summary

Methods
Modifier and Type	Method and Description
`H`	`ancestor(Object keyOrEntity)` Restricts result set only to objects which have the given ancestor somewhere in the chain.
`H`	`chunk(int value)` Sets the internal chunking and prefetching strategy within the low-level API.
`H`	`chunkAll()` Sets the internal chunking and prefetching strategy within the low-level API to attempt to get all results at once.
`protected H`	`clone()`
`int`	`count()` Count the total number of values in the result.
`H`	`distinct(boolean value)` Determines whether this is a SELECT DISTINCT query.
`H`	`endAt(com.google.appengine.api.datastore.Cursor value)` Ends query results at the specified Cursor.
`SimpleQuery<T>`	`filterKey(Object value)` An alias for `filterKey("=", value)`
`H`	`filterKey(String condition, Object value)` Create a filter on the key of an entity.
`LoadResult<T>`	`first()` Gets the first entity in the result set.
`H`	`hybrid(boolean force)` This method forces Objectify to (or not to) hybridize the query into a keys-only fetch plus batch get.
`com.google.appengine.api.datastore.QueryResultIterable<T>`	`iterable()` Starts an asynchronous query which will return entities.
`com.google.appengine.api.datastore.QueryResultIterator<T>`	`iterator()`
`QueryKeys<T>`	`keys()` Switches to a keys-only query.
`H`	`limit(int value)` Limit the fetched result set to a certain number of values.
`List<T>`	`list()` Execute the query and get the results as a List.
`H`	`offset(int value)` Starts the query results at a particular zero-based offset.
`H`	`reverse()` Reverse the query, as described in the GAE docs.
`H`	`startAt(com.google.appengine.api.datastore.Cursor value)` Starts query results at the specified Cursor.
`String`	`toString()` Generates a string that consistently and uniquely specifies this query.

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - SimpleQueryWrapper
```
public SimpleQueryWrapper(SimpleQuery<T> base)
```
- Method Detail
  - filterKey
```
public H filterKey(String condition,
          Object value)
```
    Description copied from interface: SimpleQuery
    Create a filter on the key of an entity. Examples:
    - filterKey(">=", key) (standard inequalities)
    - filterKey("=", key) (wouldn't you rather do a load-by-key?)
    - filterKey("", key) (if no operator, = is assumed)
    - filterKey("!=", key)
    - filterKey("in", keyList) (wouldn't you rather do a batch load-by-key?)
    The key parameter can be anything key-ish; a Key, a native datastore key, a Ref, a pojo entity, etc.
    
    See the Google documentation for indexes for an explanation of what you can and cannot filter for.
    Specified by:
    
    filterKey in interface SimpleQuery<T>
  - filterKey
```
public SimpleQuery<T> filterKey(Object value)
```
    Description copied from interface: SimpleQuery
    
    An alias for filterKey("=", value)
    
    Specified by:
    
    filterKey in interface SimpleQuery<T>
  - ancestor
```
public H ancestor(Object keyOrEntity)
```
    Description copied from interface: SimpleQuery
    
    Restricts result set only to objects which have the given ancestor somewhere in the chain. Doesn't need to be the immediate parent. The specified ancestor itself will be included in the result set (if it exists).
    
    Specified by:
    
    ancestor in interface SimpleQuery<T>
    
    Parameters:
    keyOrEntity - can be a Key, a Key, or an Objectify entity object.
  - limit
```
public H limit(int value)
```
    Description copied from interface: SimpleQuery
    
    Limit the fetched result set to a certain number of values.
    
    Specified by:
    
    limit in interface SimpleQuery<T>
    
    Parameters:
    value - must be >= 0. A value of 0 indicates no limit.
  - offset
```
public H offset(int value)
```
    Description copied from interface: SimpleQuery
    
    Starts the query results at a particular zero-based offset. This can be extraordinarily expensive because each skipped entity is billed as a "minor datastore operation". If you can, you probably want to use cursors instead.
    
    Specified by:
    
    offset in interface SimpleQuery<T>
    
    Parameters:
    value - must be >= 0
  - startAt
```
public H startAt(com.google.appengine.api.datastore.Cursor value)
```
    Description copied from interface: SimpleQuery
    
    Starts query results at the specified Cursor. You can obtain a Cursor from a QueryResultIterator by calling the getCursor() method. Note that limit() and offset() are NOT encoded within a cursor; they operate on the results of the query after a cursor is established.
    
    Specified by:
    
    startAt in interface SimpleQuery<T>
  - endAt
```
public H endAt(com.google.appengine.api.datastore.Cursor value)
```
    Description copied from interface: SimpleQuery
    
    Ends query results at the specified Cursor. You can obtain a Cursor from a QueryResultIterator by calling the getCursor() method. Note that limit() and offset() are NOT encoded within a cursor; they operate on the results of the query after a cursor is established.
    
    Specified by:
    
    endAt in interface SimpleQuery<T>
  - reverse
```
public H reverse()
```
    Description copied from interface: SimpleQuery
    
    Reverse the query, as described in the GAE docs.
    
    Specified by:
    
    reverse in interface SimpleQuery<T>
  - toString
```
public String toString()
```
    Description copied from interface: SimpleQuery
    
    Generates a string that consistently and uniquely specifies this query. There is no way to convert this string back into a query and there is no guarantee that the string will be consistent across versions of Objectify.
    
    In particular, this value is useful as a key for a simple memcache query cache.
    
    Specified by:
    
    toString in interface QueryExecute<T>
    
    Specified by:
    
    toString in interface SimpleQuery<T>
    
    Overrides:
    
    toString in class Object
  - first
```
public LoadResult<T> first()
```
    Description copied from interface: QueryExecute
    
    Gets the first entity in the result set. Obeys the offset value.
    
    Specified by:
    
    first in interface QueryExecute<T>
    
    Returns:
    an asynchronous result containing the first result. The result will hold null if the result set is empty.
  - count
```
public int count()
```
    Description copied from interface: SimpleQuery
    
    Count the total number of values in the result. limit and offset are obeyed. This is somewhat faster than fetching, but the time still grows with the number of results. The datastore actually walks through the result set and counts for you.
    
    Immediately executes the query; there is no async version of this method.
    
    WARNING: Each counted entity is billed as a "datastore minor operation". Counting large numbers of entities can quickly create massive bills.
    
    Specified by:
    
    count in interface SimpleQuery<T>
  - iterable
```
public com.google.appengine.api.datastore.QueryResultIterable<T> iterable()
```
    Description copied from interface: QueryExecute
    
    Starts an asynchronous query which will return entities.
    
    Note that since the Query itself is QueryResultIterable, you can iterate on the query object itself. However, if you want to start an async query and iterate on it later, you can use this method.
    
    Specified by:
    
    iterable in interface QueryExecute<T>
  - list
```
public List<T> list()
```
    Description copied from interface: QueryExecute
    
    Execute the query and get the results as a List. The list will be equivalent to a simple ArrayList; you can iterate through it multiple times without incurring additional datastore cost.
    
    Note that you must be careful about limit()ing the size of the list returned; you can easily exceed the practical memory limits of Appengine by querying for a very large dataset.
    
    Specified by:
    
    list in interface QueryExecute<T>
  - chunk
```
public H chunk(int value)
```
    Description copied from interface: SimpleQuery
    
    Sets the internal chunking and prefetching strategy within the low-level API. Affects performance only; the result set will be the same.
    
    Specified by:
    
    chunk in interface SimpleQuery<T>
    
    Parameters:
    value - must be >= 0
  - chunkAll
```
public H chunkAll()
```
    Description copied from interface: SimpleQuery
    
    Sets the internal chunking and prefetching strategy within the low-level API to attempt to get all results at once. Affects performance only; the result set will be the same.
    
    Same as chunk(Integer.MAX_VALUE).
    
    Specified by:
    
    chunkAll in interface SimpleQuery<T>
  - distinct
```
public H distinct(boolean value)
```
    Description copied from interface: SimpleQuery
    
    Determines whether this is a SELECT DISTINCT query.
    
    Specified by:
    
    distinct in interface SimpleQuery<T>
  - hybrid
```
public H hybrid(boolean force)
```
    Description copied from interface: SimpleQuery
    This method forces Objectify to (or not to) hybridize the query into a keys-only fetch plus batch get.
    
    If Objectify knows you are fetching an entity type that can be cached, it automatically converts queries into a "hybrid" of keys-only query followed by a batch fetch of the keys. This is cheaper (keys-only results are 1/7th the price of a full fetch) and, if the cache hits, significantly faster. However, there are some circumstances in which you may wish to force behavior one way or another:
    - Issuing a kindless query (which Objectify will not auto-hybridize) when you know a significant portion of the result set is cacheable.
    - Some exotic queries cannot be made keys-only, and produce an exception from the Low-Level API when you try to execute the query. Objectify tries to detect these cases but since the underlying implementation may change, you may need to force hybridization off in some cases.
    - Hybrid queries have a slightly different consistency model than normal queries. You may wish to force hybridization off to ensure a weakly consistent query (see below).
    For the most part, hybridization only affects the performance and cost of queries. However, it is possible for hybridization to alter the content of the result set. In the HRD, queries always have EVENTUAL consistency but get operations may have either STRONG or EVENTUAL consistency depending on the read policy (see Objectify.consistency(). The keys-only query results will always be EVENTUAL and may return data that has been deleted, but Objectify will exclude these results when the more-current batch get fails to return data. So the count of the returned data may actually be less than the limit(), even if there are plenty of actual results. hybrid(false) will prevent this behavior.
    
    Note that in hybrid queries, the chunk size defines the batch size.
    Specified by:
    
    hybrid in interface SimpleQuery<T>
  - iterator
```
public com.google.appengine.api.datastore.QueryResultIterator<T> iterator()
```
    Specified by:
    
    iterator in interface com.google.appengine.api.datastore.QueryResultIterable<T>
    
    Specified by:
    
    iterator in interface Iterable<T>
  - keys
```
public QueryKeys<T> keys()
```
    Description copied from interface: SimpleQuery
    
    Switches to a keys-only query. Keys-only responses are billed as "minor datastore operations" which are significantly cheaper (~7X) than fetching whole entities.
    
    Specified by:
    
    keys in interface SimpleQuery<T>
  - clone
```
protected H clone()
```
    Overrides:
    
    clone in class Object

Class SimpleQueryWrapper<H extends SimpleQueryWrapper<H,T>,T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SimpleQueryWrapper

Method Detail

filterKey

filterKey

ancestor

limit

offset

startAt

endAt

reverse

toString

first

count

iterable

list

chunk

chunkAll

distinct

hybrid

iterator

keys

clone