TSQL – Comment empêcher l'optimization dans cette requête

J'ai une requête analogue à:

update x set xy = ( select sum(x2.y) from mytable x2 where x2.y < xy ) from mytable x

le fait étant que je suis en train d'itérer sur des lignes et de mettre à jour un champ basé sur une sous-requête sur les champs qui changent .

Ce que je vois, c'est que la sous-requête est en cours d'exécution pour chaque ligne avant que les mises à jour se produisent, donc les valeurs modifiées pour chaque ligne ne sont pas sockets en count.

Comment puis-je forcer la sous-requête à être réévaluée pour chaque ligne de la mise à jour?

Y at-il un indice de table approprié ou quelque chose?

En passant, je faisais le ci-dessous et cela a fonctionné, mais depuis modifier ma requête un peu (pour des raisons logiques, ne pas essayer de résoudre ce problème) cette astuce ne fonctionne plus 🙁

 declare @temp int update x set @temp = ( select sum(x2.y) from mytable x2 where x2.y < xy ), xy = @temp from mytable x

Je ne suis pas particulièrement concerné par les performances, il s'agit d'une tâche de fond exécutée sur quelques lignes

Il semble que la tâche soit incorrecte ou que d'autres règles s'appliquent.

Voyons voir par exemple. Disons que vous avez des valeurs 4, 1, 2, 3, 1, 2

Sql mettra à jour les lignes en fonction des valeurs d'origine. C'est-à-dire lors de l'instruction de mise à jour unique, les nouvelles valeurs calculées ne se mélangent PAS avec les valeurs d'origine:

 -- only original values used 4 -> 9 (1+2+3+1+2) 1 -> null 2 -> 2 (1+1) 3 -> 6 (1+2+1+2) 1 -> null 2 -> 2 (1+1)

En fonction de votre request, vous souhaitez que la mise à jour de chaque ligne count les nouvelles valeurs calculées. (Notez que SQL ne garantit pas la séquence dans laquelle les lignes seront traitées.) Faisons ce calcul en traitant les lignes de haut en bas:

 -- from top 4 -> 9 (1+2+3+1+2) 1 -> null 2 -> 1 (1) 3 -> 4 (1+1+2) 1 -> null 2 -> 1 (1)

Faites de même dans les autres séquences – de bas en haut:

 -- from bottom 4 -> 3 (2+1) 1 -> null 2 -> 1 (1) 3 -> 5 (2+2+1) 1 -> null 2 -> 2 (1+1)

Comment vous pouvez voir votre résultat attendu est incohérent. Pour le rendre correct, vous devez corriger la règle de calcul – par exemple, définir une séquence forte des lignes à traiter (date, id, …) Aussi, si vous voulez faire un traitement récursif, regardez l' expression common_table_expression :

http://technet.microsoft.com/en-us/library/ms186243(v=sql.105).aspx