Interface Query<T>
- All Superinterfaces:
Iterable<T>
,QueryExecute<T>
,QueryResultIterable<T>
,SimpleQuery<T>
- All Known Subinterfaces:
LoadType<T>
- All Known Implementing Classes:
QueryImpl
- Author:
- Jeff Schnitzer invalid input: '<'[email protected]>
-
Method Summary
Modifier and TypeMethodDescriptionRestricts result set only to objects which have the given ancestor somewhere in the chain.chunk
(int value) Sets the internal chunking and prefetching strategy within the low-level API.chunkAll()
Sets the internal chunking and prefetching strategy within the low-level API to attempt to get all results at once.distinct
(boolean value) Determines whether this is a SELECT DISTINCT query.endAt
(com.google.cloud.datastore.Cursor value) Ends query results at the specified Cursor.filter
(com.google.cloud.datastore.StructuredQuery.Filter filter) Create a filter based on the raw low-level Filter.Create an arbitrarily complex filter.Create a filter based on the specified condition and value, using the same syntax as the GAE/Python query class.An alias forfilterKey("=", value)
Create a filter on the key of an entity.hybrid
(boolean force) This method forces Objectify to (or not to) hybridize the query into a keys-only fetch plus batch get.limit
(int value) Limit the fetched result set to a certain number of values.offset
(int value) Starts the query results at a particular zero-based offset.Sorts based on a property.orderKey
(boolean descending) Shorthand fororder("__key__")
ororder("-__key__")
Converts this query into a projection query.startAt
(com.google.cloud.datastore.Cursor value) Starts query results at the specified Cursor.Methods inherited from interface java.lang.Iterable
forEach, spliterator
Methods inherited from interface com.googlecode.objectify.cmd.QueryExecute
first, iterable, list, stream
Methods inherited from interface com.googlecode.objectify.cmd.QueryResultIterable
iterator
Methods inherited from interface com.googlecode.objectify.cmd.SimpleQuery
count, keys, toString
-
Method Details
-
filter
Create a filter based on the specified condition and value, using the same syntax as the GAE/Python query class. Examples:
filter("age >=", age)
filter("age =", age)
filter("age", age)
(if no operator, = is assumed)filter("age !=", age)
filter("age IN", Arrays.asList(25, 35, 45)
filter("age !IN", Arrays.asList(25, 35, 45)
The space between the property name and the operator is required. Filtering a condition of
"age>="
will perform an equality test on an entity property exactly named "age>=". You can't create properties like this with Objectify, but you can with the Low-Level API.Multiple calls to filter() will produce an AND (intersection) query.
==
is an alias of=
,<>
is an alias of!=
.See the Google documentation for indexes for an explanation of what you can and cannot filter for.
You can not filter on @Id or @Parent properties. Use
filterKey()
orancestor()
instead. -
filter
Create a filter based on the raw low-level Filter. This is a very low-level operation; the values in the Filter are not translated in any way. For example, this only understands native datastore
Key
objects and not ObjectifyKey<?>
objects.See the Google documentation for indexes for an explanation of what you can and cannot filter for.
You can not filter on @Id or @Parent properties. Use
filterKey()
orancestor()
instead. -
filter
Create an arbitrarily complex filter. This method is preferred to the low-level Filter method because it has better ergonomics and automatically handles objects like Objectify
Key<?>
andRef<?>
.Construct Filter objects using static methods on the Filter class.
Note that like the other filter methods, you can not filter on @Id or @Parent properties. You can filter by
__key__
however. -
filterKey
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 Keyinvalid input: '<'?>, 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.
All command objects are immutable; this method returns a new object instead of modifying the current command object.
- Specified by:
filterKey
in interfaceSimpleQuery<T>
- Returns:
- a new immutable query object that applies the filter
-
filterKey
Description copied from interface:SimpleQuery
An alias forfilterKey("=", value)
All command objects are immutable; this method returns a new object instead of modifying the current command object.
- Specified by:
filterKey
in interfaceSimpleQuery<T>
- Returns:
- a new immutable query object that applies the filter
-
order
Sorts based on a property. Examples:
order("age")
order("-age")
(descending sort)
You can not sort on @Id or @Parent properties. Sort by __key__ or -__key__ instead.
-
orderKey
Shorthand fororder("__key__")
ororder("-__key__")
- Specified by:
orderKey
in interfaceSimpleQuery<T>
- Parameters:
descending
- if true, specifies a descending (aka reverse) sort- Returns:
- a new immutable query object that applies the sort order
-
ancestor
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).All command objects are immutable; this method returns a new object instead of modifying the current command object.
- Specified by:
ancestor
in interfaceSimpleQuery<T>
- Parameters:
keyOrEntity
- can be a Key, a Key, or an Objectify entity object. - Returns:
- a new immutable query object that applies the ancestor filter
-
limit
Description copied from interface:SimpleQuery
Limit the fetched result set to a certain number of values.All command objects are immutable; this method returns a new object instead of modifying the current command object.
- Specified by:
limit
in interfaceSimpleQuery<T>
- Parameters:
value
- must be >= 0. A value of 0 indicates no limit.- Returns:
- a new immutable query object that applies the limit
-
offset
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.All command objects are immutable; this method returns a new object instead of modifying the current command object.
- Specified by:
offset
in interfaceSimpleQuery<T>
- Parameters:
value
- must be >= 0- Returns:
- a new immutable query object that applies the offset
-
startAt
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.All command objects are immutable; this method returns a new object instead of modifying the current command object.
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 interfaceSimpleQuery<T>
- Returns:
- a new immutable query object that applies the cursor
-
endAt
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.All command objects are immutable; this method returns a new object instead of modifying the current command object.
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 interfaceSimpleQuery<T>
- Returns:
- a new immutable query object that applies the cursor
-
chunk
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.All command objects are immutable; this method returns a new object instead of modifying the current command object.
- Specified by:
chunk
in interfaceSimpleQuery<T>
- Parameters:
value
- must be >= 0- Returns:
- a new immutable query object that applies the chunk size
-
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.
All command objects are immutable; this method returns a new object instead of modifying the current command object.
Same as chunk(Integer.MAX_VALUE).
- Specified by:
chunkAll
in interfaceSimpleQuery<T>
- Returns:
- a new immutable query object that applies the chunk size
-
hybrid
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, 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.
Note that in hybrid queries, the chunk size defines the batch size.
All command objects are immutable; this method returns a new object instead of modifying the current command object.
- Specified by:
hybrid
in interfaceSimpleQuery<T>
- Returns:
- a new immutable query object that forces hybridization on or off
-
project
Description copied from interface:SimpleQuery
Converts this query into a projection query. Projection queries allow values to be selected directly out of an index rather than loading the whole entity. While this allows data to be fetched quickly and cheaply, it is limited to selecting data that exists in an index.
Entities returned from projection queries are NOT kept in the session cache. However, @Load annotations are processed normally.
This method can be called more than once; it will have the same effect as passing all the fields in to a single call.
- Specified by:
project
in interfaceSimpleQuery<T>
- Parameters:
fields
- is one or more field names- Returns:
- a new immutable query object that projects the specified fields
-
distinct
Description copied from interface:SimpleQuery
Determines whether this is a SELECT DISTINCT query.All command objects are immutable; this method returns a new object instead of modifying the current command object.
- Specified by:
distinct
in interfaceSimpleQuery<T>
- Returns:
- a new immutable query object that applies the distinct operator
-