efficace de la mémoire intégrée SqlAlchemy itérateur/générateur?

J'ai un ~10M enregistrement de la table MySQL que je l'interface avec l'aide de SqlAlchemy. J'ai trouvé que les requêtes sur de grands sous-ensembles de ce tableau permettra de consommer trop de mémoire, même si je pensais que j'étais l'aide d'un générateur de façon intelligente extraites petits morceaux de la base de données:

for thing in session.query(Things):
    analyze(thing)

Pour éviter cela, je trouve que je dois construire mon propre itérateur qui mord en morceaux:

lastThingID = None
while True:
    things = query.filter(Thing.id < lastThingID).limit(querySize).all()
    if not rows or len(rows) == 0: 
        break
    for thing in things:
        lastThingID = row.id
        analyze(thing)

Est-ce normal ou est-il quelque chose qui m'échappe concernant SA built-dans les générateurs?

La réponse à cette question semble indiquer que la consommation de la mémoire n'est pas à prévoir.

J'ai quelque chose de très similaire, sauf qu'il donne de "chose". Fonctionne mieux que toutes les autres solutions
N'est-il pas Chose.id > lastThingID? Et qu'est-ce que les "lignes"?

InformationsquelleAutor Paul | 2011-09-12

107

Plus DBAPI implémentations entièrement lignes de tampon comme elles sont lues - ainsi, habituellement, avant la SQLAlchemy ORM obtient même une attente d'un résultat, la totalité des résultats est en mémoire.

Mais alors, la voie de Requête fonctionne, c'est qu'il est entièrement chargée, le résultat fourni par défaut avant de revenir à vous de vos objets. Le raisonnement ce qui concerne les requêtes qui sont plus que de simples instructions SELECT - se joint à d'autres tables qui peut retourner la même identité de l'objet de multiples fois dans un jeu de résultats (commun avec impatient de chargement), l'ensemble des lignes doit être dans la mémoire de sorte que les bons résultats peuvent être retournés autrement les collections et tel pourrait être que partiellement rempli.

Afin de Requête dispose d'une option pour modifier ce comportement, qui est le yield_per() appel http://www.sqlalchemy.org/docs/orm/query.html?highlight=yield_per#sqlalchemy.orm.query.Query.yield_per . Cet appel va provoquer la Requête de rendement des lignes de lots, où vous le donner la taille du lot. Comme les docs de l'état, ce n'est approprié que si vous ne faites tout type de chargement impatient de collections - c'est donc, fondamentalement, si vous savez vraiment ce que vous faites. Et aussi, si le sous-jacent DBAPI pré-tampons lignes , il y aura encore que la surcharge de la mémoire si l'approche ne échelles légèrement mieux que ne l'utilisez pas.

Je n'ai pratiquement jamais utiliser yield_per() - au lieu de cela, j'utilise une meilleure version de la LIMITE d'approche vous suggérons ci-dessus en utilisant les fonctions de la fenêtre. LIMIT et OFFSET avez un énorme problème que les très grandes valeurs de DÉCALAGE cause de la requête pour obtenir de plus en plus lentement, comme un DÉCALAGE de N causes à la page grâce à N lignes - c'est comme faire la même requête cinquante fois au lieu d'une, à chaque fois que la lecture d'un plus grand et plus grand nombre de lignes. Avec une fenêtre-l'approche par la fonction, je l'ai pré-extraction d'un ensemble de "fenêtre" valeurs qui font référence à des segments de la table, je veux sélectionner. Je puis émettre SELECT de déclarations que chaque traction de l'une de ces fenêtres à la fois.

La fenêtre de la fonction de l'approche est sur le wiki à http://www.sqlalchemy.org/trac/wiki/UsageRecipes/WindowedRangeQuery et je l'utilise avec beaucoup de succès.

