es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Lectura de datos en fragmentos utilizando SQLAlchemy.

04 Jun, 2023 Programación

Tengo un bloque de código que se ve así,

entities = self.session.query(Entities).filter(Entities.parent_id == 0)

index_data = {}
for entity in entities:
data = entity.dict
data['addresses'] = [address.dict for address in entity.addresses]
data['relationships'] = [relationship.dict for relationship in entity.relationships_parent]
index_data[data['id']] = data

Estoy tratando de leer los datos, procesarlos un poco como se muestra arriba y almacenarlos en la base de datos NoSQL (solo he dado la parte de lectura aquí).

Me di cuenta de que este bucle tarda mucho tiempo en completarse. ¿Sospecho que se debe a la cantidad de datos que leo con la primera línea de código? ¿Quizás en términos de retrasos en la red? Porque la utilización de memoria aquí está bien.

Necesito una solución utilizando código SQLAlchemy.

Estoy pensando que tal vez esto podría resolverse leyendo los datos en trozos? ¿Cómo puedo hacer esto? Si el problema es algo más, ¿cómo puedo solucionarlo?

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para abordar el problema de que el bucle tarda mucho tiempo, puedes intentar leer los datos en fragmentos en lugar de hacerlo todo a la vez. Esto se puede lograr utilizando el método yield_per de SQLAlchemy.

    Aquí hay un ejemplo de cómo leer los datos en fragmentos:

    chunk_size = 1000
entities = self.session.query(Entities).filter(Entities.parent_id == 0).yield_per(chunk_size)

for entity in entities:
    data = entity.__dict__
    data['addresses'] = [address.__dict__ for address in entity.addresses]
    data['relationships'] = [relationship.__dict__ for relationship in entity.relationships_parent]
    index_data[data['id']] = data

    En el código anterior, usamos yield_per para leer los datos en fragmentos de 1000. Esto significa que solo se leerán 1000 filas de la base de datos a la vez, lo que puede reducir significativamente el tiempo necesario para leer los datos.

    Si el problema no se debe a retrasos en la red, también puedes intentar optimizar tu código. Una forma de hacerlo es evitar el uso del atributo __dict__, que puede ser lento para conjuntos de datos grandes. En su lugar, puedes usar orm.attributes.instance_dict, que es más rápido y eficiente. Aquí hay un ejemplo:

    chunk_size = 1000
entities = self.session.query(Entities).filter(Entities.parent_id == 0).yield_per(chunk_size)

for entity in entities:
    data = orm.attributes.instance_dict(entity)
    data['addresses'] = [orm.attributes.instance_dict(address) for address in entity.addresses]
    data['relationships'] = [orm.attributes.instance_dict(relationship) for relationship in entity.relationships_parent]
    index_data[data['id']] = data

    En el código anterior, usamos orm.attributes.instance_dict para obtener el diccionario de instancia de cada objeto en lugar de usar __dict__. Esto debería ser más rápido y eficiente, especialmente para conjuntos de datos grandes.

Comments are closed.