For your information I ended up choosing Objectify. I picked that
because...
* of its very informative, yet short and elegant, documentation. In
fact, it is a far more precise and explanatory description of
datastore than in Google's own GAE documentation;
* the simple, yet powerful API. I
Hi
I really can't decide which datastore abstraction to use for my app.
Any help deciding, would be much appreciated!
The app is build using GWT and there is a lot of one-to-many relations
(so I would value if all children could be automatically deleted if
the parent is deleted).
So... Which
@Nick:
That makes sense. However, I think the footnote text should be
modified - it is really hard to tell the meaning of it. For instance,
It uses a multiplication (x) between two for every...-phrases.
That doesn't type check, but seems to be an attempt to denote the
*cardinality* of the
In the section Quotas and Limits in
http://code.google.com/appengine/docs/java/datastore/overview.html
there is a table stating
»maximum number of values in an index for an entity (1): 1,000«
where (1) is the following footnote:
»An entity uses one value in an index for every column × every
Nice points. I actually think approach 2) will suffice. Thanks alot!
--
You received this message because you are subscribed to the Google Groups
Google App Engine group.
To post to this group, send email to google-appeng...@googlegroups.com.
To unsubscribe from this group, send email to
I know that the app engine servers are synchronized with NTP so that
their clocks should be almost perfectly synchronized. Should. But can
I rely on that? Are there any mechanisms that decouples a node if its
clock gets e.g. more than N seconds out of sync the rest (or some
master node)? If so,
I try to figure out how easy it is to ruin/break the data in app
engine's datastore by accident. Assume that a class, say MyClass, has
a number of persistent members, e.g.
...
int a
int b
int c
...
and assume a number of MyClass objects have been stored in app
engine's persistent
Thanks a lot for the very elaborate answer! Actually I thought that
JDO was *the* way to access the datastore... Are there some comparison
of the access methods somewhere?
I I'll try to post my questions to the appengine-java list also, as
you suggested.
--
You received this message because you
Thanks. But using memcache would give me a somewhat fragile counter
as it's memory-only. However, I stumbled upon Jeff Scudder's
implementation of a sharded counter, which is exactly what I'm looking
for. But... Shouldn't the code that 1) fetches a shard, and 2)
increases it, be encapsulated in a
