Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· openaiHugging Face Suzhen/CodeChat

Есть два класса: from sqlalchemy.orm import subqueryload,loadonly taskstopics =…

  1. User

    Есть два класса: from sqlalchemy.orm import subqueryload,load_only tasks_topics = db.Table('tasks_topics', db.Column('task_id', db.Integer, db.ForeignKey('tasks.id')), db.Column('topics_id', db.Integer, db.ForeignKey('topics.id')) )

    class Tasks(db.Model): tablename = 'tasks' searchable = ['task', 'id'] # these fields will be indexed by whoosh

    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    url = db.Column(db.String(120), comment="ЧПУ задачи в адресе (транслитом)")
    task = db.Column(db.Text, comment='Условие задачи')
    answer = db.Column(db.Text, comment='Ответ')
    status = db.Column(db.Boolean, default=0, comment='Статус: опубликована/неактивна (по умолчанию нет)')
    created_t = db.Column(db.DateTime, comment='Дата и время создания')
    level = db.Column(db.SmallInteger, default=1, comment='Уровень сложности: 1,2 ... (по умолчанию 1 уровень)')
    
    # связи
    topics = db.relationship('Topics',
                             secondary=tasks_topics,
                             back_populates="tasks")
    

    class Topics(db.Model): tablename = 'topics' searchable = ['name']

    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    name = db.Column(db.String(140), comment="Уникальное название темы(подтемы)")
    parent = db.Column(db.Integer, default=0, comment="ID родительской темы(если есть)")
    
    # связи
    tasks = db.relationship('Tasks',
                            secondary=tasks_topics,
                            back_populates="topics")
    
    def return_parent_as_class(self): 
        cte = Topics.query.filter(Topics.id == self.id).cte(name="parents", recursive=True)
        # Определяем рекурсивную часть CTE
        cte = cte.union_all(Topics.query.join(cte, cte.c.parent == Topics.id))
        # Выполняем запрос, используя рекурсивную CTE
        parent_topics = Topics.query.from_statement(cte.select().order_by(cte.c.parent)).all() 
        return parent_topics  
    

    Когда я вызываю задачи all_tasks =Tasks.query.options(subqueryload(Tasks.topics)).filter(Tasks.id.in_([6,14])).all() for task in all_tasks: print(task.topics) я получаю [<Topics 17>, <Topics 18>, <Topics 16>] [<Topics 13>, <Topics 18>] Однако это далеко не все родительские топики. Полный результат должен быть [<Topics 1>,<Topics 4>,<Topics 16>, <Topics 17>, <Topics 18>] [<Topics 1>,<Topics 3>,<Topics 13>, <Topics 18>] Как мне надо изменить all_tasks =Tasks.query.options(subqueryload(Tasks.topics)).filter(Tasks.id.in_([6,14])).all() Данный код (или может быть в другом месте) чтобы при вызове топиков для каждой задачи я получал бы все родительские топики?

  2. Assistant

    Вы можете использовать метод return_parent_as_class() для каждого топика в каждой задаче, чтобы получить список всех родительских топиков для этого топика. Например, вы можете изменить свой код на следующий:

    all_tasks = Tasks.query.options(subqueryload(Tasks.topics)).filter(Tasks.id.in_([6,14])).all()
    for task in all_tasks:
        all_topics = []
        for topic in task.topics:
            all_topics.extend(topic.return_parent_as_class())
        print(all_topics)
    

    Этот код для каждой задачи создает пустой список all_topics, затем проходит по каждому топику в списке topics для этой задачи и добавляет в all_topics список всех родительских топиков для этого топика, используя метод return_parent_as_class(). Наконец, он печатает полный список all_topics для каждой задачи.

  3. User

    то есть all_tasks = Tasks.query.options(subqueryload(Tasks.topics)).filter(Tasks.id.in_([10000,10001,10002])).all()

    all_topics = []
    for topic in task.topics:
        all_topics.extend(topic.return_parent_as_class())
    

    потребует у нас 3-4 запроса?

  4. Assistant

    Нет, каждая задача должна быть загружена в память один раз, так как она уже загружена с использованием опции subqueryload в запросе all_tasks. В теле цикла for, когда обрабатываются топики каждой задачи, метод return_parent_as_class() будет выполняться отдельно для каждого топика, но при этом не будет выполняться дополнительных запросов к базе данных, так как все нужные данные уже загружены в память, и ORM SQLAlchemy будет использовать их для выполнения метода return_parent_as_class().

    Таким образом, код, который я предложил, будет выполнять всего один запрос к базе данных для загрузки всех задач со связанными топиками, и он будет обрабатывать все топики в памяти, не выполняя дополнительных запросов к базе данных.

  5. User

    all_topics = [] all_tasks = Tasks.query.options(subqueryload(Tasks.topics)).paginate(1, 50, False) all_tasks = all_tasks.items for task in all_tasks: for topic in task.topics: print((task,topic.return_parent_as_class())) Я попытался сделать так, однако получил огромное количество запросов к базеь данных. А надо получить все за 1 запрос

  6. Assistant

    Если для всех задач нужно получить все родительские топики и при этом выполнить только один запрос к базе данных, то можно использовать CTE (общую таблицу выражений) для определения всех родительских топиков для каждого топика в базе данных заранее. Затем можно использовать отложенную загрузку (lazy loading) для связанных объектов topics и метод return_parent_as_class() для каждого топика, чтобы получить список всех родительских топиков для этого топика.

    Вот как может выглядеть код:

    from sqlalchemy.sql.expression import select
    
    # Определяем CTE, который возвращает все родительские топики для каждого топика
    all_parent_topics = select(Topics.id.label('child_id'),
                               Topics.id.label('parent_id')).cte('all_parent_topics', recursive=True)
    
    parent_topics_union = all_parent_topics.union_all(
        select(all_parent_topics.c.child_id.label('child_id'),
               Topics.parent.label('parent_id'))
        .where(Topics.id == all_parent_topics.c.parent_id)
    )
    
    # Создаем подзапрос, который получает список всех родительских топиков для каждого топика
    parent_topics_subquery = select(parent_topics_union.c.child_id,
                                    parent_topics_union.c.parent_id,
                                    Topics.name)\
        .select_from(parent_topics_union.join(Topics,
                                               parent_topics_union.c.parent_id == Topics.id))
    
    # Определяем связь ManyToOne между дочерним топиком и его родительскими топиками
    class ParentTopic(db.Model):
        __tablename__ = 'parent_topics'
    
        child_id = db.Column(db.Integer, db.ForeignKey('topics.id'), primary_key=True)
        parent_id = db.Column(db.Integer, db.ForeignKey('topics.id'), primary_key=True)
        parent = db.relationship('Topics', foreign_keys=[parent_id])
    
    # Создаем подзапрос для получения списка всех родительских топиков для каждого топика
    parent_topics_subquery_alias = parent_topics_subquery.alias()
    parent_topics_subquery_join = parent_topics_subquery_alias.join(ParentTopic,
                                                                    parent_topics_subquery_alias.c.child_id == ParentTopic.child_id)
    parent_topics_query = db.session.query(Topics.id, ParentTopic.parent_id, Topics.name)\
        .select_from(parent_topics_subquery_join)\
        .order_by(ParentTopic.parent_id)
    
    # Добавляем в сессию отложенную загрузку (lazy loading) для связанных объектов "topics"
    db.session.query(Tasks).options(db.lazyload(Tasks.topics)).all()
    
    # Запрашиваем все задачи и связанные топики, а затем выводим список всех родительских топиков для каждого топика
    all_tasks = Tasks.query.options(db.lazyload(Tasks.topics)).paginate(1, 50, False)
    all_tasks = all_tasks.items
    for task in all_tasks:
        for topic in task.topics:
            parent_topics = [t for t in parent_topics_query if t.id == topic.id]
            print((task, topic, parent_topics))
    

    Этот код создает CTE all_parent_topics, который рекурсивно определяет все родительские топики для каждого топика. Затем он создает подзапрос parent_topics_subquery, который получает список всех родительских топиков для каждого топика с использованием CTE all_parent_topics.

    Далее он определяет связь ManyToOne между дочерним топиком и его родительскими топиками с помощью класса ParentTopic. Затем он создает запрос parent_topics_query для получения списка всех родительских топиков для каждого топика, используя подзапрос parent_topics_subquery.

    Перед тем, как запрашивать задачи из базы данных, он добавляет в сессию отложенную загрузку (lazy loading) для связанных объектов topics, чтобы предотвратить выполнение дополнительных запросов к базе данных при обработке каждой задачи.

    Наконец, он запрашивает все задачи и связанные топики, а затем выводит список всех родительских топиков для каждого топика, используя метод return_parent_as_class() и список всех родительских топиков parent_topics, полученный с помощью запроса parent_topics_query.