存在的GQL查询：获取与密钥查询与实体查询

Question

While the Google Cloud Client Library has a lot of built-in functionality, I haven't found anything to use when querying for an Entitys existence based on its id. From what I understand, it is much more efficient to make a key query, than an entity query like so.

SELECT __key__ FROM User WHERE __key__ = Key(User, 1)

If possible from within a Java app, using the get(Key key) function would be even better.

Datastore datastore = DatastoreOptions.getDefaultInstance().getService();
KeyFactory keyFactory = datastore.newKeyFactory().setKind(User);
Key key = keyFactory.newKey(1);
Entity entity = datastore.get(key);

If I have an instance where my Entity has ancestors as well, which would be more efficient of the three when querying for the existence of an ancestor with just the parent ID? I assume that the entity query ( SELECT * From Parent WHERE __key__ = Key(Parent, 1) ) will always be slower than a key query, but how about when compared to the get?

What about when the ancestor paths are chained even longer? Then the key queries may become something along the likes of:

SELECT __key__ FROM Grandchild WHERE __key__ = Key(Parent, 1, Child, 1, Grandchild, 1)

Answer 1

Key-only queries are faster because the Entity data does not have to be transmitted back to the client. Let's say you have an entity with N number of properties and the size of those properties (names and values) is 50 KB, you are saving 50 KB of data transfer over the network, if you do a key-only query.

The actual lookup of the entity from the Datastore point of view would be same whether you use Key-only query, Entity Query based on a Key or Get(key) method because the Datastore just looks up the entity based on the provided key.

To summarize - if all you need to know is if an entity with the given keys exists are not, key-only query would be your best option.