Как выбрать больше чем 1 000?

Добавить содержание двух запросов вместе:

list1 = first query
list2 = second query
list1 += list2

Список 1 теперь содержит весь 2000 результаты.

1 000 рекордных пределов являются жестким пределом в Google AppEngine.

Это представление http://sites.google.com/site/io/building-scalable-web-applications-with-google-app-engine объясняет, как эффективно пролистать использование данных AppEngine.

(В основном при помощи числового идентификатора как ключ и определение оператора Where на идентификаторе.)

Каждый раз, когда это подходит как ограничение, я всегда задаюсь вопросом" , почему Вам нужны больше чем 1 000 результатов?" Знаете ли Вы, что Google самостоятельно не подает больше чем 1 000 результатов? Попробуйте этот поиск: http://www.google.ca/search?hl=en&client=firefox-a&rls=org.mozilla:en-US:official&hs=qhu&q=1000+results&start=1000&sa=N я не знал, что до недавнего времени, потому что я никогда не не торопился для нажатия в 100-ю страницу результатов поиска на запросе.

, Если Вы на самом деле возвращаете больше чем 1 000 результатов назад пользователю, тогда я думаю, что существует большая проблема под рукой, чем то, что хранилище данных не позволит Вам сделать это.

Одна возможная (законная) причина нуждаться в этом много результатов состоят в том, если Вы делали большую операцию на данных и представляли сводку (например, каково среднее число всех этих данных). Решение этой проблемы (о котором говорят в разговоре Google I/O) состоит в том, чтобы вычислить сводные данные на лету, как это входит, и сохраните его.

Вы не можете.

Часть FAQ указывает, что нет никакого способа, которым можно получить доступ вне строки, 1000 из запроса, увеличивая "СМЕЩЕНИЕ" просто приведут к более короткому набору результатов,

т.е.: СМЕСТИТЕ 999->, 1 результат возвращается.

Из Википедии:

пределы Механизма Приложения максимальные строки, возвращенные из объекта, добираются до 1 000 строк на вызов Хранилища данных. Большинство веб-приложений базы данных использует подкачку страниц и кэширование, и следовательно не требует этого большого количества данных сразу, таким образом, это - надуманный вопрос в большинстве сценариев. [необходима цитата], Если для приложения нужны больше чем 1 000 записей на операцию, оно может использовать свое собственное клиентское программное обеспечение или страницу Ajax для выполнения операции на неограниченном количестве строк.

От http://code.google.com/appengine/docs/whatisgoogleappengine.html

Другим примером сервисного предела является количество результатов, возвращенных запросом. Запрос может возвратить самое большее 1 000 результатов. Запросы, которые возвратили бы больше результатов только, возвращают максимум. В этом случае запрос, который выполняет такой запрос, вероятно, не возвратит запрос перед тайм-аутом, но предел существует для сохранения ресурсов на хранилище данных.

От http://code.google.com/appengine/docs/datastore/gqlreference.html

Примечание: ПРЕДЕЛЬНЫЙ пункт имеет максимум 1 000. Если предел, больше, чем максимум, определяется, максимум используется. Этот тот же максимум относится к выборке () метод класса GqlQuery.

Примечание: Как параметр смещения для выборки () метод, СМЕЩЕНИЕ в строке запроса GQL не сокращает количество объектов, выбранных от хранилища данных. Это только влияет, какие результаты возвращаются выборкой () метод. Запрос со смещением имеет рабочие характеристики, которые соответствуют линейно размеру смещения.

От http://code.google.com/appengine/docs/datastore/queryclass.html

предел и аргументы смещения управляют, сколько результатов выбирается от хранилища данных, и сколько возвращается выборкой () метод:

• хранилище данных выбирает смещение + предельные результаты к приложению. Первые результаты смещения не пропущены самим хранилищем данных.

• выборка () метод пропускает первые результаты смещения, затем возвращает остальных (предельные результаты).

• запрос имеет рабочие характеристики, которые соответствуют линейно объему смещения плюс предел.

то, Что это означает,

, Если у Вас есть исключительный запрос, нет никакого способа запросить что-либо вне диапазона 0-1000.

смещение Увеличения просто повысит этот 0, таким образом

LIMIT 1000  OFFSET 0    

возвратит 1 000 строк,

и

LIMIT 1000 OFFSET 1000 

