Mysql 如何填充sqlalchemy列'；自动取值

我正在处理电子商务应用程序的数据库，我使用SQLAlchemy在

Order

表（父项）和

OrderItem

表（子项）之间建立了一对多关系

数据库：

class Order(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    customer_id = db.Column(db.Integer, db.ForeignKey('customer.id'), nullable=False)
    total = db.Column(db.Integer, nullable=False)
    submitted_on = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
    delivery_charges = db.Column(db.Integer, nullable=False)
    sub_total = db.Column(db.Integer, nullable=False)  # needs to be calculated automatically
    total_quantity = db.Column(db.Integer, nullable=False)  # needs to be calculated automatically
    order_items = db.relationship('OrderItem', backref='order', lazy=True)

    def __init__(self, customer_id, delivery_charges, sub_total, total_quantity):
        self.customer_id = customer_id
        self.delivery_charges = delivery_charges
        self.sub_total = sub_total
        self.total_quantity = total_quantity
        self.total = delivery_charges + sub_total


class OrderItem(db.Model):
    __tablename__ = "order_item"
    id = db.Column(db.Integer, primary_key=True)
    order_id = db.Column(db.Integer, db.ForeignKey('order.id'), nullable=False)
    product_size_color_id = db.Column(db.Integer, db.ForeignKey('product_size_color.id'), nullable=False)
    sale_id = db.Column(db.Integer, db.ForeignKey('sale.id'), nullable=True, default=None)
    selling_price = db.Column(db.Integer, nullable=False)  # needs to be calculated automatically
    quantity = db.Column(db.Integer, nullable=False)

我想做的是：我希望根据其他表的值自动计算某些列，例如：

-

Order.total\u quantity

：与相同的

Order

实例相对应的每个

Order\u项目的数量之和

-
Order.sub\u total
：与同一
订单
实例相对应的每个
订单项目.售价
的总和

-
订购商品。售价
：

我使用了
default
来自动获取一些列，就像
中的顺序一样。在
上提交，并在class
Order
中使用
函数来计算
顺序。中回答的total
值，但是，这两种方法只有在值与类/表本身在一起时才起作用，我的问题是：如何根据其他表的值自动设置列的值

我在列
Order.total_quantity
上尝试了以下代码，它在列中填充了零

    def __init__(self, customer_id, delivery_charges, sub_total):
        self.customer_id = customer_id
        self.delivery_charges = delivery_charges
        self.sub_total = sub_total
        order_items = self.order_items
        self.total_quantity = sum([i.quantity for i in order_items])
        self.total = delivery_charges + sub_total

我想做的事可能吗？如何操作？
问题在于，当您初始化
订单
对象时，还没有关联的
订单项目
。你不可能创建任何，除非你猜什么是
order\u id
，这看起来很危险。与其在init上运行，为什么不在添加所有项目后运行updatequantity方法呢

例如：

class Order(Model):
    # your code as-is

    def update_total(self):
        self.total_quantity = sum([i.quantity for i in self.order_items])
        self.total = self.delivery_charges + self.sub_total

该方法正是您已经提出的，就在
\uuuu init\uuuu
之外，因为您需要在添加项目后调用它。事实上，我只需要将您的
\uuuu init\uuuuu
全部删除，这样您就可以随时更改总数（假设您需要在创建订单之后但在结束之前向订单添加一个项目），然后调用
update\u total（）
，以使所有内容都最新

您也可以考虑创建一个方法来添加一个项目，并使用它同时添加一个项目并同时更新汇总。您可以使用它来自动计算任何数量的项目类型（我假设为ProductSizeColor）的价格。我称之为“line_total”，但你可以使用任何对你有意义的东西
class OrderItem(Model):
    __tablename__ = 'order_item'
    id = Column(Integer, primary_key=True)
    order_id = Column(Integer, ForeignKey('order.id'))
    product_size_color_id = Column(Integer, ForeignKey('product_size_color.id'))
    product_size_color = relationship('ProductSizeColor')
    # would it make more sense for the sale to be associated with the order
    # instead of the order item?
    sale_id = Column(Integer, ForeignKey('sale.id'))
    quantity = Column(Integer)
    line_total = Column(Integer)

class Order(Model):
    # other code

    def update_total(self):
        self.total_quantity = sum([i.quantity for i in self.order_items])
        self.sub_total = sum([i.line_total for i in self.order_items])
        self.total = self.delivery_charges + self.sub_total

    def add_item(self, session, psi_id, quantity):
        s = session
        order_item = OrderItem(
            order_id = self.id,
            product_size_color_id = psi_id,
            quantity = quantity
        )
        s.add(order_item)
        line_total = order_item.product_size_color.selling_price * quantity
        order_item.line_total = line_total
        self.update_total()

然后实时：

s = session()
order = Order(customer_id=customer_id, delivery_charges=delivery_charges,
              sub_total=sub_total)
s.add(order)
order.add_item(s, 1, 10)
order.add_item(s, 2, 8)
s.commit()

我们刚刚添加了10个ProductSizeColor编号1和8个ProductSizeColor编号2，并更新了项目总数、每个产品的总数以及整个订单的总数。
问题是，当您初始化
订单
对象时，还没有关联的
订单
项目。你不可能创建任何，除非你猜什么是
order\u id
，这看起来很危险。与其在init上运行，为什么不在添加所有项目后运行updatequantity方法呢

例如：

class Order(Model):
    # your code as-is

    def update_total(self):
        self.total_quantity = sum([i.quantity for i in self.order_items])
        self.total = self.delivery_charges + self.sub_total

该方法正是您已经提出的，就在
\uuuu init\uuuu
之外，因为您需要在添加项目后调用它。事实上，我只需要将您的
\uuuu init\uuuuu
全部删除，这样您就可以随时更改总数（假设您需要在创建订单之后但在结束之前向订单添加一个项目），然后调用
update\u total（）
，以使所有内容都最新

您也可以考虑创建一个方法来添加一个项目，并使用它同时添加一个项目并同时更新汇总。您可以使用它来自动计算任何数量的项目类型（我假设为ProductSizeColor）的价格。我称之为“line_total”，但你可以使用任何对你有意义的东西
class OrderItem(Model):
    __tablename__ = 'order_item'
    id = Column(Integer, primary_key=True)
    order_id = Column(Integer, ForeignKey('order.id'))
    product_size_color_id = Column(Integer, ForeignKey('product_size_color.id'))
    product_size_color = relationship('ProductSizeColor')
    # would it make more sense for the sale to be associated with the order
    # instead of the order item?
    sale_id = Column(Integer, ForeignKey('sale.id'))
    quantity = Column(Integer)
    line_total = Column(Integer)

class Order(Model):
    # other code

    def update_total(self):
        self.total_quantity = sum([i.quantity for i in self.order_items])
        self.sub_total = sum([i.line_total for i in self.order_items])
        self.total = self.delivery_charges + self.sub_total

    def add_item(self, session, psi_id, quantity):
        s = session
        order_item = OrderItem(
            order_id = self.id,
            product_size_color_id = psi_id,
            quantity = quantity
        )
        s.add(order_item)
        line_total = order_item.product_size_color.selling_price * quantity
        order_item.line_total = line_total
        self.update_total()

然后实时：

s = session()
order = Order(customer_id=customer_id, delivery_charges=delivery_charges,
              sub_total=sub_total)
s.add(order)
order.add_item(s, 1, 10)
order.add_item(s, 2, 8)
s.commit()

我们刚刚添加了10个ProductSizeColor编号1和8个ProductSizeColor编号2，并更新了项目总数、每个产品的总数以及整个订单的总数。
小心使用
datetime.datetime.utcnow
或
datetime.datetime.now
作为默认时间，因为在提交对数据库的更改之前，它不会进行计算。如果您使用的是事务管理器，这不会有什么大不了的，而且可能也不会有什么大不了的，但这是需要注意的。请小心使用
datetime.datetime.utcnow
或
datetime.datetime.now
作为默认时间，因为它在将更改提交到数据库之前不会计算。如果您使用的是事务管理器，这不会有什么大不了的，也可能没有什么大不了的，但这是需要注意的。谢谢您，请给我演示一下
update\u quantity
方法的实现。上面的更新示例。这是我一直在寻找的所有内容，甚至更多，非常感谢：）谢谢，请，你能给我展示一下
update\u quantity
方法的实现吗？上面的更新示例。这是我一直在寻找的所有内容，甚至更多，非常感谢：）