Comment faire pour récupérer plus de 1000?

Comment puis-je récupérer plus de 1000 enregistrement à partir de la banque de données et de les mettre tous dans une seule liste à transmettre à django?

InformationsquelleAutor Zote | 2008-11-05

37

À partir de la Version 1.3.6 (sorti en Août-17-2010), vous PEUT

De le changelog:

Résultats de la banque de données de count() requêtes et des compensations pour l'ensemble de la banque de données les requêtes ne sont plus limités à 1000.
- Je suis encore en train de seulement 1000 environ 3600 il se doit. Comment mettre en place cette? Merci
- une seule extraction ne peut que retourner 1000, mais vous pouvez effectuer une itération sur la requête de l'extraction de 1000 à l'heure et réglage de l'offset pour les 1000 prochaines. Je vais poster le code pour bientôt.
- Cela fonctionne par exemple: numTotalUsers = Utilisateur.tous(keys_only=True).count(999999) # la 999999 est la limite maximum. sinon je obtenir 1000 comme mon comte.
- À l'aide d'offset est pas recommandé pour des performances et des coûts. Vous devez utiliser un Curseur se place comme indiqué ici: developers.google.com/appengine/docs/python/datastore/...
- Ce n'est pas recommandé. Vous devriez regarder dans la fragmentation des compteurs à la place: blog.svpino.com/2015/03/08/...
InformationsquelleAutor Shay Erlichmen
23

Juste pour le record de chercher la limite de 1000 entrées est maintenant révolue:

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

Citation:

Pas plus de 1000 résultat limite - C'est
droite: avec l'ajout de Curseurs et
le point culminant de nombreuses petites
La banque de données de la stabilité et des performances
des améliorations au cours des derniers mois,
nous sommes maintenant assez confiant pour enlever
le maximum de résultat, à la limite tout à fait.
Si vous êtes en train de faire une extraction,
l'itération, ou à l'aide d'un Curseur, il y a
pas de limites sur le nombre de résultats.

InformationsquelleAutor Tomasz Zieliński
19

App Engine vous donne une belle façon de "pagination" à travers les résultats par 1000 par la commande de Clés et en utilisant la dernière touche que la prochaine décalage. Ils fournissent même un exemple de code ici:

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

Bien que leur exemple écarte les requêtes sur de nombreuses demandes, vous pouvez modifier la taille de la page à partir de 20 à 1000 et de la requête dans une boucle, la combinaison de la querysets. En outre, vous pouvez utiliser itertools pour relier les requêtes sans les évaluer, avant qu'ils ne soient nécessaires.

