> Question 1: When you define a chain of ownership between an entity and
> child entity, is the entity group defined at the root entity level or
> the "kind" level.  For example of you have "kind" called "Book" and a
> child kind "Chapter" defined.  If you have a "Book" entity named
> "Intro to AppEngine", and it has three child entitles, "Ch1", "Ch2",
> and "Ch3", is there 1 entityGroup containing "Intro to AppEngine" with
> its 3 child entities or is the entityGroup at the 'book" level where
> it contains all entities of kind "book" along with all of the child
> entities?

The grouping is at the level of entities, not models(hence the name).
In your example the Book entities will be stored in various Datastore
nodes, only "Intro to AppEngine" with its 3 child entities "Ch1/Ch2/
Ch3" are guaranteed to be grouped together in the same Datastore node.

> Question 2: Assuming you have an entityGroup with a chain of ownership
> of 3 different kinds. Does the write throughput vary based on whether
> we are using transactions or not. When Max Ross at Google I/O
> described write throughput on an entityGroup being from anywhere from
> 1 to 10 writes per second, were these numbers based on writes using
> appengine datastore transaction management or were these numbers based
> on writes without transactions.

I assume it does vary; transactions are inherently slower and can
fail.
I think the threshold is that you will get into trouble if you use
transactions on entity groups that get more than 1 write per second.

> Question 3: The second question involves queries against data in an
> entity group. In the relational database world, some databases allow
> you to partition data within a table. The advantage of this, if done
> properly, is that queries against those tables result in scans against
> specific partitions (given parameters in where clause) as oppossed to
> full table scans across all data in the table. The query can perform
> much better with these partitions in place.  With respect to the
> AppEngine datastore, do we get a performance boost with queries whose
> entities all reside within a single entity group?

The only difference for queries is that the entities are stored at the
same location. As the entities matching a query are fetched in
parallel, this will not result in a performance boost, and might
actually be slower.

--

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 
google-appengine+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/google-appengine?hl=en.


Reply via email to