Как я могу получить более 1000 записей из хранилища данных и поместить все в один список для перехода к django?
Как получить более 1000?
Ответ 1
Начиная с версии 1.3.6 (выпущенной в августе-17-2010), вы CAN
Результаты запросов к хранилищу данных() и смещения для всех запросов хранилища больше не ограничены 1000.
Ответ 2
Только для лимита записи - выборка из 1000 записей в настоящее время отсутствует:
http://googleappengine.blogspot.com/2010/02/app-engine-sdk-131-including-major.html
Цитата:
Не более 1000 предел результата - это право: с добавлением курсоров и кульминацией многих меньших Стабильность и производительность хранилища данных улучшения за последние несколько месяцев, мы теперь достаточно уверены, чтобы удалить максимальный предел результата. Если вы делаете выборку, итерации, или используя Курсор, есть нет ограничений на количество результатов.
Ответ 3
App Engine дает вам хороший способ "подкачки" по результатам на 1000, заказывая по клавишам и используя последний ключ в качестве следующего смещения. Они даже предоставляют здесь несколько примеров кода:
http://code.google.com/appengine/docs/python/datastore/queriesandindexes.html#Queries_on_Keys
Хотя их пример распространяет запросы на многие запросы, вы можете изменить размер страницы от 20 до 1000 и запросить в цикле, объединяя запросы. Кроме того, вы можете использовать itertools для связывания запросов, не оценивая их до того, как они понадобятся.
Например, чтобы подсчитать количество строк за пределами 1000:
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
Ответ 4
Каждый раз, когда это возникает как ограничение, я всегда задаюсь вопросом: "Почему вам нужно более 1000 результатов?" Знаете ли вы, что сам Google не обслуживает более 1000 результатов? Попробуйте выполнить поиск: 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-ю страницу результаты поиска по запросу.
Если вы на самом деле возвращаете пользователю более 1000 результатов, то я думаю, что существует большая проблема, чем тот факт, что хранилище данных не позволит вам это сделать.
Одной из возможных (законных) причин, требующих много результатов, является то, что вы делаете большую операцию над данными и представляете резюме (например, среднее значение всех этих данных). Решение этой проблемы (о которой говорят в разговорах ввода-вывода Google) заключается в том, чтобы вычислять сводные данные "на лету", когда они входят, и сохранять их.
Ответ 5
Вы не можете.
В части часто задаваемых вопросов указано, что вы не можете получить доступ за пределами строки 1000 запроса, увеличение "OFFSET" приведет к более короткому набору результатов,
то есть: OFFSET 999 → 1 результат возвращается.
Из Википедии:
App Engine ограничивает максимальные ряды возвращается от лица до 1000 строк на вызов Datastore. Большинство веб-сайтов приложения баз данных используют пейджинг и кэширования и, следовательно, не требуют этого много данных сразу, так что это non-issue в большинстве сценариев. [цитата] необходимо] Если приложение требует больше чем 1000 записей за операцию, это может использовать свое собственное клиентское программное обеспечение или страницу Ajax для выполнения операции на неограниченном количестве строки.
От http://code.google.com/appengine/docs/whatisgoogleappengine.html
Другим примером лимита обслуживания является количество результатов, возвращаемых запрос. Запрос может вернуться максимум 1000 результатов. Запросы, которые вернуть больше результатов, верните максимум. В этом случае запрос, который выполняет такой запрос, вряд ли вернуть запрос до таймаута, но предел для сохранения ресурсов в хранилище данных.
От http://code.google.com/appengine/docs/datastore/gqlreference.html
Примечание. Предложение LIMIT имеет максимум 1000. Если указан предел, превышающий максимальный, максимальный используемый. Этот же максимум применяется к fetch() класса GqlQuery.
Примечание. Как и параметр смещения для метод fetch(), OFFSET в GQL строка запроса не уменьшает количество объектов, полученных из хранилище данных. Это влияет только на результаты возвращаются функцией fetch() метод. Запрос со смещением имеет характеристики производительности, которые линейно соответствуют смещению размер.
От http://code.google.com/appengine/docs/datastore/queryclass.html
Управление ограничениями и смещениями сколько результатов получено из хранилище данных и сколько их вернули методом fetch():
Хранилище данных выбирает смещение + ограничение результатов для приложения. Первые результаты смещения не пропущены самим хранилищем.
Метод fetch() пропускает результаты первого смещения, затем возвращает остальные (предельные результаты).
Запрос имеет характеристики производительности, которые соответствуют линейно со смещением плюс предел.
Что это означает
Если у вас есть сингулярный запрос, нет способа запросить что-либо за пределами диапазона 0-1000.
Увеличение смещения просто поднимет 0, поэтому
LIMIT 1000 OFFSET 0
Вернет 1000 строк,
и
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
Если ваши данные или запрос не могут иметь этот идентификатор жесткого кода ID, то вы не повезло
Ответ 6
Эта проблема с лимитом 1K разрешена.
query = MyModel.all()
for doc in query:
print doc.title
Обрабатывая объект Query как итерируемый: итератор извлекает результаты из хранилища данных небольшими партиями, позволяя приложению прекратить итерацию по результатам, чтобы избежать выборки больше, чем это необходимо. Итерация прекращается, когда все результаты, соответствующие запросу, были получены. Как и в случае с fetch(), интерфейс итератора не кэширует результаты, поэтому создание нового итератора из объекта Query приведет к повторному выполнению запроса.
Максимальный размер партии - 1K. И у вас все еще есть квоты auto Datastore.
Но с планом 1.3.1 SDK они ввели курсоры, которые могут быть сериализованы и сохранены, так что будущий вызов может начать запрос, где он последний раз остановился.
Ответ 7
Предел записи 1000 является жестким пределом в Google AppEngine.
В этой презентации http://sites.google.com/site/io/building-scalable-web-applications-with-google-app-engine объясняется, как эффективно выполнять перенос данных с помощью AppEngine.
(В основном, используя числовой идентификатор как ключ и определяющий предложение WHERE на идентификаторе.)
Ответ 8
Извлечение, хотя удаленный api все еще имеет проблемы, когда более 1000 записей. Мы написали эту крошечную функцию для перебора по таблице в кусках:
def _iterate_table(table, chunk_size = 200):
offset = 0
while True:
results = table.all().order('__key__').fetch(chunk_size+1, offset = offset)
if not results:
break
for result in results[:chunk_size]:
yield result
if len(results) < chunk_size+1:
break
offset += chunk_size
Ответ 9
мы используем что-то в нашем классе ModelBase, который:
@classmethod
def get_all(cls):
q = cls.all()
holder = q.fetch(1000)
result = holder
while len(holder) == 1000:
holder = q.with_cursor(q.cursor()).fetch(1000)
result += holder
return result
Это обходит ограничение 1000 запросов для каждой модели, не задумываясь об этом. Я полагаю, что версия ключей будет так же просто реализовать.
Ответ 10
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
Ответ 11
entities = []
for entity in Entity.all():
entities.append(entity)
Просто. Обратите внимание, что для каждого объекта есть RPC, который намного медленнее, чем выборка в кусках. Поэтому, если вас беспокоит производительность, сделайте следующее:
Если у вас меньше 1 М элементов:
entities = Entity.all().fetch(999999)
В противном случае используйте курсор.
Следует также отметить, что:
Entity.all().fetch(Entity.all().count())
возвращает 1000 макс и не должен использоваться.
Ответ 12
JJG: ваше решение выше является удивительным, за исключением того, что оно вызывает бесконечный цикл, если у вас есть 0 записей. (Я обнаружил это при тестировании некоторых моих отчетов локально).
Я изменил начало цикла while, чтобы выглядеть так:
while count % 1000 == 0:
current_count = query.count()
if current_count == 0:
break
Ответ 13
Чтобы добавить содержимое двух запросов вместе:
list1 = first query
list2 = second query
list1 += list2
Список 1 теперь содержит все результаты 2000 года.
Ответ 14
Предлагаемое решение работает только в том случае, если записи сортируются по ключу... Если вы сначала сортируете по другому столбцу, вам все равно придется использовать предложение limit (offset, count), тогда ограничение на 1000 записей по-прежнему применяется. Это то же самое, если вы используете два запроса: один для получения индексов (с условиями и сортировкой), а другой - с использованием индекса index() с подмножеством индексов из первого результата, поскольку первый запрос не может вернуть более 1000 ключей? (Раздел Google Queries on Keys четко не указывается, если нам нужно сортировать по ключу, чтобы удалить ограничение 1000 результатов)
Ответ 15
Это близко к решению, предоставленному Габриелем, но не дает результатов, которые он просто считает их:
count = 0
q = YourEntityClass.all().filter('myval = ', 2)
countBatch = q.count()
while countBatch > 0:
count += countBatch
countBatch = q.with_cursor(q.cursor()).count()
logging.info('Count=%d' % count)
Отлично работает для моих запросов и быстро (1,1 секунды для подсчета 67 000 объектов)
Обратите внимание, что запрос не должен быть фильтром неравенства или набором или курсором не будет работать, и вы получите это исключение:
AssertionError: нет курсора для MultiQuery (запросы с использованием операторов "IN" или "! =" )
Ответ 16
Если вы используете NDB:
@staticmethod
def _iterate_table(table, chunk_size=200):
offset = 0
while True:
results = table.query().order(table.key).fetch(chunk_size + 1, offset=offset)
if not results:
break
for result in results[:chunk_size]:
yield result
if len(results) < chunk_size + 1:
break
offset += chunk_size