Python backref lazy='；动态'；-不支持对象填充-无法应用即时加载

如何在指定的两个日期之间进行

预订

以获得

飞机

。我需要过滤

预订

，仅当它们在两个日期之间时才包括在内。我尝试了此操作，但出现错误：

“Plane.bookings”不支持对象填充-无法应用即时加载。

为什么会发生此错误？如何修复

planes = (db.session.query(Plane)
             .join(Booking)
             .filter(Booking.start_date >= date)
             .options(contains_eager(Plane.bookings)))

模型：

class Booking(db.Model):
        id = db.Column(db.Integer, primary_key=True)
        start_date = db.Column(db.DateTime)
        end_date = db.Column(db.DateTime)

        person_id = db.Column(db.Integer, db.ForeignKey('person.id'))
        person = db.relationship('Person', foreign_keys=[person_id], backref=db.backref('bookings', lazy='dynamic'))

        instructor_id = db.Column(db.Integer, db.ForeignKey('person.id'))
        instructor = db.relationship('Person', foreign_keys=[instructor_id], backref=db.backref('instructor_bookings', lazy='dynamic'))

        plane_id = db.Column(db.Integer, db.ForeignKey('plane.id'))
        plane = db.relationship('Plane', backref=db.backref('bookings', lazy='dynamic'))

        def __init__(self, start_date, end_date, plane_id, instructor_id, person_id):
            self.start_date = start_date
            self.end_date = end_date
            self.plane_id = plane_id
            self.instructor_id = instructor_id
            self.person_id = person_id

        def __repr__(self):
            return '<Booking... %r>'

        def as_dict(self):
           return {c.name: getattr(self, c.name) for c in self.__table__.columns}


    class Plane(db.Model):
        id = db.Column(db.Integer, primary_key=True)
        name = db.Column(db.String(80))
        description = db.Column(db.String(120))

        def __init__(self, name, description):
            self.name = name
            self.description = description

        def __repr__(self):
            return '<Plane... %r>'

        def as_dict(self):
           return {c.name: getattr(self, c.name) for c in self.__table__.columns}

班级预订（db.Model）：
id=db.Column（db.Integer，主键=True）
开始日期=db.Column（db.DateTime）
end_date=db.Column（db.DateTime）
person\u id=db.Column（db.Integer，db.ForeignKey（'person.id'））
person=db.relationship（'person'，外键=[person\u id]，backref=db.backref（'bookings'，lazy='dynamic'））
讲师id=db.Column（db.Integer，db.ForeignKey（'person.id'））
讲师=db.relationship（'Person'，外键=[讲师id]，backref=db.backref（'讲师预订'，lazy='dynamic'））
平面id=db.Column（db.Integer，db.ForeignKey（'plane.id'））
plane=db.relationship（'plane'，backref=db.backref（'bookings'，lazy='dynamic'））
定义初始日期（自我、开始日期、结束日期、飞机id、教员id、人员id）：
self.start\u date=开始日期
self.end\u日期=end\u日期
self.plane\u id=plane\u id
self.讲师\u id=讲师\u id
self.person\u id=person\u id
定义报告（自我）：
返回“”
定义为（自身）：
返回{c.name:getattr（self，c.name），用于self中的c。_table__.columns}
类平面（数据库模型）：
id=db.Column（db.Integer，主键=True）
name=db.Column（db.String（80））
description=db.Column（db.String（120））
定义初始化（自我、姓名、描述）：
self.name=名称
self.description=描述
定义报告（自我）：
返回“”
定义为（自身）：
返回{c.name:getattr（self，c.name），用于self中的c。_table__.columns}

错误消息准确地告诉您“错误”是什么：无法加载

惰性class='dynamic'

关系。动态关系生成新查询，而不是集合（列表）。预加载动态关系是没有意义的，因为动态关系的整个要点是能够构造其他查询

访问预订时，使用动态关系过滤预订。这不是很理想，因为它需要对每个飞机进行查询才能获得预订

planes = Plane.query.join(Plane.bookings).filter(Booking.start_date >= date)
for plane in planes:
    bookings = plane.bookings.filter(Booking.start_date >= date)

更有可能的是，你想要一种非动态的关系。只需从关系的backref中删除

lazy='dynamic'

。如果为已筛选的联接传递

contains\u eager

，则生成的集合将只包含筛选的项

plane = db.relationship(lambda: Plane, backref='bookings')
# ...
planes = Plane.query.join(Plane.bookings
).filter(Booking.start_date >= date
).options(db.contains_eager(Plane.bookings))

还要注意的是，没有什么可以阻止您定义同一集合的两个关系，一个是动态的，另一个是非动态的，使用您当时所做的事情所需要的关系