06 Locking and Latching

-- user1, execute 1 -----------------
select * from DEPT
where deptno = 10;

-- user2, execute 2 -----------------
-- user2 第一次查询
select * from DEPT
where deptno = 10;    
-- get result, deptno = 10, dname=‘bbb‘, loc=‘aaa‘

variable :deptno number;
variable :dname varchar2(20);
variable :loc varchar2(20);
-- 模拟应用程序的本地变量存储
exec :deptno := 10; :dname := ‘bbb‘; :loc := ‘aaa‘;

-- user1, execute 3 -----------------
update dept
set dname = ‘ccc‘
where deptno = 10;
commit;
-- 此时, user2 本地变量中保存的数据已经过时

-- user2, execute 4 -----------------
-- user2 第2次查询, 加锁, 准备修改
select deptno, dname, loc
  from dept
 where deptno = :deptno
   and decode(dname, :dname, 1) = 1
   and decode(loc, :loc, 1) = 1
   for update nowait;
-- result, 0 rows

create table dept
(
    deptno number(2),
    dname varchar2(14),
    loc varchar2(13),
    last_mod    timestamp with time zone default systimestamp not null,
    constraint dept_pk primary key(deptno)
)

insert into dept(deptno, dname, loc)
select deptno, dname, loc
from scott.dept;
commit;

-- timestamp 是oracle的最高精度, 两个用户在这样精度下的同一时刻修改数据,
-- 概率太小了.
-- 维护这个值可以使用 trigger/procedure, 不过我们最好是让用户维护这个值,
-- 不是必须使用触发器的情况, 尽量少用触发器.

variable deptno number
variable dname varchar2(14)
variable loc varchar2(13)
variable last_mod varchar2(50)

-- start test
begin
    :deptno := 10;
    select dname, loc, to_char(last_mod, ‘DD-MON-YYYY HH>MI.SSXFF AM TZR‘)
    into :dname, :loc, :last_mod
    from dept
    where deptno = :deptno;
end;/

-- 没有加锁, 直接修改
update dept
set dname = initcap(:dname),
    last_mod = systimestamp
where deptno = :deptno
  and last_mod = to_timestamp_tz(:last_mod, ‘DD-MON-YYYY HH>MI.SSXFF AM TZR‘);
-- 注意这里的条件, 包括了 timestamp, 所以如果在之前有人修改过这个table, 那么本地保存的
-- 数据就是"旧数据", 而此时如果你保存的是旧数据的话, 那么更新将不能进行, 因为条件不满足

-- session 1
-- initialize 
create table t1
( xa number(2));
create table t2
( xb number(2));

insert into t1 values(1);
insert into t2 values(1);
commit;

-- start demonstrate -------------------------
-- session 1, execute 1
-- 注意没有commit, 如果commit就没戏了
update t1
set xa = 2;
-- session 2, execute 2
update t2
set xb = 2;

-- 下面语句执行, 会发生阻塞
update t1
set xa = 3;

-- 下面语句执行, 会发生死锁
-- session 1, execute 3
update t2
set xb = 3;

-- session 1
create table p(x int primary key);

create table c(x references p);

insert into p values(1);

insert into p values(2);

commit;

insert into c values(2);
insert into c values(1);

-- session 2
-- 以下这条语句会被阻塞, 因为以下操作会为表c 加一个全表锁, 而此时的表c中的
-- 某一行已经被session1加锁, 所以加全表锁不成功, 需要等待, 更新主键也会发生

delete from p where x = 1;

column columns format a30 word_wrapped
column tablename format a15 word_wrapped
column constraint_name format a15 word_wrapped

select table_name, constraint_name,
        cname1 || nvl2(cname2, ‘,‘ ||cname2, null) ||
        nvl2(cname3, ‘,‘ || cname3, null) || nvl2(cname4, ‘,‘||cname4, null) ||
        nvl2(cname5, ‘,‘ || cname5, null) || nvl2(cname6, ‘,‘||cname6, null) ||
        nvl2(cname7, ‘,‘ || cname7, null) || nvl2(cname8, ‘,‘||cname8, null) ||
            columns
  from ( select b.table_name,
                b.constraint_name,
                max(decode( position, 1, column_name, null)) cname1,
                max(decode( position, 2, column_name, null)) cname2,
                max(decode( position, 3, column_name, null)) cname3,
                max(decode( position, 4, column_name, null)) cname4,
                max(decode( position, 5, column_name, null)) cname5,
                max(decode( position, 6, column_name, null)) cname6,
                max(decode( position, 7, column_name, null)) cname7,
                max(decode( position, 8, column_name, null)) cname8,            
                count(*) col_cnt
           from ( select substr(table_name, 1, 30) table_name,
                         substr(constraint_name, 1, 30) constraint_name,
                         substr(column_name, 1, 30) column_name,
                         position
                    from user_cons_columns) a,
                user_constraints b
          where a.constraint_name = b.constraint_name
            and b.constraint_type = ‘R‘
          group by b.table_name, b.constraint_name
        ) cons
 where col_cnt > all 
                ( select count(*)
                         from user_ind_columns i
                        where i.table_name = cons.table_name
                          and i.column_name in (cname1, cname2, cname3, cname4,
                                                cname5, cname6, cname7, cname8 )
                          and i.column_position <= cons.col_cnt
                        group by i.index_name
                )
