Я полагаю, что один из способов подсчета выглядит следующим образом:
foo = db.GqlQuery("SELECT * FROM bar WHERE baz = 'baz')
my_count = foo.count()
Что мне не нравится, так это то, что мой счет будет ограничен максимум 1000, и мой запрос, вероятно, будет медленным. У кого-нибудь есть обходной путь? У меня есть один на уме, но он не кажется чистым. Если бы только в GQL была настоящая функция COUNT...
+1 к ответу Иехии.
Официальный и благословенный метод получения счетчиков объектов в GAE — создание сегментированного счетчика. Несмотря на громкое название, это довольно просто.
При работе с масштабируемым хранилищем данных, таким как GAE, вам придется изменить свое мышление, чтобы заранее выполнять расчеты. В данном случае это означает, что вам нужно хранить счетчики для каждого baz и увеличивать их всякий раз, когда вы добавляете новый bar, а не считать во время отображения.
class CategoryCounter(db.Model):
category = db.StringProperty()
count = db.IntegerProperty(default=0)
затем при создании объекта Bar увеличивайте счетчик
def createNewBar(category_name):
bar = Bar(...,baz=category_name)
counter = CategoryCounter.filter('category =',category_name).get()
if not counter:
counter = CategoryCounter(category=category_name)
else:
counter.count += 1
bar.put()
counter.put()
db.run_in_transaction(createNewBar,'asdf')
теперь у вас есть простой способ получить количество для любой конкретной категории
CategoryCounter.filter('category =',category_name).get().count
Функции подсчета во всех базах данных работают медленно (например, O(n)) — хранилище данных GAE просто делает это более очевидным. Как предлагает Иехайя, вам нужно сохранить вычисленное количество в сущности и ссылаться на нее, если вам нужна масштабируемость.
Это не уникально для App Engine — другие базы данных просто скрывают это лучше, вплоть до момента, когда вы пытаетесь подсчитать десятки тысяч записей с каждым запросом, и время рендеринга вашей страницы начинает увеличиваться в геометрической прогрессии...
Согласно GqlQuery.count() документации, вы можете установить limit как некоторое число больше 1000:
from models import Troll
troll_count = Troll.all(keys_only=True).count(limit=31337)
Как говорят люди, разделенные счетчики — это правильный способ отслеживать такие числа, но если вы поймете это в конце игры (как я), вам нужно будет инициализировать счетчики из фактического количества объектов. Но это отличный способ сжечь бесплатную квоту Datastore Small Operations (думаю, 50 000). Каждый раз, когда вы запускаете код, он будет использовать столько операций, сколько существует объектов модели.
Я не пробовал, и это полный расход ресурсов, но, возможно, повторение с .fetch() и указанием смещения сработает?
LIMIT=1000
def count(query):
result = offset = 0
gql_query = db.GqlQuery(query)
while True:
count = gql_query.fetch(LIMIT, offset)
if count < LIMIT:
return result
result += count
offset += LIMIT
решение orip работает с небольшой настройкой:
LIMIT=1000
def count(query):
result = offset = 0
gql_query = db.GqlQuery(query)
while True:
count = len(gql_query.fetch(LIMIT, offset))
result += count
offset += LIMIT
if count < LIMIT:
return result
Теперь у нас есть статистика хранилища данных, которую можно использовать для запроса количества сущностей и других данных. Эти значения не всегда отражают самые последние изменения, поскольку они обновляются каждые 24–48 часов. Ознакомьтесь с документацией (см. ссылку ниже) для получения более подробной информации:
Как отметил @Dimu, статистика, периодически рассчитываемая Google, является достойным ресурсом для использования, когда точные подсчеты не нужны, а процент записей НЕ меняется кардинально в течение любого дня.
Чтобы запросить статистику для данного типа, вы можете использовать следующую структуру GQL:
select * from __Stat_Kind__ where kind_name = 'Person'
Есть ряд полезных свойств, возвращаемых this:
count -- количество Сущностей этого видаbytes -- общий размер всех сущностей, хранящихся в этом видеtimestamp -- на дату/время последнего расчета статистикиПример кода
Чтобы ответить на дополнительный вопрос, опубликованный в качестве комментария к моему ответу, я сейчас предоставляю пример кода C#, который я использую, который, по общему признанию, может быть не таким надежным, как должен быть, но, похоже, работает нормально для меня:
/// <summary>Returns an *estimated* number of entities of a given kind</summary>
public static long GetEstimatedEntityCount(this DatastoreDb database, string kind)
{
var query = new GqlQuery
{
QueryString = $"select * from __Stat_Kind__ where kind_name = '{kind}'",
AllowLiterals = true
};
var result = database.RunQuery(query);
return (long) (result?.Entities?[0]?["count"] ?? 0L);
}
Лучший обходной путь может показаться немного нелогичным, но он отлично работает во всех моих приложениях appengine. Вместо того, чтобы полагаться на целочисленные методы KEY и count(), вы добавляете собственное целочисленное поле к типу данных. Это может показаться расточительным, пока у вас действительно не будет более 1000 записей, и вы вдруг обнаружите, что fetch() и limit() НЕ РАБОТАЮТ ЗА ГРАНИЦЕЙ 1000 ЗАПИСЕЙ.
def MyObj(db.Model):
num = db.IntegerProperty()
Когда вы создаете новый объект, вы должны вручную получить самый высокий ключ:
max = MyObj.all().order('-num').get()
if max : max = max.num+1
else : max = 0
newObj = MyObj(num = max)
newObj.put()
Это может показаться пустой тратой запроса, но get() возвращает одну запись из верхней части индекса. Это очень быстро.
Затем, когда вы хотите извлечь больше 1000-го объекта, вы просто делаете:
MyObj.all().filter('num > ' , 2345).fetch(67)
Я уже сделал это, когда прочитал разгромный обзор Aral Balkan: http://aralbalkan.com/1504. Это расстраивает, но когда вы привыкнете к этому и поймете, насколько это быстрее, чем count() в реляционной базе данных, вы не будете возражать...
