How can I query for direct descendants only?

Question

Let's say I have entities a, b and c all of the same type, and the situation is like this:

entity a is parent for entity b entity b is parent for entity c

Now if I do the following query

query = ndb.Query(ancestor=a.key)
result = query.fetch()

The result will contain both b and c entities. Is there a way I can filter out c so that only entities that are direct descendants remain? Any way apart from me going through the results and removing them I mean.

Answer 1

This is a little late, however it will help anyone with the same problem.

The solution is to first do a keys-only query and take the subset of keys which are direct descendants.

With that subset of keys, you can batch get the desired entities.

I'm unfamiliar with python, so here's an example in go:

directDescKeys := make([]*datastore.Key, 0)

q := datastore.NewQuery("A").Ancestor(parentKey).KeysOnly()
for it := q.Run(ctx);; {
    key, err := it.Next(nil)
    if err == datastore.Done {
        break
    } else if err != nil {
        // handle error
    }

    if reflect.DeepEquals(key.Parent(), parentKey) {
        directDescKeys = append(directDescKeys, key)
    }
}

entities := make([]*A, len(directDescKeys))
if err := datastore.GetMulti(ctx, directDescKeys, entities); err != nil {
    // handle error
}

Answer 2

Actually, this is not supported at all. Nick's answer does work but only if you can specify the entity kind in your query which the OP did not specify:

"Kindless queries cannot include filters on properties. They can, however, filter by Entity Key by passing Entity.KEY_RESERVED_PROPERTY as the property name for the filter. Ascending sorts on Entity.KEY_RESERVED_PROPERTY are also supported."

Answer 3

The only way to do this is to modify your schema, adding a 'parent' KeyProperty that references an entity's direct parent, then filtering on that.