Par exemple, pour compter le nombre de lignes au-delà de 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
```
- Cette boucle pour toujours, si le nombre réel se trouve être un multiple exact de 1000 -- mauvaise sortie d'état!-) Sinon nice...
- Cela ne fonctionnera pas. La boucle while n'est jamais entré b/c compteur est initialisé à zéro.
InformationsquelleAutor JJ Geewax
18

Chaque fois que cela apparaît comme une limitation, je me demande toujours "pourquoi avez-vous besoin de plus de 1 000 résultats?" Saviez-vous que Google lui-même, n'est pas de servir jusqu'à plus de 1 000 résultats? Essayez cette recherche: 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 je ne le savais pas jusqu'à récemment, parce que je n'avais jamais pris le temps de cliquer sur le 100e page de résultats de recherche sur une requête.

Si vous êtes de retour plus de 1000 résultats à l'utilisateur, puis je pense qu'il y a un gros problème à portée de main que le fait que la banque de données ne vous laissera pas faire.

Une (légitime) de la raison pour avoir besoin d'autant de résultats est si vous faisiez une grande opération sur les données et la présentation d'un résumé (par exemple, quelle est la moyenne de toutes ces données). La solution à ce problème (qui est parlé dans la Google I/O de parler) est de calculer la synthèse de données à la volée, comme il arrive, et de l'enregistrer.
- D'accord. Il n'y a aucun point dans le retour de milliers de résultats à un utilisateur dans une page unique.
- Et il suit de là qu'il n'y a pas de point de traction de 1000 dossiers de la banque de données, sauf si vous allez le retour de l'utilisateur.
- Si je veux calculer la somme d'un bien de plus de 1000 entités stockées dans la banque de données, j'aurais besoin de l'adresse de cette limite, en quelque sorte. jgeewax a la solution que je cherchais.
InformationsquelleAutor Tony Arkles
14

Vous ne pouvez pas.

Partie de la FAQ indique qu'il n'existe aucun moyen que vous pouvez accéder au-delà de la ligne 1 000 d'une requête, l'augmentation de la "OFFSET" sera simplement résultat en moins de résultat,

ie: OFFSET 999 --> 1 résultat revient.

De Wikipedia:

App Engine limite le nombre maximum de lignes
retourné à partir d'une entité arriver à 1000
lignes par la banque de données de l'appel. La plupart des sites web
applications de base de données utilisation de la pagination et de la
la mise en cache, et donc ne nécessitent pas de ce
beaucoup de données à la fois, donc c'est un
non-problème dans la plupart des scénarios.[citation
nécessaire] Si une application a besoin de plus de
de 1000 dossiers par opération, il
peut utiliser son propre logiciel client
ou une page Ajax pour effectuer une
opération sur un nombre illimité de
les lignes.

De http://code.google.com/appengine/docs/whatisgoogleappengine.html

Un autre exemple d'une limite de service est
le nombre de résultats retournés par un
de la requête. Une requête peut retourner au plus
1000 résultats. Les requêtes qui serait
de retour des résultats plus seulement le retour
maximum. Dans ce cas, une demande de
effectue une telle requête n'est pas susceptible d'
de retour d'une demande avant le délai d'expiration,
mais la limite est en place pour économiser l'
les ressources de la banque.

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

Remarque: UNE clause LIMIT a un maximum de
1000. Si une limite supérieure à la valeur maximale est spécifiée, la valeur maximale est de
utilisé. Cette même limite s'applique à la
fetch() la méthode de la GqlQuery classe.

Remarque: Comme le paramètre offset pour
fetch (), un DÉCALAGE dans un GQL
chaîne de requête ne permet pas de réduire la
nombre d'entités extraites de la
la banque de données. Il n'affecte que les
les résultats sont retournés par le fetch()
la méthode. Une requête avec un offset a
caractéristiques de performance
correspondent de façon linéaire avec le décalage
la taille de l'.

De http://code.google.com/appengine/docs/datastore/queryclass.html
La limite et de compenser les arguments de contrôle
combien de résultats sont extraits de la
magasin de données, et combien sont retournés
par fetch ():
- La banque de données récupère offset + limite les résultats à l'application. Le premier décalage résultats sont pas sauté par la banque elle-même.
- Fetch() ignore le premier décalage résultats, puis renvoie le reste (limiter les résultats).
- La requête a des caractéristiques de performance qui correspondent
  linéairement avec la quantité de décalage en plus de la limite.
Ce que cela signifie, c'est

Si vous avez une singulière requête, il n'existe aucun moyen de demander quelque chose à l'extérieur de la gamme 0-1000.

L'augmentation de compensation à lever la 0, de sorte
```
LIMIT 1000  OFFSET 0    
```
Sera de retour 1000 lignes,

et
```
LIMIT 1000 OFFSET 1000 
```
Sera de retour 0 lignes, donc, ce qui rend impossible l', avec une seule syntaxe de la requête, il récupère les résultats 2000, que ce soit manuellement ou en utilisant l'API.

La seule plausible exception

Est de créer un index numérique sur la table, c'est à dire:
```
 SELECT * FROM Foo  WHERE ID > 0 AND ID < 1000 

 SELECT * FROM Foo WHERE ID >= 1000 AND ID < 2000
```
Si vos données ou une requête ne peut pas avoir cette 'ID' identificateur codé en dur, alors vous êtes hors de la chance
- C'est, je le sais. Mais Comment je peux récupérer 1000 par 1000 et créer 1 liste avec 2000?
- list1 = première requête de la liste 2 = deuxième requête list1 += liste2
- Tom: sa inutile si la deuxième requête, en raison de la base de données des limites, c'est la garantie de retour 0 lignes.
- Notez que cette réponse est aujourd'hui quelque peu obsolète: Le pseudo-propriété est désormais disponible pour le tri et le filtrage, ce qui permet d'itérer sur arbitrairement grands ensembles de résultats par morceaux.
- Il est possible à l'aide de jgeewax de la méthode.
InformationsquelleAutor Kent Fredric
10

Ce 1K limiter problème est résolu.
```
query = MyModel.all()
for doc in query:
    print doc.title