Également de noter que pas toutes les bases de données de soutenir les fonctions de la fenêtre - vous besoin PG, Oracle ou SQL Server. À mon humble avis à l'aide d'au moins Postgresql est certainement la peine - si vous utilisez une base de données relationnelle, vous pourriez aussi bien utiliser le meilleur.
- Vous mentionnez Requête instanciant tout pour comparer les identités. Cela pourrait être évité par un tri sur la clé primaire, et la comparaison de résultats consécutifs?
- la question est de savoir si vous donner un exemple avec l'identité de X, l'application obtient une main, puis prend ses décisions en fonction de cette entité, et peut-être même se transforme il. Plus tard, peut-être (en fait habituellement), même sur la ligne suivante, la même identité revient dans le résultat, peut-être à ajouter plus de contenu à ses collections. L'application a donc reçu l'objet dans un état incomplet. le tri n'aide pas ici parce que le plus gros problème est le fonctionnement de l'désireux de chargement, à la fois "uni" et "sous-requête" chargement ont des problématiques différentes.
- J'ai compris la "ligne suivante met à jour les collections de chose, dans ce cas, vous seulement besoin de regarder à l'avance par un db ligne pour savoir quand les collections sont complètes. La mise en œuvre de chargement impatient aurait à coopérer avec le tri, de sorte que la collecte des mises à jour sont toujours fait sur des lignes adjacentes.
- le yield_per option() est toujours là pour quand vous êtes confiant sur la requête que vous êtes en émettant est compatible avec la livraison partielle des ensembles de résultats. J'ai passé un marathon de plusieurs jours session essayer d'activer ce comportement dans tous les cas, il y avait toujours obscur, qui est, jusqu'à ce que votre programme utilise l'un d'entre eux, sur les bords qui a échoué. En particulier, en s'appuyant sur la commande ne peut pas être pris en charge. Comme toujours, je suis la bienvenue en code contributions.
- Je suis désolé pour chahuter vous. Je voulais juste savoir davantage sur ce que cela est difficile.
- c'était surtout une question de combien de compliqué, il fallait obtenir pour englober tous les possibles cas d'utilisation, y compris lorsque le même groupe de classes peuvent être rencontrés plusieurs, déconnecté fois de suite, ainsi que la façon de faire de la susdite "vérifier pour la fin de l'rejoint résultat" logique, qui aurait à travailler de manière récursive. Une fois que vous faites le comportement implicite, alors vous êtes sur le crochet pour tous les bugs d'aller de l'avant. Si j'avais les ressources d'une équipe de développeurs derrière moi, c'est peut-être quelque chose de supportable, mais il a été d'apprendre à être extrêmement complexe pour pas grand chose d'un avantage.
- et sqlalchemy a déjà une énorme quantité de complexité im cherche constamment à se réduire, tout en conservant le comportement de contrat.
- Comment voulez-vous suggérons d'appliquer les WindowedRangeQuery l'utilisation de la recette sur un très grand, filtrée ensemble de données avec aucune naturelle de la colonne de tirer varie de? Nous sommes en train de creuser dans notre base de données de la recherche pour "aiguille dans la botte de foin" les types de lignes. Seulement dans ce cas, notre botte de foin est tellement grand qu'il dépasse 800 lignes retournées et l'habitude OFFSET/LIMITE approche ralentit énormément. J'ai essayé en utilisant le NUMÉRO de LIGNE sur l'ensemble des données de retour des plages de lignes à retourner, mais il s'est vite rendu compte de mon erreur. Souhaitons qu'il y avait un moyen plus facile de retourner paginé résultats à partir d'une base de données...
- pratiquement toute table relationnelle a une sorte de unique candidat à la clé, composé d'un groupe de colonnes. si la table a vraiment pleinement des lignes en double, alors il n'est pas clair ce que le sens est de la pure dupes et pourquoi vous auriez ceux.
- merci pour votre explication, la fenêtre-l'approche par la fonction va peut ne pas fonctionner pour moi parce que lors de la pagination par le biais de données de résultats de certaines lignes peuvent changer(entre deux Sélectionne), mais j'ai besoin de données qui a été effective lors de la première SÉLECTIONNEZ venu. Je ne peux pas charger tous les résultats dans la mémoire, car il est trop grand. Donc, je suis en train de tester yeild_per, ressemble à de la mémoire reste sous contrôle. Je veux utiliser yield_per fonction et d'essayer de comprendre si il adapté pour mon cas. Est-il un exemple avec des explications plus détaillées quand et pourquoi les jointures ou les sous-requêtes devenir un problème?
- J'ai lu ce fil et la page de manuel couple de fois, mais ne peut toujours pas comprendre pourquoi et quand une requête peut devenir pas bon à utiliser avec yield_per. Merci.
- Depuis que je suis en utilisant postgres ressemble, il est possible d'utiliser la Lecture répétée lecture seule opération et de l'exécution de toutes les fenêtre de requêtes dans le cadre de l'opération.
- Dans le WindowedRangeQuery l'utilisation de la recette vous répondre liés, ce qui est le double modulo (%%) de l'opérateur? Je ne trouve rien sur elle, est-ce une faute de frappe?
- Même dans SQLAlchemy de Base 1.1.x, ResultProxy semble essayer d'extraire chaque ligne (et ce n'est pas un itérateur soit). Je suis actuellement en train de revenir à la crue db-api objet curseur pour effectuer une itération sur les deux cx_Oracle et psycopg2 de la vanille, de la non-serverside curseurs. Si le comportement est clairement pas le DB-API de mise en œuvre de comportement. C'est un juste compromis entre la complexité du code (je ne peux plus utiliser SQLAlchemy pour le dialecte de l'abstraction) et l'utilisation de la mémoire.
InformationsquelleAutor zzzeek
13

