计算Python中GQL查询给出的不同字符串的数量

Question

Suppose I have the following GQL database,

class Signatories(db.Model):
    name = db.StringProperty()
    event = db.StringProperty()

This database holds information regarding events that people have signed up for. Say I have the following entries in the database in the format (event_name, event_desc): (Bob, TestEvent), (Bob, TestEvent2), (Fred, TestEvent), (John, TestEvent). But the dilemma here is that I cannot just aggregate all of Bob's events into one entity because I'd like to Query for all the people signed up for a specific event and also I'd like to add such entries without having to manually update the entry every single time.

How could I count the number of distinct strings given by a GQL Query in Python (in my example, I am specifically trying to see how many people are currently signed up for events)?

I have tried using the old mcount = db.GqlQuery("SELECT name FROM Signatories").count() , however this of course returns the total number of strings in the list, regardless of the uniqueness of each string.

I have also tried using count = len(member) , where member = db.GqlQuery("SELECT name FROM Signatories") , but unfortunately, this only returns an error.

Answer 1

You can't - at least not directly. (By the way you don't have a GQL database).

If you have a small number of items, then fetch them into memory, and use a set operation to produce the unique set and then count

If you have larger numbers of entities that make in memory filtering and counting problematic then your strategy will be to aggregate the count as you create them,

eg

create a separate entity each time you create an event that has the pair of strings as the key. This way you will only have one entity the data store representing the specific pair. Then you can do a straight count.

However as you get large numbers of these entities you will need to start performing some additional work to count them as the single query.count() will become too expensive. You then need to start looking at counting strategies using the datastore.