Tengo el siguiente problema al usar Django con MySQL 5.5.22.

Dada una tabla con columnas id, nivel y una matriz 2x2 almacenada como a11, a12, a21, a22, tengo esta fila:

id   a11   a12   a21   a22   level
324  3     2     5     3     2

Dado un queryset qs, hago la siguiente actualización:

qs.update(
    a11=(b12 * a21 - b11 * a22) * F('a11') + (b11 * a12 - b12 * a11) * F('a21'),
    a12=(b12 * a21 - b11 * a22) * F('a12') + (b11 * a12 - b12 * a11) * F('a22'),
    a21=(b22 * a21 - b21 * a22) * F('a11') + (b21 * a12 - b22 * a11) * F('a21'),
    a22=(b22 * a21 - b21 * a22) * F('a12') + (b21 * a12 - b22 * a11) * F('a22'),
    level=(F('level') - 1)
    )

Para lo que django genera la siguiente consulta (la obtuve de db.connection.queries, elimine la cláusula where por brevedad):

UPDATE `storage` 
SET 
`a21` = (3 * `storage`.`a11`) + (-1 * `storage`.`a21`), 
`a22` = (3 * `storage`.`a12`) + (-1 * `storage`.`a22`), 
`level` = `storage`.`level` - -1, 
`a11` = (2 * `storage`.`a11`) + (-1 * `storage`.`a21`), 
`a12` = (2 * `storage`.`a12`) + (-1 * `storage`.`a22`) 

Y mi fila se ve así después de eso:

id   a11   a12   a21   a22   level
324  2     1     4     3     1

Para cualquier fila,a12*a21 - a11*a22 = 1 se supone que es verdadero, y de acuerdo con eso, se suponía que la fila era:

id   a11   a12   a21   a22   level
324  1     1     4     3     1

Esto es lo que obtengo en SQLite, con Django generando la misma consulta, y me tomó mucho tiempo darme cuenta de que MySQL estaba haciendo algo diferente. Desde la consulta, parece que cuando se actualizan varias filas interdependientes, MySQL no lo trata como una sola operación atómica y, al actualizar las columnas, afectan los valores que dependen de ellas. Confirmé que esto parece ser lo que sucede con el siguiente código en el indicador de Python:

>>> a11, a12, a21, a22 = (3, 2, 5, 3)
>>> (2 * a11) + (-1 * a21),\
... (2 * a12) + (-1 * a22),\
... (3 * a11) + (-1 * a21),\
... (3 * a12) + (-1 * a22)
(1, 1, 4, 3)

Si las columnas se actualizan de una en una, en el mismo orden dado por la consulta:

>>> a11, a12, a21, a22 = (3, 2, 5, 3)
>>> a21 = (3*a11) + (-1*a21)
>>> a22 = (3*a12) + (-1*a22)
>>> a11 = (2*a11) + (-1*a21)
>>> a12 = (2*a12) + (-1*a22)
>>> (a11, a12, a21, a22)
(2, 1, 4, 3)

Este es un comportamiento realmente aterrador, ya que se trata de una biblioteca destinada a ser utilizada en múltiples plataformas. Mis preguntas son:

¿Cuál está haciendo mal, MySQL o SQLite? ¿Se puede considerar esto un error?¿Qué puedo esperar de otras bases de datos importantes (Oracle, PostgreSQL y SQLServer)?¿Qué puedo hacer con el ORM de Django (sin consultas sin procesar) para normalizar este comportamiento?

editar

El problema está claro, pero todavía estoy buscando una solución. Extraer todos los valores y empujarlos hacia atrás no es una solución aceptable para esta aplicación en particular.