J'ai été regarder dans efficace traversée/recherche avec SQLAlchemy et souhaitez mettre à jour cette réponse.

Je pense que vous pouvez utiliser la tranche d'appel de bien limiter la portée d'une requête et vous pourriez réutiliser efficacement il.

Exemple:
```
window_size = 10  # or whatever limit you like
window_idx = 0
while True:
    start,stop = window_size*window_idx, window_size*(window_idx+1)
    things = query.slice(start, stop).all()
    if things is None:
        break
    for thing in things:
        analyze(thing)
    if len(things) < window_size:
        break
    window_idx += 1
```
- Cela semble très simple et rapide. Je ne suis pas sûr de la .all() est nécessaire. Je remarque la vitesse est beaucoup amélioré après le 1er appel.
- Je me rends compte que c'est un vieux commentaire si juste de le laisser pour la postérité. Sans .all() les choses variable est une requête qui ne prend pas en charge len()
InformationsquelleAutor Joel
7

Je ne suis pas un expert base de données, mais lors de l'utilisation de SQLAlchemy comme un simple Python couche d'abstraction (c'est à dire, ne pas utiliser l'ORM objet de Requête) je suis venu avec une solution de satisfaction à la requête de 300 m à la ligne de la table sans faire exploser l'utilisation de la mémoire...

Ici est un mannequin exemple:
```
from sqlalchemy import create_engine, select

conn = create_engine("DB URL...").connect()
q = select([huge_table])

proxy = conn.execution_options(stream_results=True).execute(q)
```
Ensuite, j'utilise la SQLAlchemy fetchmany() méthode d'itération sur les résultats dans un while boucle:
```
empty = False
while not empty:
    batch = proxy.fetchmany(100000)  # 100,000 rows at a time

    if not batch:
        empty = True

    for row in batch:
        # Do your stuff here...

proxy.close()
```
Cette méthode m'a permis de faire toute sorte de l'agrégation de données sans aucune dangereux surcharge de la mémoire.

NOTE la stream_results fonctionne avec Postgres et la pyscopg2 adaptateur, mais je suppose que ça ne marchera pas avec tout DBAPI, ni avec n'importe quel pilote de base de données...

Il y a un intéressant cas d'utilisation dans ce post de blog qui a inspiré ma méthode ci-dessus.
- Si l'on travaille sur postgres ou mysql (avec pymysql), ce qui devrait être la accepté de répondre à mon humble avis.
InformationsquelleAutor edouardtheron

Dans l'esprit de Joel réponse, j'utilise la suite:

WINDOW_SIZE = 1000
def qgen(query):
    start = 0
    while True:
        stop = start + WINDOW_SIZE
        things = query.slice(start, stop).all()
        if things is None:
            break
        for thing in things:
            yield(thing)
        start += WINDOW_SIZE

InformationsquelleAutor

2

Autant que je sache, la première variante obtient encore de tous les tuples de la table (avec une requête SQL) mais qui construit l'ORM de présentation pour chaque entité lors de l'itération. Il est donc plus efficace que la construction d'une liste de toutes les entités avant l'itération, mais vous avez encore pour récupérer toutes les (premières) les données en mémoire.

Ainsi, à l'aide de LIMITE sur d'immenses tables sonne comme une bonne idée pour moi.

InformationsquelleAutor Pankrat
2

Utiliser LIMIT/OFFSET est mauvais, parce que vous devez trouver tous {OFFSET} colonnes avant, de sorte que le plus grand est le DÉCALAGE le plus de demande que vous obtenez.
À l'aide fenêtre de requête pour moi aussi, donne de mauvais résultats sur une grande table avec une grande quantité de données (vous attendre d'abord les résultats pour trop longtemps, qu'il n'est pas bon dans mon cas, pour les fragments de réponse web).

Meilleure approche présentée ici https://stackoverflow.com/a/27169302/450103. Dans mon cas, j'ai résolu le problème tout simplement en utilisant l'index sur le champ de date /heure et de l'extraction de la prochaine requête avec datetime>=previous_datetime. Stupide, parce que j'ai utilisé cet indice dans les différents cas avant, mais la pensée que pour la récupération de toutes les données de la fenêtre de requête serait mieux. Dans mon cas, j'ai eu tort.

InformationsquelleAutor Victor Gavro

Vous devez vous connecter pour publier un commentaire.