Database Migration in Odoo 18: Complete Pre & Post Migration Guide

-- List all registered models in the database
SELECT DISTINCT model 
FROM ir_model 
ORDER BY model;

-- Compare with installed modules
SELECT m.model, m.name, md.name as module
FROM ir_model m
JOIN ir_model_data md ON md.res_id = m.id 
    AND md.model = 'ir.model'
ORDER BY md.name, m.model;

-- List all fields for a specific model
SELECT f.name as field_name, 
       f.ttype as field_type,
       f.store as is_stored,
       f.compute as compute_method,
       f.related as related_field
FROM ir_model_fields f
JOIN ir_model m ON f.model_id = m.id
WHERE m.model = 'sale.order'
ORDER BY f.name;

-- Find fields that might need migration attention
SELECT f.name, f.ttype, m.model
FROM ir_model_fields f
JOIN ir_model m ON f.model_id = m.id
WHERE f.ttype IN ('char', 'text', 'selection')
ORDER BY m.model, f.name;

-- Example: Converting varchar to jsonb for account codes
-- Step 1: Add the new column
ALTER TABLE account_account 
ADD COLUMN IF NOT EXISTS code_store jsonb;

-- Step 2: Migrate data with proper JSON structure
UPDATE account_account 
SET code_store = jsonb_build_object(
    COALESCE(company_id::text, '1'), 
    code
)
WHERE code IS NOT NULL AND code_store IS NULL;

-- Step 3: Verify the conversion
SELECT id, code, code_store, company_id 
FROM account_account 
LIMIT 10;

# migrations/18.0.1.0/post-migrate.py
from odoo import api, SUPERUSER_ID
import logging

_logger = logging.getLogger(__name__)

def migrate(cr, version):
    """Post-migration script for Odoo 18 upgrade."""
    env = api.Environment(cr, SUPERUSER_ID, {})
    
    _logger.info("Starting post-migration computed field population")
    
    # Recompute sale order totals
    recompute_sale_order_fields(env)
    
    # Recompute invoice amounts
    recompute_invoice_fields(env)
    
    # Recompute stock quantities
    recompute_stock_fields(env)
    
    # Validate and fix user access rights
    validate_user_access(env)
    
    _logger.info("Post-migration completed successfully")


def recompute_sale_order_fields(env):
    """Recompute all computed fields on sale orders."""
    SaleOrder = env['sale.order']
    
    # Find orders that need recomputation
    orders = SaleOrder.search([('state', '!=', 'cancel')])
    
    _logger.info("Recomputing %d sale orders", len(orders))
    
    # Trigger recomputation in batches
    batch_size = 100
    for i in range(0, len(orders), batch_size):
        batch = orders[i:i + batch_size]
        
        # Force recomputation of amount fields
        for order in batch:
            order._compute_amounts()
        
        # Commit each batch
        env.cr.commit()
        _logger.info("Processed sale orders %d-%d", i, min(i + batch_size, len(orders)))


def recompute_invoice_fields(env):
    """Recompute invoice amounts and status fields."""
    Invoice = env['account.move']
    
    invoices = Invoice.search([
        ('move_type', 'in', ['out_invoice', 'out_refund', 'in_invoice', 'in_refund']),
        ('state', '!=', 'cancel')
    ])
    
    _logger.info("Recomputing %d invoices", len(invoices))
    
    batch_size = 50
    for i in range(0, len(invoices), batch_size):
        batch = invoices[i:i + batch_size]
        
        for invoice in batch:
            invoice._compute_amount()
            invoice._compute_payments_widget_reconciled_info()
        
        env.cr.commit()


def recompute_stock_fields(env):
    """Recompute stock quantities and valuations."""
    Product = env['product.product']
    
    products = Product.search([('type', '=', 'product')])
    
    _logger.info("Recomputing stock for %d products", len(products))
    
    # Trigger quantity computation
    for product in products:
        product._compute_quantities()
    
    env.cr.commit()


def validate_user_access(env):
    """Validate user access rights after migration."""
    User = env['res.users']
    
    # Check for users with invalid group assignments
    users = User.search([('active', '=', True)])
    
    for user in users:
        # Ensure base group assignments are valid
        if not user.has_group('base.group_user'):
            user.write({'groups_id': [(4, env.ref('base.group_user').id)]})
            _logger.warning("Fixed missing base group for user: %s", user.login)

-- Find all custom views (not from base Odoo)
SELECT v.id, v.name, v.model, v.type, md.module
FROM ir_ui_view v
JOIN ir_model_data md ON md.res_id = v.id 
    AND md.model = 'ir.ui.view'
WHERE md.module NOT IN (
    'base', 'sale', 'purchase', 'account', 'stock',
    'crm', 'hr', 'project', 'website', 'mail'
    -- Add other standard Odoo modules
)
ORDER BY md.module, v.model;

-- Find views that reference potentially problematic fields
SELECT v.name, v.model, v.arch_db
FROM ir_ui_view v
WHERE v.arch_db LIKE '%field_name_that_changed%';

# scripts/validate_views.py
def validate_views(env):
    """Validate all views render without errors."""
    View = env['ir.ui.view']
    
    views = View.search([('type', 'in', ['form', 'tree', 'kanban', 'search'])])
    
    errors = []
    for view in views:
        try:
            # Attempt to read the combined view
            env[view.model].get_view(view.id, view.type)
        except Exception as e:
            errors.append({
                'view_id': view.id,
                'view_name': view.name,
                'model': view.model,
                'error': str(e)
            })
    
    return errors

-- List all active scheduled actions
SELECT name, model_id, state, interval_number, interval_type, nextcall
FROM ir_cron
WHERE active = true
ORDER BY nextcall;

-- List all active automated actions
SELECT name, model_id, trigger, state
FROM base_automation
WHERE active = true
ORDER BY name;