Robert,
In our code, we use some thin wrapper classes to create and execute
queries, which obfuscates the execution of the datastore API calls a
bit. I have created a code fragment that illustrates how you execute
an IN query using the Java LL API:
DatastoreServiceConfig config =
DatastoreServiceConfig.Builder.withDefaults();
DatastoreService datastoreService =
DatastoreServiceFactory.getDatastoreService(config);
List<Entity> entityList = new ArrayList<Entity>();
// some code here to fill the entityList with something useful
List<Key> keyList = new ArrayList<Key>();
for (Entity entity : entityList) {
keyList.add(entity.getKey());
}
Query query = new Query("MyEntityKind");
query.addFilter("MyPropertyName", Query.FilterOperator.IN,
keyList);
Iterable<Entity> result =
datastoreService.prepare(query).asIterable();
As in my test the keyList had 36 entries, I must assume that there's
no such limit in the Java LL API. My test was using our GUI, but I'm
inclined to create a new test case that creates test data
programmatically.
Unfortunately we haven't enabled Appstats currently as we're only
going to analyze performance once we have the most important features
running. But I acknowledge that it's creating nice (and useful)
diagrams :-D. It illustrates well what you're saying. Interestingly,
the queries are executed sequentially, although one could imagine them
to be executed in parallel. I may enable Appstats soon to see how this
looks in Java. I'll keep the list posted as soon as we get any new
results.
Cheers, Remigius.
--
You received this message because you are subscribed to the Google Groups
"Google App Engine" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to
[email protected].
For more options, visit this group at
http://groups.google.com/group/google-appengine?hl=en.
