Creating Computed Fields in Odoo: Dynamic Data Without Database Storage

class SaleOrder(models.Model):
    _inherit = 'sale.order'
    
    # Regular field (stored)
    amount_subtotal = fields.Float()
    
    # Computed field (not stored)
    amount_tax = fields.Float(
        compute='_compute_amount_tax'  # Method that calculates it
    )
    
    @api.depends('amount_subtotal')  # Triggers when this field changes
    def _compute_amount_tax(self):
        """Calculate tax based on subtotal."""
        for order in self:
            # Tax = 8% of subtotal
            order.amount_tax = order.amount_subtotal * 0.08

class Product(models.Model):
    _inherit = 'product.product'
    
    # Non-stored: Calculated real-time, not searched
    # (Changes based on current date, so can't store)
    days_until_expiry = fields.Integer(
        compute='_compute_days_until_expiry',
        store=False  # Can't store (depends on today's date)
    )
    
    # Stored: Calculated once, used in reports/filters
    # (Profit margin is stable, frequently accessed)
    profit_margin_pct = fields.Float(
        compute='_compute_profit_margin',
        store=True  # Store (stable value, often searched)
    )
    
    @api.depends('expiry_date')
    def _compute_days_until_expiry(self):
        from datetime import date
        for product in self:
            if product.expiry_date:
                days = (product.expiry_date - date.today()).days
                product.days_until_expiry = days
            else:
                product.days_until_expiry = 0
    
    @api.depends('cost', 'list_price')
    def _compute_profit_margin(self):
        for product in self:
            if product.list_price > 0:
                margin = ((product.list_price - product.cost) / product.list_price) * 100
                product.profit_margin_pct = margin
            else:
                product.profit_margin_pct = 0

# ❌ WRONG - Missing @api.depends
def _compute_profit(self):
    """Calculate profit."""
    for order in self:
        order.profit = order.amount_total - order.amount_cost

# ✅ RIGHT - Declares dependencies
@api.depends('amount_total', 'amount_cost')
def _compute_profit(self):
    """Calculate profit."""
    for order in self:
        order.profit = order.amount_total - order.amount_cost

@api.depends(
    'order_line.product_id.cost',      # Cost from product
    'order_line.product_qty',           # Qty on line
    'order_line.price_unit',            # Price on line
)
def _compute_total_profit(self):
    """Calculate total profit for order."""
    for order in self:
        total_profit = 0
        for line in order.order_line:
            line_profit = (line.price_unit - line.product_id.cost) * line.product_qty
            total_profit += line_profit
        order.total_profit = total_profit

class SaleOrder(models.Model):
    _inherit = 'sale.order'
    
    subtotal = fields.Float()
    discount_percent = fields.Float()
    
    # Computed field: discount in dollars
    discount_amount = fields.Float(
        compute='_compute_discount_amount',
        inverse='_inverse_discount_amount',  # Handle edits
        store=True
    )
    
    @api.depends('subtotal', 'discount_percent')
    def _compute_discount_amount(self):
        """Calculate discount in dollars."""
        for order in self:
            order.discount_amount = order.subtotal * (order.discount_percent / 100)
    
    def _inverse_discount_amount(self):
        """Handle when user edits discount_amount directly."""
        for order in self:
            if order.subtotal > 0:
                # Back-calculate discount_percent from discount_amount
                order.discount_percent = (order.discount_amount / order.subtotal) * 100
            else:
                order.discount_percent = 0

# ❌ SLOW - Searches inside compute
@api.depends('order_line')
def _compute_customer_ltv(self):
    for order in self:
        # THIS SEARCHES 1,000 times for 1,000 orders!
        all_orders = self.env['sale.order'].search([
            ('partner_id', '=', order.partner_id.id)
        ])
        order.customer_ltv = sum(o.total for o in all_orders)

# ✅ FAST - Search once, reuse
def _compute_customer_ltv(self):
    # Fetch all data at once
    all_orders_by_customer = {}
    all_orders = self.env['sale.order'].search([
        ('partner_id', 'in', self.mapped('partner_id').ids)
    ])
    
    for order in all_orders:
        customer_id = order.partner_id.id
        if customer_id not in all_orders_by_customer:
            all_orders_by_customer[customer_id] = []
        all_orders_by_customer[customer_id].append(order)
    
    # Now use cached data
    for order in self:
        orders = all_orders_by_customer.get(order.partner_id.id, [])
        order.customer_ltv = sum(o.total for o in orders)

# ✓ USE store=True when:
# - Computed frequently in reports
# - Filtered/searched in lists
# - Performance-critical
# - Value is relatively stable
profit_margin = fields.Float(
    compute='_compute_profit_margin',
    store=True  # Frequently used
)

# ✗ AVOID store=True when:
# - Depends on current date/time
# - Depends on too many fields
# - Expensive to compute
# - Rarely accessed
days_until_expiry = fields.Integer(
    compute='_compute_days',
    store=False  # Depends on today
)