Google AppEngine : Comment récupérer plus de 1000 données ?

Question

Premièrement : je suis un débutant en python.

Comment puis-je récupérer plus de 1000 enregistrements à partir du magasin de données et les mettre dans une seule liste à passer à django ?

Answer 1

À partir de la version 1.3.6 (sortie le 17 août 2010), vous pouvez CAN

Extrait du journal des modifications :

Résultats des requêtes count() du datastore et les offsets pour toutes les requêtes de datastore ne sont plus plafonnés à 1000 .

Answer 2

Pour mémoire, la limite de recherche de 1000 entrées a été supprimée :

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

Devis :

Plus de limite de 1000 résultats - C'est exact : avec l'ajout des curseurs et l'aboutissement de nombreux petits stabilité et les performances du Datastore performances au cours des derniers mois, nous sommes maintenant assez confiants pour supprimer la limite maximale de résultats. Que vous fassiez un fetch, une itération, ou l'utilisation d'un curseur. aucune limite sur le nombre de résultats.

Answer 3

App Engine vous offre une façon agréable de "paginer" dans les résultats par 1000 en les classant sur les clés et en utilisant la dernière clé comme le prochain 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 répartisse les requêtes sur de nombreuses requêtes, vous pouvez faire passer la taille de la page de 20 à 1000 et effectuer une requête en boucle, en combinant les ensembles de requêtes. De plus, vous pouvez utiliser itertools pour lier les requêtes sans les évaluer avant qu'elles ne soient nécessaires.

Par exemple, pour compter le nombre de rangées 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

Answer 4

Chaque fois que ce sujet est abordé 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 ne propose pas 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+résultats&début=1000&sa=N Je ne le savais pas jusqu'à récemment, car je n'avais jamais pris le temps de cliquer sur la 100e page de résultats de recherche pour une requête.

Si vous renvoyez plus de 1 000 résultats à l'utilisateur, je pense qu'il y a un problème plus important que le fait que le magasin de données ne vous laisse pas faire.

Une raison possible (légitime) pour avoir besoin d'autant de résultats est d'effectuer une grande opération sur les données et de présenter un résumé (par exemple, quelle est la moyenne de toutes ces données). La solution à ce problème (dont il est question dans la présentation de Google I/O) consiste à calculer les données récapitulatives à la volée, au fur et à mesure qu'elles arrivent, et à les enregistrer.

Answer 5

Tu ne peux pas.

Une partie de la FAQ indique qu'il n'y a aucun moyen d'accéder à une requête au-delà de la ligne 1000, et qu'en augmentant le "OFFSET", le jeu de résultats sera plus court,

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

De Wikipedia :

App Engine limite le nombre maximum de lignes maximum de rangs renvoyés par un get d'entité à 1000 rangs par appel au Datastore. La plupart des applications base de données utilisent la pagination et la et la mise en cache, et donc ne nécessitent pas pas besoin d'autant de données à la fois, ce qui problème dans la plupart des scénarios [citation]. nécessaire] Si une application a besoin de plus de plus de 1 000 enregistrements par opération, elle peut utiliser son propre logiciel côté client ou une page Ajax pour effectuer une opération sur un nombre illimité de rangées.

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

Un autre exemple de limite de service est le nombre de résultats retournés par un requête. Une requête peut renvoyer au maximum 1 000 résultats. Les requêtes qui plus de résultats ne renvoient que le maximum. Dans ce cas, une requête qui effectue une telle requête n'est pas susceptible de retourner une requête avant le délai imparti, mais la limite est en place pour conserver la ressources sur le datastore.

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

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

Remarque : Comme le paramètre de décalage pour la méthode fetch(), un OFFSET dans une chaîne de requête GQL ne réduit pas le nombre d'entités extraites du base de données. Il affecte seulement les résultats qui sont renvoyés par la méthode fetch() par la méthode fetch(). Une requête avec un décalage a caractéristiques de performance qui qui correspondent linéairement à la taille la taille.

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

Les arguments limite et décalage contrôlent combien de résultats sont récupérés depuis le base de données, et combien sont retournés par la méthode fetch() :

• Le datastore récupère les résultats du décalage et de la limite vers l'application. Les premiers résultats de décalage sont no sautée par le datastore lui-même.

• La méthode fetch() ignore les premiers résultats décalés, puis renvoie le reste (résultats limites).

• La requête a des caractéristiques de performance qui correspondent linéairement avec le montant du décalage plus la limite.

Cela signifie que

Si vous avez une requête unique, il n'y a aucun moyen de demander quelque chose en dehors de la plage 0-1000.

Augmenter le décalage ne fera qu'augmenter le 0, donc

LIMIT 1000  OFFSET 0

Retournera 1000 lignes,

et

LIMIT 1000 OFFSET 1000

Reviendra 0 rangs Il est donc impossible, avec une seule syntaxe de requête, d'obtenir 2000 résultats, que ce soit manuellement ou en utilisant l'API.

La seule exception plausible

Il s'agit de créer un index numérique sur la table, par exemple :

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

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

Si vos données ou votre requête ne peuvent pas avoir cet identifiant codé en dur "ID", alors vous êtes pas de chance