```
Par le traitement de la Requête de l'objet comme un objet iterable: L'itérateur récupère les résultats de la banque de données en petits lots, ce qui permet pour l'application pour arrêter l'itération sur les résultats afin d'éviter l'extraction de plus que ce qui est nécessaire. L'itération s'arrête lorsque tous les résultats correspondant à la requête ont été récupérés. Comme avec fetch(), l'interface iterator ne pas mettre en cache les résultats, de sorte que la création d'un nouvel itérateur de l'objet de Requête ré-exécuter la requête.

Max taille des lots est de 1K. Et vous avez encore le auto de la banque de données des quotas.

Mais avec le plan 1.3.1 SDK, ils ont introduit les curseurs qui peuvent être sérialisés et enregistrées de sorte qu'une nouvelle invocation peut commencer la requête où elle s'est laissée.

InformationsquelleAutor Tiger Woods
7

Les 1000 limite d'enregistrement est une dure limite sur Google AppEngine.

Cette présentation http://sites.google.com/site/io/building-scalable-web-applications-with-google-app-engine explique la façon la plus efficace de la page par le biais de données à l'aide de AppEngine.

(Essentiellement par l'utilisation d'un identifiant numérique comme la clé et la spécification d'une clause where sur l'id.)

InformationsquelleAutor jakber

Bien que l'extraction de l'api à distance a toujours des problèmes lorsque plus de 1000 enregistrements. Nous avons écrit cette petite fonction pour effectuer une itération sur une table en morceaux:

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

InformationsquelleAutor Tzach

3

nous sommes à l'aide de quelque chose dans notre ModelBase classe:
```
@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
```
Cela permet de contourner la 1000 limite de requête sur tous les modèles sans avoir à y penser. Je suppose qu'une des clés de la version serait tout aussi facile à mettre en œuvre.

InformationsquelleAutor Gabriel

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

InformationsquelleAutor fun_vit

2
```
entities = []
for entity in Entity.all():
    entities.append(entity)
```
Simple que cela. Notez qu'il existe une RPC pour chaque entité qui est beaucoup plus lent que d'aller chercher dans les morceaux. Donc, si vous êtes inquiet au sujet de la performance, procédez de la manière suivante:

Si vous avez moins de 1M éléments:
```
entities = Entity.all().fetch(999999)
```
Sinon, utilisez un curseur.

Il convient également de noter que:
```
Entity.all().fetch(Entity.all().count())
```
retourne 1000 max et ne doit pas être utilisé.
- Donc, si vous parcourir l'Entité.tous les() de la requête, vous continuerez à obtenir des résultats jusqu'à ce que vous frappez le dernier élément qui correspond à la requête, même si c'est #de 100 000? Ne GAE prêt le lot suivant lorsque vous êtes à #999, #1999, #2999?
InformationsquelleAutor
1

JJG: votre solution ci-dessus est génial, sauf qu'il provoque une boucle infinie si vous avez 0 enregistrements. (J'ai trouvé cela bien que les tests de certains de mes rapports localement).

J'ai modifié le début de la boucle while pour ressembler à ceci:
```
while count % 1000 == 0:
    current_count = query.count()
    if current_count == 0:
        break
```
InformationsquelleAutor mhawthorne
0

Pour ajouter le contenu de la deux requêtes:
```
list1 = first query
list2 = second query
list1 += list2
```
Liste 1 contient maintenant tous les résultats 2000.
- C'est bien dans les normal de la base de données, mais pas en FGA avec GQL. GQL a une dure limite. LIMIT/OFFSET basée sur l'augmentation ne sera pas vous aider, ils doivent être différentes requêtes, c'est à dire: les différentes OÙ les conditions.
- Je suis d'accord avec (et ont upvoted) votre réponse. Mon point est de se concentrer sur le python question. Une fois que vous avez deux listes (à l'aide de différents où les conditions), vous avez besoin de les fusionner. C'est extrêmement simple, mais une partie de sa question que vous avez manqué.
- Il pourrait être bon de l'avertir que la taille de GAE objet peut aussi limitée. Au cours de la bêta, il était de 1 mégaoctet.
InformationsquelleAutor
0

La solution proposée ne fonctionne que si les entrées sont triées par clé... Si vous êtes de tri par une autre colonne tout d'abord, vous devez toujours utiliser une limite(offset, comte) de la clause, alors les entrées de 1000 limitation continuent de s'appliquer. C'est la même chose si vous utilisez deux demandes : l'une pour la récupération des index (avec les conditions et tri) et l'autre à l'aide d'index en () avec un sous-ensemble d'index à partir de la première suite, que la première requête ne peut pas retourner de plus de 1000 clés ? (Google Requêtes sur les Touches l'article ne précise pas clairement si nous avons à trier par clé pour supprimer les 1000 résultats limitation)

InformationsquelleAutor
0

Il est proche de la solution fournie par Gabriel, mais ne pas aller chercher les résultats, il seulement compte:
```
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)
```
Fonctionne parfaitement pour mes requêtes, et rapide aussi (1.1 secondes à compter de 67 000 entités)

Notez que la requête ne doit pas être une inégalité de filtre ou d'un ensemble ou le curseur ne fonctionnera pas et vous obtiendrez cette exception:

AssertionError: Pas de curseur disponible pour un MultiQuery (requêtes à l'aide de "EN" ou "!=" les opérateurs)

InformationsquelleAutor Timothy Tripp

Si vous utilisez 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

InformationsquelleAutor Oded Breiner

Vous devez vous connecter pour publier un commentaire.

Ce que cela signifie, c'est

La seule plausible exception