Google App Engine：更好的查询方式

Question

Say I have RootEntity , AEntity (child of RootEntity), BEntity (child of AEntity ).

class RootEntity(ndb.Model):
    rtp = ndb.StringProperty()

class AEntity(ndb.Model):
    ap = ndb.IntegerProperty()

class BEntity(ndb.Model):
    bp = ndb.StringProperty()

So in different handlers I need to get instances of BEntity with specific ancestor(instance of AEntity).

There is a my query: BEntity.query(ancestor = ndb.Key("RootEntity", 1, "AEntity", AEntity.query(ancestor = ndb.Key("RootEntity", 1)).filter(AEntity.ap == int(some_value)).get().key.integer_id()))

How I can to optimize this query? Make it better, may be less sophisticated?

Upd:

This query is a part of function with @ndb.transactional decorator.

Answer 1

You should not use Entity Groups to represent entity relationships.

Entity groups have a special purpose : to define the scope of transactions. They give you ability to update multiple entities transactionally, as long as they are a part of the same entity group (this limitation has been somewhat relaxed with the new XG transactions ). They also allow you to use queries within transactions (not available via XG transactions).

The downside of entity groups is that they have an update limitation of 1 write/second.

In your case my suggestion would be to use separate entities and make references between them. The reference should be a Key of the referenced entity as this is type-safe.

Regarding query simplicity: GAE unfortunately does not support JOINs or reference (multi-entity) queries, so you would still need to combine multiple queries together (as you do now).

Answer 2

There is a give and take with ancestor queries. They are a more verbose and messy to deal with but you get a better structure to your data and consistency in your queries.

To simplify this, if your handler knows the BEntity you want to get, just pass around the key.urlsafe() encoded key, it already has all of your ancestor information encoded.

If this is not possible, try possibly restructuring your data. Since these objects are all of the same ancestor, they belong to the same entity group, thus at most you can insert/update ~1 time per second for objects in that entity group. If you require higher throughput or do not require consistent ancestral queries, then try using ndb.KeyProperty to link entities with a reference to a parent rather than as an ancestor. Then you'd only need to get a single parent to query on rather than the parent and the parent's parent.

You should also try and use IDs whenever possible, so you can avoid having to filter for entities in your datastore by properties and just reference them by ID:

BEntity.query(ancestor = ndb.Key("RootEntity", 1, "AEntity", int(some_value)))

Here, int(some_value) is the integer ID of the AEntity you used when you created that object. Just be sure that you can ensure the IDs you manually create/use will be unique across all instances of that Model that share the same parent.

EDIT : To clarify, my last example should have been made more clear in that I was suggesting to restructure the data such that int(some_value) be used as the integer ID of the AEntity rather than storing is as a separate property of the Entity - if possible of course. From the example given, a query is performed for the AEntity objects that have a given integer field value of int(some_value) and executed with a get() - implying that you will always expect a single value return for that integer ID making it a good candidate to use as the integer ID for the key of that object eliminating the need for a query.