Very useful points – especially the reminder about write consistency.

In this case, of course, we’re going to be updating every row in the table, so I should have suggested “lock table in exclusive mode” as a starting step – which would be much more efficient than select for update.

I believe your suggestion about why the “next/previous” problem wouldn’t occur to many SQL Server programmers is correct. That doesn’t mean they shouldn’t worry about it, though, it just means they’re slightly less likely to think of it as a problem.

update t1 set running_tot = n1;

or change your query with adding one “dummy” predicate:

update t1
set running_tot = (
                  select sum( t1_1.n1) 
                  from t1 t1_1
                  where t1_1.id <= t1.id
                    and t1_1.n1*0 = t1.n*0
);

you would see that applied new values.

This behaviour described in articles about “write consistency” and mini-rollbacks(statement restarts).

About posting:
http://jonathanlewis.wordpress.com/comments-on-comment/
http://en.support.wordpress.com/code/posting-source-code/

Buy the way, how did you add this beautiful formatting to your post?

--creating test table with 10 rows, id and n1 = 1..10:
create table t1 as 
select 
   level id
  ,level n1
  ,cast(null as int) running_tot 
from dual 
connect by level<=10;

Table created.

-----------------------
-- in one session we updating n1 to 100 where id=5:
update t1 set n1=100 where id=5;

1 row updated.
-----------------------
            -- in another we updating running_total with your query:
            update t1
            set running_tot = (
                              select sum( t1_1.n1) 
                              from t1 t1_1
                              where t1_1.id <= t1.id
            );
            -- wait for unlocking..
-----------------------
-- now committing in first session:
commit;

Commit complete.
-----------------------
            -- second session unlocked:
            10 rows updated.
            -- let's see what we got:
            select * from t1;
            
                    ID         N1 RUNNING_TOT
            ---------- ---------- -----------
                     1          1           1
                     2          2           3
                     3          3           6
                     4          4          10
                     5        100          15
                     6          6          21
                     7          7          28
                     8          8          36
                     9          9          45
                    10         10          55

            10 rows selected.

update t1
 set running_tot = (
                    select sum( t1_1.n1) from t1 t1_1
                     where t1_1.id <= t1.id 
                   );

Not the fastest query in the world, but should work.

And would be great if “window sort” executed after locking in next oracle versions like subqueries and functions now, which is not used for sorting into “order by” clause.
Also i want to ask: has the “for update” mechanism for array locking like “array update”(redo array) ?