public class LoaderImpl<L extends Loader> extends SimpleQueryImpl<T> implements Loader, Cloneable
Implementation of the Loader interface. This is also suitable for subclassing; you can return your own subclass by overriding ObjectifyImpl.load().
| Modifier and Type | Field and Description |
|---|---|
protected LoadArrangement |
loadArrangement |
protected ObjectifyImpl<?> |
ofy |
loader| Constructor and Description |
|---|
LoaderImpl(ObjectifyImpl<?> ofy) |
| Modifier and Type | Method and Description |
|---|---|
protected LoaderImpl<L> |
clone() |
int |
count()
Count the total number of values in the result.
|
<E> Map<Key<E>,E> |
entities(E... entities)
A convenient substitute for entities(Iterable)
|
<E> Map<Key<E>,E> |
entities(Iterable<E> values)
Load multiple entities from the datastore in a batch.
|
<E> LoadResult<E> |
entity(E entity)
Load a single entity which has the same id/parent as the specified entity.
|
LoadResult<T> |
first()
Gets the first entity in the result set.
|
<T> T |
fromEntity(com.google.appengine.api.datastore.Entity entity)
Convert a native datastore Entity into a typed POJO.
|
Set<Class<?>> |
getLoadGroups() |
Objectify |
getObjectify() |
ObjectifyImpl<?> |
getObjectifyImpl() |
L |
group(Class<?>... groups)
Enables one or more fetch groups.
|
com.google.appengine.api.datastore.QueryResultIterable<T> |
iterable()
Starts an asynchronous query which will return entities.
|
com.google.appengine.api.datastore.QueryResultIterator<T> |
iterator() |
<E> LoadResult<E> |
key(Key<E> key)
Load a single entity by key.
|
<E> Map<Key<E>,E> |
keys(Iterable<Key<E>> keys)
Load multiple entities by key from the datastore in a batch.
|
<E> Map<Key<E>,E> |
keys(Key<? extends E>... keys)
A convenient substitute for keys(Iterable)
|
List<T> |
list()
Execute the query and get the results as a List.
|
<E> E |
now(Key<E> key)
Get the entity for a key immediately.
|
<E> LoadResult<E> |
ref(Ref<E> ref)
Load a single entity ref.
|
<E> Map<Key<E>,E> |
refs(Iterable<Ref<E>> refs)
Load multiple refs in a batch operation.
|
<E> Map<Key<E>,E> |
refs(Ref<? extends E>... refs)
A convenient substitute for refs(Iterable)
|
<E> LoadType<E> |
type(Class<E> type)
Restricts the find operation to entities of a particular type.
|
<E> LoadResult<E> |
value(Object key)
Load a single entity given any of a variety of acceptable key-like structures.
|
<E> Map<Key<E>,E> |
values(Iterable<?> values)
Fetch multiple entities from the datastore in a batch.
|
<E> Map<Key<E>,E> |
values(Object... values)
A convenient substitute for values(Iterable)
|
ancestor, chunk, chunkAll, distinct, endAt, filterKey, filterKey, hybrid, keys, limit, offset, orderKey, reverse, startAtequals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitancestor, chunk, chunkAll, count, distinct, endAt, filterKey, filterKey, hybrid, keys, limit, offset, orderKey, reverse, startAt, toStringfirst, iterable, listprotected ObjectifyImpl<?> ofy
protected LoadArrangement loadArrangement
public LoaderImpl(ObjectifyImpl<?> ofy)
public L group(Class<?>... groups)
LoaderEnables one or more fetch groups. This will cause any entity fields (or Ref fields) which
are annotated with @Load(XYZGroup.class) to be fetched along with your entities. The class
definition can be any arbitrary class, but inheritance is respected - if you have a
class Foo extends Bar, then group(Foo.class) will cause loading of all @Load(Bar.class)
properties.
Calling this method multiple times is the same as passing all the groups into one call.
public <E> LoadType<E> type(Class<E> type)
LoaderRestricts the find operation to entities of a particular type. The type may be the base of a polymorphic class hierarchy. This is optional.
public <E> LoadResult<E> ref(Ref<E> ref)
LoaderLoad a single entity ref. This starts an asynchronous fetch operation.
Since fetching is asynchronous,
datastore exceptions
(DatastoreTimeoutException, ConcurrentModificationException, DatastoreFailureException)
can be thrown from Result operations.
public <E> Map<Key<E>,E> refs(Ref<? extends E>... refs)
LoaderA convenient substitute for refs(Iterable)
public <E> Map<Key<E>,E> refs(Iterable<Ref<E>> refs)
LoaderLoad multiple refs in a batch operation. This starts an asynchronous fetch.
Since fetching is asynchronous,
datastore exceptions
(DatastoreTimeoutException, ConcurrentModificationException, DatastoreFailureException)
can be thrown from the map operations.
public <E> LoadResult<E> key(Key<E> key)
LoaderLoad a single entity by key. This starts an asynchronous fetch.
Since fetching is asynchronous,
datastore exceptions
(DatastoreTimeoutException, ConcurrentModificationException, DatastoreFailureException)
can be thrown from Result operations.
public <E> LoadResult<E> entity(E entity)
LoaderLoad a single entity which has the same id/parent as the specified entity. This starts an asynchronous fetch.
This is a shortcut for key(Key.create(entity)).
Since fetching is asynchronous,
datastore exceptions
(DatastoreTimeoutException, ConcurrentModificationException, DatastoreFailureException)
may be thrown from Result operations.
public <E> LoadResult<E> value(Object key)
LoaderLoad a single entity given any of a variety of acceptable key-like structures. This starts an asynchronous fetch.
The parameter can be any key-like structure, including:
Since fetching is asynchronous,
datastore exceptions
(DatastoreTimeoutException, ConcurrentModificationException, DatastoreFailureException)
may be thrown from Result operations.
public <E> Map<Key<E>,E> keys(Key<? extends E>... keys)
LoaderA convenient substitute for keys(Iterable)
public <E> Map<Key<E>,E> keys(Iterable<Key<E>> keys)
LoaderLoad multiple entities by key from the datastore in a batch. This starts an asynchronous fetch.
Since fetching is asynchronous,
datastore exceptions
(DatastoreTimeoutException, ConcurrentModificationException, DatastoreFailureException)
will be thrown when the Map is accessed.
public <E> Map<Key<E>,E> entities(E... entities)
LoaderA convenient substitute for entities(Iterable)
public <E> Map<Key<E>,E> entities(Iterable<E> values)
LoaderLoad multiple entities from the datastore in a batch. This starts an asynchronous fetch.
Since fetching is asynchronous,
datastore exceptions
(DatastoreTimeoutException, ConcurrentModificationException, DatastoreFailureException)
may be thrown when the Map is accessed.
public <E> Map<Key<E>,E> values(Object... values)
LoaderA convenient substitute for values(Iterable)
public <E> Map<Key<E>,E> values(Iterable<?> values)
LoaderFetch multiple entities from the datastore in a batch. This starts an asynchronous fetch.
The parameters can be any mix of key-like structures, including:
Since fetching is asynchronous,
datastore exceptions
(DatastoreTimeoutException, ConcurrentModificationException, DatastoreFailureException)
may be thrown when the Map is accessed.
public Objectify getObjectify()
getObjectify in interface Loaderpublic Set<Class<?>> getLoadGroups()
getLoadGroups in interface Loaderpublic ObjectifyImpl<?> getObjectifyImpl()
public <E> E now(Key<E> key)
Loaderpublic <T> T fromEntity(com.google.appengine.api.datastore.Entity entity)
LoaderfromEntity in interface Loaderentity - is a native datastore entity which has an appropriate kind registered in the ObjectifyFactory.protected LoaderImpl<L> clone()
public LoadResult<T> first()
QueryExecutepublic com.google.appengine.api.datastore.QueryResultIterator<T> iterator()
public com.google.appengine.api.datastore.QueryResultIterable<T> iterable()
QueryExecuteStarts an asynchronous query which will return entities.
Note that since the Query
public int count()
SimpleQueryCount 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.
public List<T> list()
QueryExecuteExecute 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.
Copyright © 2014. All rights reserved.