возвратится 0 строк , таким образом, лишая возможности на, с синтаксисом единого запроса, выберет результаты 2000 года или вручную или с помощью API.

единственное вероятное исключение

должно создать числовой индекс на таблице, т.е.:

 SELECT * FROM Foo  WHERE ID > 0 AND ID < 1000 

 SELECT * FROM Foo WHERE ID >= 1000 AND ID < 2000

, Если Ваши данные или запрос не могут иметь этого 'идентификатора' hardcoded идентификатор, то Вы неудачливые

Механизм приложения дает Вам хороший способ "подкачки страниц" через результаты 1 000 путем упорядочивания на Ключах и использования последнего ключа в качестве следующего смещения. Они даже предоставляют некоторый код кода здесь:

http://code.google.com/appengine/docs/python/datastore/queriesandindexes.html#Queries_on_Keys

Хотя их пример распространяет запросы по многим запросам, можно изменить размер страницы от 20 до 1 000 и запросить в цикле, комбинируя querysets. Дополнительно Вы могли бы использовать itertools для соединения запросов, не оценивая их, прежде чем они будут необходимы.

Например, для подсчета, сколько строк вне 1 000:

class MyModel(db.Expando):
    @classmethod
    def count_all(cls):
        """
        Count *all* of the rows (without maxing out at 1000)
        """
        count = 0
        query = cls.all().order('__key__')

        while count % 1000 == 0:
            current_count = query.count()
            if current_count == 0:
                break

            count += current_count

            if current_count == 1000:
                last_key = query.fetch(1, 999)[0].key()
                query = query.filter('__key__ > ', last_key)

        return count

Предлагаемое решение работает только в том случае, если записи отсортированы по ключу ... Если вы сначала выполняете сортировку по другому столбцу, вам все равно придется использовать предложение limit (offset, count), а затем 1000 ограничение на количество записей по-прежнему действует. То же самое, если вы используете два запроса: один для получения индексов (с условиями и сортировкой), а другой - с использованием where index in () с подмножеством индексов из первого результата, поскольку первый запрос не может вернуть более 1000 ключей? (В разделе Google Queries on Keys четко не указано, нужно ли нам сортировать по ключу , чтобы снять ограничение на 1000 результатов)

JJG: ваше решение, приведенное выше, потрясающее, за исключением того, что оно вызывает бесконечный цикл, если у вас 0 записей. (Я обнаружил это при локальном тестировании некоторых своих отчетов.)

Я изменил начало цикла while, чтобы он выглядел следующим образом:

while count % 1000 == 0:
    current_count = query.count()
    if current_count == 0:
        break

class Count(object):
def getCount(self,cls):
    class Count(object):
def getCount(self,cls):
    """
    Count *all* of the rows (without maxing out at 1000)
    """
    count = 0
    query = cls.all().order('__key__')


    while 1:
        current_count = query.count()
        count += current_count
        if current_count == 0:
            break

        last_key = query.fetch(1, current_count-1)[0].key()
        query = query.filter('__key__ > ', last_key)

    return count

Эта проблема с ограничением в 1 КБ устранена.

query = MyModel.all()
for doc in query:
    print doc.title

Посредством обработки объекта Query как итерируемого: итератор извлекает результаты из хранилища данных небольшими партиями, что позволяет приложению прекратить повторение результатов, чтобы избежать получения большего количества, чем необходимо. Итерация останавливается, когда будут получены все результаты, соответствующие запросу. Как и в случае с fetch (), интерфейс итератора не кэширует результаты, поэтому создание нового итератора из объекта Query приведет к повторному выполнению запроса.

Максимальный размер пакета - 1 КБ. И у вас по-прежнему есть квоты для автоматического хранилища данных.

Но в пакете plan 1.3.1 SDK они ввели курсоры, которые можно сериализовать и сохранить, чтобы при следующем вызове запрос мог начинаться с того места, где он в последний раз остановился.

Просто для справки - лимит выборки в 1000 записей теперь исчез:

http://googleappengine.blogspot.com/2010/02/app-engine-sdk-131-including-major.html

Цитата:

Больше нет лимита в 1000 результатов - Это верно: с добавлением курсоров и кульминацией многих более мелких стабильности и производительности хранилища данных улучшений за последние несколько месяцев, мы теперь достаточно уверены, чтобы убрать ограничение на максимальный результат. Выполняете ли вы выборку, итерацию или используете курсор, не существует количество результатов не ограничено.