/    

-- initialize ------------------
create table dept
as select * from scott.dept;

create table emp
as select * from scott.emp;

alter table dept
add constraint dept_pk
primary key(deptno);

alter table emp
add constraint emp_pk
primary key(empno);

alter table emp
add constraint emp_fk_dept
foreign key (deptno)
references dept(deptno);

create index emp_deptno_idx
on emp(deptno);

-- start one transaction
update dept
set dname = initCap(dname);

-- 查看系统状态
-- 以下返回1条数据, 虽然锁定了4行, 但是只有1行
select username,
        v$lock.sid,
        trunc(id1/power(2, 16))rbs,
        bitand(id1, to_number(‘ffff‘, ‘xxxx‘))+0 slot,
        id2 seq,
        lmode,
        request
  from v$lock, v$session
 where v$lock.type = ‘TX‘
   and v$lock.sid = v$session.sid
   and v$session.username = USER;


select XIDUSN, XIDSLOT, XIDSQN
  from v$transaction;

create table t
( x int primary key,
  y varchar2(4000)
);
 
    
 insert into t(x,y)
 select rownum, rpad(‘*‘, 148, ‘*‘)
   from dual
 connect by level <= 46;
 
 select length(y),
        dbms_rowid.rowid_block_number(rowid) blk,
        count(*), min(x), max(x)
   from t
  group by length(y), dbms_rowid.rowid_block_number(rowid);


-- 以下存储过程使用了递归调用, 直到我们的块填满
create or replace procedure do_update( p_n in number )
 as
 pragma autonomous_transaction;
 l_rec t%rowtype;
 resource_busy exception;
 pragma exception_init( resource_busy, -54 );
 begin
 select *
 into l_rec
 from t
 where x = p_n
 for update NOWAIT;

 do_update( p_n+1 );
 commit;
 exception
 when resource_busy
 then
 dbms_output.put_line( ‘locked out trying to select row ‘ || p_n );
 commit;
 when no_data_found
 then
 dbms_output.put_line( ‘we finished - no problems‘ );
 commit;
 end;
 /

exec do_update(1);
-- locked out trying to select row 38
-- PL/SQL procedure successfully completed.
-- 发现执行到, 第38行, 块满了, 无法再接受新的事务在这行

-- 重新测试, 这次块内还有很大空间, 那么存储过程可以顺利执行
truncate table t;
insert into t (x,y)
select rownum, rpad(‘*‘,147,‘*‘)
from dual
connect by level <= 46;

exec do_update(1);

-- 建立测试环境
connect scott/scott

begin
    for i in 1..10
    loop
        for x in (select * from user_tables where table_name = ‘T‘ || i)
        loop
            execute immediate ‘drop table‘ || x.table_name;
        end loop;
        execute immediate ‘create table t‘ || i || ‘(x int)‘;
    end loop;
end;
/

package com.leon.testjava;

import java.sql.*;

public class instest {
    public static void main(String[] args) throws Exception {
        DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());
        Connection
        conn = DriverManager.getConnection
        ("jdbc:oracle:thin:@localhost:1521:ora11gr2",
        "scott","soctt");
        conn.setAutoCommit( false );
        Statement stmt = conn.createStatement();
        for( int i = 0; i < 25000; i++ )
        {
        stmt.execute
        ("insert into "+ args[0] +
        " (x) values(" + i + ")" );
        }
        conn.commit();
        conn.close();
        
    }
}

import java.sql.*;
public class instest
{
static public void main(String args[]) throws Exception
{
System.out.println( "start" );
DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());
Connection
conn = DriverManager.getConnection
("jdbc:oracle:thin:@localhost:1521:ora11gr2",
"scott","scott");
conn.setAutoCommit( false );
PreparedStatement pstmt =
conn.prepareStatement
("insert into "+ args[0] + " (x) values(?)" );
for( int i = 0; i < 25000; i++ )
{
    pstmt.setInt( 1, i );
    pstmt.executeUpdate();
}
    conn.commit();
    conn.close();
    System.out.println( "done" );
}
}