精华内容
下载资源
问答
  • 什么是事务事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务事务开始(begin transaction)和事务结束(end transaction)之间执行的全体操作组成。事务的属性-ACID原子性...

    什么是事务?

    事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务由事务开始(begin transaction)和事务结束(end transaction)之间执行的全体操作组成。

    事务的属性-ACID

    原子性(Atomicity)-事务的原子性强调了一个事物是一个逻辑工作单元,是一个整体,是不可分割的。一个事务所包含的操作要么全部做,要不全部不做。

    一致性(Consistency)-一个事务执行一项数据库操作,事务使数据库从一种一致性的状态变换成另一种一致性状态。

    隔离性(Isolation)-在事务未提交前,它操作的数据,对其他用户不可见。

    持久性(Durability)-一旦事务成功完成,该事务对数据库所施加的所有更新都是永久的。

    redo日志–提交的事务被永久的记录到redo日志中。

    数据库事务的开始和结束

    以第一个DML语句的执行作为开始

    以下面的其中之一作为结束:

    commit或rollback语句

    DDL或DCL语句(自动提交)

    用户会话正常结束–commit

    系统异常终了–rollback

    并发与数据的读取

    当多个会话同时访问(操作)相同的数据时,将会出现一些意想不到的结果。包括:

    脏读 --dirty reads

    一个事务读取了另一个事务未提交的数据,而这个数据是有可能回滚

    不可重复读 --non-repeatable reads

    在数据库访问中,一个事务范围内两个相同的查询却返回了不同数据。这是由于查询时系统中其他事务修改的提交而引起的。

    幻读 --Phantom(虚幻的) reads

    事务1读取记录时事务2增加了记录并提交,事务1再次读取时可以看到事务2新增的记录。对事物1而言就好像出现了幻觉一样。

    事务的隔离等级

    ANSI定义的事务的隔离等级:

    事务隔离等级

    脏读

    不可重复读

    幻读Read uncommited(读未提交的)

    Y

    Y

    Y

    Read commited(读提交的)

    N

    Y

    Y

    Repeatable read

    N

    N

    Y

    Serializable

    N

    N

    N

    Oracle定义的事务隔离等级:

    事务隔离等级

    影响Read commited

    Oracle默认的隔离等级,对一条SQL,可以保证数据的一致性,对于一个事务,无法做到repeatable read。

    Serializable

    只能看到事务开始时所有提交的改变以及自身的改变

    Read-only

    只能看到事务开始时所有提交的改变,自身不允许DML操作

    事务的并发控制-锁

    Oracle的锁定机制

    Oracle尽可能的减少锁定的使用

    Oracle的读操作不会对表加锁,一些数据库会使用查询锁定(共享锁,排它锁)

    Oracle通过回滚机制,保证读不会受到阻塞

    Oracle没有锁管理器

    Oracle中锁作为数据块的一种属性存在

    Oracle和Sql Server锁的区别

    Sql Server

    Oracle并发和读一致性不可兼得,必须牺牲一方

    可兼得

    因为锁实现方式,事务代价昂贵

    没有真正的锁,事务没有资源代价

    提倡尽快提交

    主张按照业务需求确定事务边界

    事务的控制-savepoint

    通过在事务中间设置检查点,可以更加精细的控制事务,防止一部分错误操作导致整个事务重新运行。演示如下:

    SQL> create table t(id int);

    表已创建。

    SQL> insert into t values(1);

    已创建 1 行。

    SQL> savepoint s1;

    保存点已创建。

    SQL> select * from t;

    ID

    ----------

    1

    SQL> update t set id=2;

    已更新 1 行。

    SQL> savepoint s2;

    保存点已创建。

    SQL> select * from t;

    ID

    ----------

    2

    SQL> rollback to s1;

    回退已完成。

    SQL> select * from t;

    ID

    ----------

    1

    一旦返回到保存点s1之后s2就失去了效果,因为已经回到s1了,这时候s2还不存在。

    自治事务

    自治事务允许在一个事务中存在独立的事务,它的操作不会对当前事务产生影响。

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    语法:

    pragma autonomous_transaction

    关于自治事务的使用可以参考:ORACLE中的自治事务

    实验演示如下:(演示用例来自参考资料Oracle中的自治事务)

    首先是不使用自治事务

    SQL> create table msg (msg varchar2(120));

    SQL> set serveroutput on

    SQL> declare

    2 cnt number := -1; --} Global variables

    3 procedure local is

    4 begin

    5 select count(*) into cnt from msg;

    6 dbms_output.put_line('local: # of rows is '||cnt);

    7

    8 insert into msg values ('New Record');

    9 commit;

    10 end;

    11 begin

    12 delete from msg ;

    13 commit;

    14 insert into msg values ('Row 1');

    15 local;

    16 select count(*) into cnt from msg;

    17 dbms_output.put_line('main: # of rows is '||cnt);

    18 rollback;

    19

    20 local;

    21 insert into msg values ('Row 2');

    22 commit;

    23

    24 local;

    25 select count(*) into cnt from msg;

    26 dbms_output.put_line('main: # of rows is '||cnt);

    27 end;

    28 /

    local: # of rows is 1 -> 子程序local中可以’看到’主匿名块中的uncommitted记录

    main: # of rows is 2 -> 主匿名块可以’看到’2条记录(它们都是被local commit掉的)

    local: # of rows is 2 -> 子程序local首先’看到’2条记录,然后又commit了第三条记录

    local: # of rows is 4 -> 子程序local又’看到’了新增加的记录(它们都是被local commit掉的),然后又commit了第五条记录

    main: # of rows is 5 -> 主匿名块最后’看到’了所有的记录.

    PL/SQL 过程已成功完成。

    从这个例子中,我们看到COMMIT和ROLLBACK的位置无论是在主匿名块中或者在子程序中,都会影响到整个当前事务.

    现在如果将procedure local改成自治事务,在procedure local后面加上:

    pragma AUTONOMOUS_TRANSACTION;

    效果如下:

    SQL> declare

    2 cnt number := -1; --} Global variables

    3 procedure local is

    4 pragma AUTONOMOUS_TRANSACTION;

    5 begin

    6 select count(*) into cnt from msg;

    7 dbms_output.put_line('local: # of rows is '||cnt);

    8

    9 insert into msg values ('New Record');

    10 commit;

    11 end;

    12 begin

    13 delete from msg ;

    14 commit;

    15 insert into msg values ('Row 1');

    16 local;

    17 select count(*) into cnt from msg;

    18 dbms_output.put_line('main: # of rows is '||cnt);

    19 rollback;

    20

    21 local;

    22 insert into msg values ('Row 2');

    23 commit;

    24

    25 local;

    26 select count(*) into cnt from msg;

    27 dbms_output.put_line('main: # of rows is '||cnt);

    28 end;

    29 /

    local: # of rows is 0 -> 子程序local中无法可以’看到’主匿名块中的uncommitted记录 (因为它是独立的)

    main: # of rows is 2 -> 主匿名块可以’看到’2条记录,但只有一条是被commited.

    local: # of rows is 1 -> 子程序local中可以’看到’它前一次commit的记录,但是主匿名块中的记录已经被提前rollback了

    local: # of rows is 3 -> 子程序local 中可以’看到’3条记录包括主匿名块commit的记录

    main: # of rows is 4 ->主匿名块最后’看到’了所有的记录.

    PL/SQL 过程已成功完成。

    分布式事务

    发生在多台数据库之间的事务。

    通过dblink方式进行事务处理。

    分布式事务要比单机事务要复杂的多。

    可能的风险:软件,服务器,网络。

    分布式事务的组成

    角色

    描述client

    调用其它数据库信息的节点

    database

    接受来自其它节点请求的节点

    Global coordinate

    发起分布式事务的节点(全局调度者)

    Local coordinate

    处理本地事务,并和其它节点通信的节点(本地调度者)

    Commit point site

    被global coordinate指定第一个提交或回滚事务的节点

    commit Point Strength

    Oracle选取Commit Point Strength(相当于权重)最大的数据库作为Commit point。

    Oracle分布式事务的机制-两阶段提交

    2PC-two phase commit

    prepare phase

    commit phase

    准备阶段prepare phase

    为了完成准备阶段,除了commit point机器外,其它的数据库机器按照以下步骤执行:

    每个节点检查自己是否被其它节点所引用,如果有,就通知这些节点准备提交(进入prepare阶段)

    每个节点检查自己运行的事务,如果发现本地运行的事务不做修改数据操作,则跳过后面的步骤,直接返回一个read only给全局协调进程。

    如果事务需要修改数据,为事务分配相应的资源用于保证修改的正常进行。

    对事物做的修改,记录redo信息。

    本地redo保证事务失败后的回滚。

    当上面的工作都成功后,给全局协调进程返回准备就绪的信息,反之,返回失败的信号。

    提交阶段commit phase

    提交阶段按下面的步骤进行:

    全局协调器通知commit point进行提交

    commit point提交完成。

    commit point服务器通知全局协调器提交完成

    全局协调器通知其它节点进行提交

    其它节点提交本地的事务,释放资源(提交先后顺序根据Commit Point Strength)

    其它节点在redo上记录相应的redo日志,并标注提交完成

    其它节点通知全局协调器提交完成。

    分布式事务的结束

    分布式事务的结束就是全局协调器和commit point两者之间释放资源的顺序。

    全局协调器通知commit point数据库所有节点提交完成。

    commit point数据库释放和事务相关的所有资源,然后通知全局协调器。

    全局协调器释放自己持有的资源

    分布式事务结束

    ###分布式事务的安全性

    2PC是否真的可以保证分布式事务的一致性?

    理论上是不可能保证分布式事务的一致性。

    关于CAP理论可以参见:CAP理论

    记得帮我点赞哦!

    念念不忘,必有回响,小伙伴们帮我点个赞吧,非常感谢。

    我是职场亮哥,YY高级软件工程师、四年工作经验,拒绝咸鱼争当龙头的斜杠程序员。

    听我说,进步多,程序人生一把梭

    如果有幸能帮到你,请帮我点个【赞】,给个关注,如果能顺带评论给个鼓励,将不胜感激。

    本人所有文章、回答都与版权保护平台有合作,著作权归职场亮哥所有,未经授权,转载必究!

    展开全文
  • oracle事务的隔离等级

    2011-05-26 17:45:52
    转自http://blog.sina.com.cn/s/blog_620b45a40100eywu.html 今天在消息的接受日志中,发现一个错误.ORA-08177: 无法连续访问此事务处理. 觉得有点束手无策,于是停下许...

    转自http://blog.sina.com.cn/s/blog_620b45a40100eywu.html

    今天在消息的接受日志中,发现一个错误.ORA-08177: 无法连续访问此事务处理.

    觉得有点束手无策,于是停下许多工作,开始解决此错误.

    首先怀疑,错误就是并发造成.根据日志显示,同一秒内,处理了7,8笔数据.所以就先从这里下手.

    后根据ORA-08177在网上查处错误解释.

      Cannot serialize access 不能序列访问.说是Oracle中比较郁闷的 错误.

        后来找到一个重现的例子.如下:

     

        这个问题是由oracle 事务隔离级别引起的
        在一个事务中执行
        update t set object_type='zl' where object_id=17286
        不要提交此事务
        然后再其他事务中执行
        set transaction isolation level serializable;
        update t set object_type='zl' where object_id=17286

        这个时候事务2 会等待事务1执行完成,提交事务1 的时候会出现上述问题

     

        我把SQL改成操作的对应消息的表,发现的确如此.但是其中最重要的一句话是set transaction isolation level serializable;就是将这个事务,序列化,如下所述:

     

        隔离级别(isoation eve)

    隔离级别定义了事务与事务之间的隔离程度。

    隔离级别与并发性是互为矛盾的:隔离程度越高,数据库的并发性越差;隔离程度越低,数据库的并发性越好。

    ANSI/ISO SQ92标准定义了一些数据库操作的隔离级别:

    • 未提交读(read uncommitted)
    • 提交读(read committed)  
    • 重复读(repeatabe read)  
    • 序列化(seriaizabe)

    通过一些现象,可以反映出隔离级别的效果。这些现象有:

    • 更新丢失(ost update):当系统允许两个事务同时更新同一数据是,发生更新丢失。  
    • 脏读(dirty read):当一个事务读取另一个事务尚未提交的修改时,产生脏读。
    • 非 重复读(nonrepeatabe read):同一查询在同一事务中多次进行,由于其他提交事务所做的修改或删除,每次返回不同的结果集,此时发生非重复读。(A transaction rereads data it has previousy read and finds that another committed transaction has modified or deeted the data. )
    • 幻 像(phantom read):同一查询在同一事务中多次进行,由于其他提交事务所做的插入操作,每次返回不同的结果集,此时发生幻像读。(A transaction reexecutes a query returning a set of rows that satisfies a search condition and finds that another committed transaction has inserted additiona rows that satisfy the condition. )

    下面是隔离级别及其对应的可能出现或不可能出现的现象

     

    Dirty ReadNonRepeatabe ReadPhantom Read
    Read uncommittedPossiblePossiblePossible
    Read committednot possiblePossiblePossible
    Repeatabe readnot possiblenot possiblePossible
    Seriaizabenot possiblenot possiblenot possible

     

     

    ORACE的隔离级别

    ORACE提供了SQ92标准中的read committed和seriaizabe,同时提供了非SQ92标准的read-ony。

    read committed:

    • 这是ORACE缺省的事务隔离级别。
    • 事务中的每一条语句都遵从语句级的读一致性。
    • 保证不会脏读;但可能出现非重复读和幻像。

    seriaizabe:(串行执行事务,并发性最小)

    • 简单地说,seriaizabe就是使事务看起来象是一个接着一个地顺序地执行。
    • 仅仅能看见在本事务开始前由其它事务提交的更改和在本事务中所做的更改。
    • 保证不会出现非重复读和幻像。
    • Seriaizabe隔离级别提供了read-ony事务所提供的读一致性(事务级的读一致性),同时又允许DM操作。

    如果有在seriaizabe事务开始时未提交的事务在seriaizabe事务结束之前修改了seriaizabe事务将要修改的行并进行了提交,则seriaizabe事务不会读到这些变更,因此发生无法序列化访问的错误。(换一种解释方法:只要在seriaizabe事务开始到结束之间有其他事务对seriaizabe事务要修改的东西进行了修改并提交了修改,则发生无法序列化访问的错误。)

      

        ORACE在数据块中记录最近对数据行执行修改操作的N个事务的信息,目的是确定本事务开始时,是否存在未提交的事务修改了本事务将要修改的行。

     

    read-ony:

    • 遵从事务级的读一致性,仅仅能看见在本事务开始前由其它事务提交的更改。
    • 不允许在本事务中进行DM操作。
    • read ony是seriaizabe的子集。它们都避免了非重复读和幻像。区别是在read ony中是只读;而在seriaizabe中可以进行DM操作。
    • Export with CONSISTENT = Y sets the transaction to read-ony.

     

    read committed和seriaizabe的区别和联系:

    事务1先于事务2开始,并保持未提交状态。事务2想要修改正被事务1修改的行。事务2等待。如果事务1回滚,则事务2(不论是read committed还是seriaizabe方式)进行它想要做的修改。如果事务1提交,则当事务2是read committed方式时,进行它想要做的修改;当事务2是seriaizabe方式时,失败并报错“Cannot seriaize access”,因为事务2看不见事务1提交的修改,且事务2想在事务1修改的基础上再做修改。

    即seriaizabe不允许存在事务嵌套

     

    read committed和seriaizabe可以在ORACE并行服务器中使用。

    关于SET TRANSACTION READ WRITE:read write和read committed 应该是一样的。在读方面,它们都避免了脏读,但都无法实现重复读。虽然没有文档说明read write在写方面与read committed一致,但显然它在写的时候会加排他锁以避免更新丢失。在加锁的过程中,如果遇到待锁定资源无法锁定,应该是等待而不是放弃。这与 read committed一致。

    语句级的读一致性

    • ORACE保证语句级的读一致性,即一个语句所处理的数据集是在单一时间点上的数据集,这个时间点是这个语句开始的时间。
    • 一个语句看不见在它开始执行后提交的修改。
    • 对于DM语句,它看不见由自己所做的修改,即DM语句看见的是它本身开始执行以前存在的数据。

    事务级的读一致性

    • 事务级的读一致性保证了可重复读,并保证不会出现幻像。

    设置隔离级别

    设置一个事务的隔离级别

    • SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
    • SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
    • SET TRANSACTION READ ONLY;

    设置增个会话的隔离级别

    • ATER SESSION SET ISOLATION_LEVE SERIALIZABLE;
    • ATER SESSION SET ISOLATION_LEVE READ COMMITTED;

     

    Choice of Isolation Level

    Read Committed Isolation

    两种情况:(1)在事务量大、高性能的计算环境,需要更高的吞吐量和响应时间;(2)事务数少,并且发生幻影和不可重复读的几率的比较低

     

    Serializable Isolation

    (1)适合于很少存在两个事务同时修改同一条记录的情况

    (2)长事务以只读为主

    (3)大型数据库并且每个短事务只修改很少的记录

     

    如此我就在消息的接口中,找到运行SQL的公用方法,发现执行批量SQL的方法,这里将执行事务的级别设置为了Serializable(序列化),就此就真相大白了,剩下的就是商讨如何解决了.

    来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/804471/viewspace-696376/,如需转载,请注明出处,否则将追究法律责任。

    转载于:http://blog.itpub.net/804471/viewspace-696376/

    展开全文
  • Oracle事务Transaction

    2020-09-18 10:11:09
    关于Oracle事务的总结 什么是事务? 事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务由事务开始(begin transaction)和事务结束(end transaction)之间执行的全体操作组成。 ...

    参考资料:

    Transactions

    关于Oracle事务的总结


    什么是事务?

    事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务由事务开始(begin transaction)和事务结束(end transaction)之间执行的全体操作组成。

    事务的属性-ACID

    • 原子性(Atomicity)-事务的原子性强调了一个事物是一个逻辑工作单元,是一个整体,是不可分割的。一个事务所包含的操作要么全部做,要不全部不做。
    • 一致性(Consistency)-一个事务执行一项数据库操作,事务使数据库从一种一致性的状态变换成另一种一致性状态。

    • 隔离性(Isolation)-在事务未提交前,它操作的数据,对其他用户不可见。

    • 持久性(Durability)-一旦事务成功完成,该事务对数据库所施加的所有更新都是永久的。

      • redo日志--提交的事务被永久的记录到redo日志中。

    数据库事务的开始和结束

    以第一个DML语句的执行作为开始

    以下面的其中之一作为结束:

    • commit或rollback语句
    • DDL或DCL语句(自动提交)
    • 用户会话正常结束--commit
    • 系统异常终了--rollback

    并发与数据的读取

    当多个会话同时访问(操作)相同的数据时,将会出现一些意想不到的结果。包括:

    • 脏读 --dirty reads

      一个事务读取了另一个事务未提交的数据,而这个数据是有可能回滚 ​

    • 不可重复读 --non-repeatable reads

      在数据库访问中,一个事务范围内两个相同的查询却返回了不同数据。这是由于查询时系统中其他事务修改的提交而引起的。 ​

    • 幻读 --Phantom(虚幻的) reads

      事务1读取记录时事务2增加了记录并提交,事务1再次读取时可以看到事务2新增的记录。对事物1而言就好像出现了幻觉一样。

    事务的隔离等级

    ANSI定义的事务的隔离等级:

    事务隔离等级脏读不可重复读幻读
    Read uncommited(读未提交的)YYY
    Read commited(读提交的)NYY
    Repeatable readNNY
    SerializableNNN

    Oracle定义的事务隔离等级:

    事务隔离等级影响
    Read commitedOracle默认的隔离等级,对一条SQL,可以保证数据的一致性,对于一个事务,无法做到repeatable read。
    Serializable只能看到事务开始时所有提交的改变以及自身的改变
    Read-only只能看到事务开始时所有提交的改变,自身不允许DML操作

    事务的并发控制-锁

    Oracle的锁定机制

    • Oracle尽可能的减少锁定的使用

    • Oracle的读操作不会对表加锁,一些数据库会使用查询锁定(共享锁,排它锁)

    • Oracle通过回滚机制,保证读不会受到阻塞

    • Oracle没有锁管理器

    • Oracle中锁作为数据块的一种属性存在

    Oracle和Sql Server锁的区别

    Sql ServerOracle
    并发和读一致性不可兼得,必须牺牲一方可兼得
    因为锁实现方式,事务代价昂贵没有真正的锁,事务没有资源代价
    提倡尽快提交主张按照业务需求确定事务边界

    事务的控制-savepoint

    通过在事务中间设置检查点,可以更加精细的控制事务,防止一部分错误操作导致整个事务重新运行。演示如下:

    SQL> create table t(id int);
    
    表已创建。
    
    SQL> insert into t values(1);
    
    已创建 1 行。
    
    SQL> savepoint s1;
    
    保存点已创建。
    
    SQL> select * from t;
    
            ID
    ----------
             1
    
    SQL> update t set id=2;
    
    已更新 1 行。
    
    SQL> savepoint s2;
    
    保存点已创建。
    
    SQL> select * from t;
    
            ID
    ----------
             2
    
    SQL> rollback to s1;
    
    回退已完成。
    
    SQL> select * from t;
    
            ID
    ----------
             1

    一旦返回到保存点s1之后s2就失去了效果,因为已经回到s1了,这时候s2还不存在。

    自治事务

    自治事务允许在一个事务中存在独立的事务,它的操作不会对当前事务产生影响。

    语法:

    pragma autonomous_transaction

    关于自治事务的使用可以参考:ORACLE中的自治事务

    实验演示如下:(演示用例来自参考资料Oracle中的自治事务)

    首先是不使用自治事务

    SQL> create table msg (msg varchar2(120));
    SQL> set serveroutput on
    SQL> declare
      2    cnt number := -1;  --} Global variables
      3    procedure local is
      4    begin
      5       select count(*) into cnt from msg;
      6       dbms_output.put_line('local: # of rows is '||cnt);
      7
      8       insert into msg values ('New Record');
      9       commit;
     10    end;
     11    begin
     12       delete from msg ;
     13       commit;
     14       insert into msg values ('Row 1');
     15       local;
     16       select count(*) into cnt from msg;
     17       dbms_output.put_line('main: # of rows is '||cnt);
     18       rollback;
     19
     20       local;
     21       insert into msg values ('Row 2');
     22       commit;
     23
     24       local;
     25       select count(*) into cnt from msg;
     26       dbms_output.put_line('main: # of rows is '||cnt);
     27    end;
     28  /
    local: # of rows is 1  -> 子程序local中可以’看到’主匿名块中的uncommitted记录
    main: # of rows is 2   -> 主匿名块可以’看到’2条记录(它们都是被local commit掉的)
    local: # of rows is 2  -> 子程序local首先’看到’2条记录,然后又commit了第三条记录
    local: # of rows is 4  -> 子程序local又’看到’了新增加的记录(它们都是被local commit掉的),然后又commit了第五条记录
    main: # of rows is 5   -> 主匿名块最后’看到’了所有的记录. 
    
    PL/SQL 过程已成功完成。

    从这个例子中,我们看到COMMIT和ROLLBACK的位置无论是在主匿名块中或者在子程序中,都会影响到整个当前事务.

    现在如果将procedure local改成自治事务,在procedure local后面加上:

    pragma AUTONOMOUS_TRANSACTION;

    效果如下:

    SQL> declare
      2    cnt number := -1;  --} Global variables
      3    procedure local is
      4    pragma AUTONOMOUS_TRANSACTION;
      5    begin
      6       select count(*) into cnt from msg;
      7       dbms_output.put_line('local: # of rows is '||cnt);
      8
      9       insert into msg values ('New Record');
     10       commit;
     11    end;
     12    begin
     13       delete from msg ;
     14       commit;
     15       insert into msg values ('Row 1');
     16       local;
     17       select count(*) into cnt from msg;
     18       dbms_output.put_line('main: # of rows is '||cnt);
     19       rollback;
     20
     21       local;
     22       insert into msg values ('Row 2');
     23       commit;
     24
     25       local;
     26       select count(*) into cnt from msg;
     27       dbms_output.put_line('main: # of rows is '||cnt);
     28    end;
     29  /
    local: # of rows is 0  -> 子程序local中无法可以’看到’主匿名块中的uncommitted记录 (因为它是独立的)
    main: # of rows is 2   -> 主匿名块可以’看到’2条记录,但只有一条是被commited.
    local: # of rows is 1  -> 子程序local中可以’看到’它前一次commit的记录,但是主匿名块中的记录已经被提前rollback了
    local: # of rows is 3  -> 子程序local 中可以’看到’3条记录包括主匿名块commit的记录
    main: # of rows is 4   ->主匿名块最后’看到’了所有的记录.
    
    PL/SQL 过程已成功完成。

    分布式事务

    • 发生在多台数据库之间的事务。
    • 通过dblink方式进行事务处理。
    • 分布式事务要比单机事务要复杂的多。
    • 可能的风险:软件,服务器,网络。

    分布式事务的组成

    角色描述
    client调用其它数据库信息的节点
    database接受来自其它节点请求的节点
    Global coordinate发起分布式事务的节点(全局调度者)
    Local coordinate处理本地事务,并和其它节点通信的节点(本地调度者)
    Commit point site被global coordinate指定第一个提交或回滚事务的节点

    commit Point Strength

    Oracle选取Commit Point Strength(相当于权重)最大的数据库作为Commit point。

    Oracle分布式事务的机制-两阶段提交

    2PC-two phase commit

    • prepare phase
    • commit phase

    准备阶段prepare phase

    为了完成准备阶段,除了commit point机器外,其它的数据库机器按照以下步骤执行:

    • 每个节点检查自己是否被其它节点所引用,如果有,就通知这些节点准备提交(进入prepare阶段)

    • 每个节点检查自己运行的事务,如果发现本地运行的事务不做修改数据操作,则跳过后面的步骤,直接返回一个read only给全局协调进程。

    • 如果事务需要修改数据,为事务分配相应的资源用于保证修改的正常进行。

    • 对事物做的修改,记录redo信息。

    • 本地redo保证事务失败后的回滚。

    • 当上面的工作都成功后,给全局协调进程返回准备就绪的信息,反之,返回失败的信号。

    提交阶段commit phase

    提交阶段按下面的步骤进行:

    • 全局协调器通知commit point进行提交
    • commit point提交完成。
    • commit point服务器通知全局协调器提交完成
    • 全局协调器通知其它节点进行提交
    • 其它节点提交本地的事务,释放资源(提交先后顺序根据Commit Point Strength)
    • 其它节点在redo上记录相应的redo日志,并标注提交完成
    • 其它节点通知全局协调器提交完成。

    分布式事务的结束

    分布式事务的结束就是全局协调器和commit point两者之间释放资源的顺序。

    • 全局协调器通知commit point数据库所有节点提交完成。
    • commit point数据库释放和事务相关的所有资源,然后通知全局协调器。
    • 全局协调器释放自己持有的资源
    • 分布式事务结束

    ###分布式事务的安全性

    2PC是否真的可以保证分布式事务的一致性?

    • 理论上是不可能保证分布式事务的一致性。

    关于CAP理论可以参见:CAP理论


    记得帮我点赞哦!

    精心整理了计算机各个方向的从入门、进阶、实战的视频课程和电子书,按照目录合理分类,总能找到你需要的学习资料,还在等什么?快去关注下载吧!!!

    resource-introduce

    念念不忘,必有回响,小伙伴们帮我点个赞吧,非常感谢。

    我是职场亮哥,YY高级软件工程师、四年工作经验,拒绝咸鱼争当龙头的斜杠程序员。

    听我说,进步多,程序人生一把梭

    如果有幸能帮到你,请帮我点个【赞】,给个关注,如果能顺带评论给个鼓励,将不胜感激。

    职场亮哥文章列表:更多文章

    wechat-platform-guide-attention

    本人所有文章、回答都与版权保护平台有合作,著作权归职场亮哥所有,未经授权,转载必究!

    展开全文
  • oracle事务概述

    千次阅读 2015-10-14 11:03:36
    oracle确保事务完整性的机制是撤销段和重做日志文件的组合:此机制无疑是迄今为止开发的任何数据库中的翘楚,而且完全符合数据处理的国际标准。虽然其他数据库供应商能够通过使用自己的机制遵循相同的标准,但是却...

    事务的概念都是关系数据库范例的一部分。事务由一个或多个DML语句组成,后面紧跟着ROLLBACK或COMMIT命令。可以在事务内使用SAVEPOINT命令给出控制程度。

    1.数据库事务

    oracle确保事务完整性的机制是撤销段和重做日志文件的组合:此机制无疑是迄今为止开发的任何数据库中的翘楚,而且完全符合数据处理的国际标准。虽然其他数据库供应商能够通过使用自己的机制遵循相同的标准,但是却改变了效率级别。简而言之,任何关系数据库都必须能够通过ACID测试,必须确保原子性(Atomicity)、一致性(Consistency)、隔离性(Isolation)和持久性(Durability)。

    1.原子性

    原子性原则规定一个事务的所有部分必须都完成,或都不完成(该术语背后的理论是原子不可再分——现在大家知道这是一个错误的假设)。例如,如果业务分析师认为每次某个雇员的薪水发生变化时都必须更改该雇员的等级,那么这个”原子“事务就由两个更新操作组成。数据库必须保证两个更新操作都能完成或者都不完成。如果只有一个更新操作被成功执行,那么雇员的薪水与等级会出现矛盾(商业术语为数据损坏)。如果事务在完成之前出现任何错误,那么数据库自身就必须保证自动回滚所做过的任何事务部分(并且必须自动进行)。虽然原子事务听起来似乎像原子一样小,然而事实上它可以非常大。再举一个例子,从逻辑上看,某个财务软件的名目账项总账不能为八、九月份各半月的账目之和,因此月末转账就是一个原子事务,这个事务可能会影响数千个表中的几百万条记录,并且需要花费几个小时才能完成(或者在出现错误时所进行的回滚)。未完成事务的回滚可以是人工进行的(此时需要执行ROLLBACK命令),不过在出现错误的情况下,回滚必须是自动的和不可停止的。

    2.一致性

    一致性的原则规定查询的结果必须与数据库在查询开始时的状态一致。假设要进行一个简单的查询,该查询会求取某个表中某列数据的平均值。如果这个表很大,那么扫描整个表需要数分钟时间。在这个查询进行期间,如果其他用户也在更新该列,那么查询应当包括新值还是旧值?查询应当包含在查询启动之后被插入或被删除的记录吗?一致性的原则要求数据库确保查询不会看见改变后的值;无论这个查询经过多长时间或者发生与指定表相关的其他任何动作,它都会提供查询开始时指定列所有数据的平均值。oracle能够保证:在查询成功的前提下,查询结果是一致的。不过,如果数据库管理员没有正确的配置数据库,那么查询就不会成功,就会产生一个常见的oracle错误:“ORA-1555 snapshot too old”。对于旧版本而言,这是一个极难解决的问题,不过对于最近的版本,数据库管理员可以避免这个问题。

    3.隔离性

    隔离性的原则规定对于其他部分来说,未完成的(也就是未提交的)事务必须不可见。在某个事务进行期间,只有执行该事务的一个会话能看见所做的变更,而其他所有会话看见的都是没有变更的数据(而不是更改后的新值)。这个规定的逻辑含义是:首先,由于整个事务可能没有全部完成(前面介绍了原子性原则以及自动或手动回滚),因此不允许其他用户看到可能反转的变更。其次,在某个事务进行期间,数据时不一致的,也就是说在雇员的薪水发生变化后的短暂时间里,其薪水等级尚未发生相应的变化。事务隔离性要求数据库必须对其他用户隐藏正在进行的事务,这些用户只能看到没有被更新的数据,只有在事务完成时,他们才能看到作为一个一致集合的所有变更。oracle确保事务隔离性:所有会话(除了做出变更的会话之外)都无法看到未提交的数据。未提交数据的读取称为脏读,oracle不允许这样做。

    4.持久性

    持久性的原则规定一旦某个事务完成,数据库就不可能丢失这个事务。在事务进行期间,隔离性的原则要求除了指定会话涉及的用户之外的任何用户都不能查看当前所做的变更。不过事务一旦完成,所有用户都必须能够立即看到所做的变更,同时数据库必须保证这些变更绝不会丢失(关系数据库不允许丢失数据)。oracle通过使用日志文件在变更完成时记录所有应用于数据的变更向量来满足上述需求。通过将该变更日志应用于以前的备份,就可能在数据库被损坏的情况下恢复所有已完成的工作。当然,数据可能因为用户错误(如不适当的DML、删除或者截断表)而丢失。但是对于oracle和DBA而言,这些事件和其他事物一样,依据持久性原则,它们绝对不可逆。

    2.执行SQL语句

    1.执行SELECT语句

    使用SELECT命令可以检索数据。一条SELECT语句分阶段执行。执行SELECT语句的服务器进程会首先查看包含所需数据的数据块是否已经位于内存和数据库缓冲区缓存中。如果条件成立,那么执行就会立即继续进行。如果条件不成立,那么服务器必须在磁盘上定位相应的数据块,并且将这些数据块复制至数据库缓冲区缓存。
    注意:需要牢记,服务器进程将数据块从数据文件读取至数据库缓冲区缓存,而DBWn进程则将数据块从数据库缓冲区缓存写入数据文件。
    只要查询所需的数据块位于数据库缓冲区缓存内,那么进一步的处理(如排序或聚合)就在指定会话的PGA中完成。执行完成后,结果集返回至用户进程。
    下图显示了SELECT语句的处理方式
                                                          
    步骤1将SELECT语句从用户进程传输给服务器进程。服务器将搜索数据库缓冲区缓存,了解必须的块是否已经在内存中,如果在,就进入到步骤4。否则,进入步骤2在数据文件中查找块,然后在步骤3中将它们复制到数据库缓冲区缓存中。步骤4将数据传输到服务器进程,做进一步的处理,此后,步骤5将查询结果返回给用户进程。

    2.执行UPDATE语句

    对于任何DML操作来说,必须同时处理数据块和撤销块, 并且还会生成重做。ACID测试的A、C和I要求生成撤销,D则要求生成重做。
    注意:“撤销”不是“重做”的逆过程。对于表段、索引段或撤销段的数据块的变更来说,重做可以保护所有的数据块变更。就重做而言,撤销段只是另一个段,对这个段所做的任何变更都必须是持久的。
    执行DML语句的第一个步骤与执行SELECT语句的第一个步骤相同:必须在数据库缓冲区缓冲中找到所需的数据块或者将所需的数据块从数据文件复制到数据库缓冲区缓存。在这个步骤中,二者唯一的区别是执行DML语句还需要某个撤销段的一个空数据块(或者过期的数据块)。接下来,DML语句的执行就比较复杂。
    首先,必须在DML操作影响的所有记录以及相关索引键上放置锁。接下来会生成重做,此时服务器进程在日志缓冲区中写入即将应用于指定数据块的变更向量。这个重做生成操作应用于表块的变更和撤销块的变更。如果要更新某个列,那么这个列的rowid和新值(将要应用于表数据块的变更)以及旧值(将要应用于撤销块的变更)都会被写入日志缓冲区。如果这个列是某个索引键的一部分,那么要应用于该索引的变更以及保护索引变更的撤销块变更也会被写入日志缓冲区。
    生成重做后,就可以在数据库缓冲区缓存内完成下列更新操作:使用变更后的列更新表数据块,未变更的列则被写入撤销段数据块。从这一时刻到提交更新操作的时候,与发生变更的记录相关的其他会话中的所有查询都会被重定向至撤销数据。只有执行更新操作的会话才可以在表数据块中看见更新后的行。所有关联的索引变更同样也会应用上述原则。

    3.执行INSERT和DELETE语句

    从概念上看,INSERT和DELETE语句与UPDATE语句具有相同的管理方式。第一步是在数据库缓冲区缓存中查找相关块,如果它们不在那里,就将它们复制到数据库缓冲区缓存中。
    重做生成操作完全相同,应用于数据块和撤销块的所有变更向量都会首先被写入日志缓冲区。对于INSERT,将要应用于表块(还可能包括索引块)的变更向量是构成新行(还可能包括新索引键)的字节。将要应用于撤销块的向量是新行的rowid。对于DELETE,要写入到撤销块的变更向量是整个行。
    INSERT和DELETE语句的重要差异在于所生成的撤销数据量不同。插入一条记录时,生成撤销的操作只涉及为撤销块写下新的rowid。这是由于回滚INSERT语句时,oracle只需要rowid信息,因此可以构建如下语句:
    delete from table_name where rowid=rowid_of_the_new_row;
    执行此语句将撤销原始更改。
    对于DELETE语句来说,因为整个行(可能多达数KB)都被写入撤销块,因此,可以通过构建完整行插入回表的语句,根据需要回滚这个删除操作。

    4.事务的开始和结束

    会话开始事务的时间从它发出DML命令时开始。事务持续执行任何数量的DML命令,知道会话发出COMMIT或者ROLLBACK语句为止。只有提交的变更才会变的永久,才会对其他会话可见。不可能嵌套事务,SQL标准不允许用户启动一个事务,然后在终止第一个事务之前再启动另一个事务。使用PL/SQL(Oracle专有的第三代语言)可以这样做,但它不是行业标准的SQL。
    显示事务控制语句有COMMIT、ROLLBACK、SAVEPOINT。除了用户发出的COMMIT或者ROLLBACK之外,还有一些情况会隐式终止事务:
    1.发出DDL或DCL语句
    2.退出用户工具(SQL*PLUS、SQL Developer或者其他工具)
    3.客户会话终止
    4.系统崩溃
    如果用户发出DDL(CREATE、ALTER或DROP)或者DCL(GRANT或REVOKE)命令,就会提交正在处理的事务(如果有的话):会让它变的永久,并且对其他所有用户都可见。这是因为DDL和DCL命令本身都是事务。因为在SQL中不可能嵌套事务,所以如果用户已经在运行事务,就会提交用户已经运行的语句,以及组成DDL和DCL的语句。
    如果用户通过发出DML命令来启动事务,然后在没有显示发出COMMIT或者ROLLBACK命令的情况下退出正在使用的工具,事务就会终止——但是使用COMMIT终止还是ROLLBACK终止,则完全取决于如何写工具。许多工具有不同的行为,这取决于退出工具的方式。不管在哪种情况下,都应该是受控制的退出,因此编程人员应该发出COMMIT或ROLLBACK命令。但他们必须进行选择。
    如果客户的会话因为某种原因而失败,那么数据库总是会回滚事务。这种失败可能有多种原因:用户进程终止或者在操作系统级别被终止,到数据库服务器的网络连接中断,或者运行该客户工具的计算机崩溃。在所有这些情况中,都没有依次发出COMMIT或ROLLBACK语句,现在轮到数据库来检测发生的情况。行为是终止会话,回滚活动的事务。如果失败发生在服务器端,其行为也是这样。如果数据库服务器因为某种原因崩溃,那么当它下一次启动时,就会回滚来自所有会话的所有之前正在处理的事务。

    3.事务控制

    oracle的关系数据库范例的实现通过第一个DML语句隐式开始执行某个事务。事务一直延续到COMMIT或ROLLBACK语句执行为止。SAVEPOINT命令不是SQL标准的一部分,实际上是编程人员反向撤销一些语句的简便方式。不需要单独考虑它,它不终止事务。

    1.COMMIT命令

    许多人(甚至某些经验丰富的DBA)在提交处理这个环节上都会出现不完全或者完全错误的理解oracle体系结构的情况。执行COMMIT命令时发生的所有物理操作时LGWR进程将日志缓冲区的内容刷新到磁盘。DBWn进程完全没有执行任何操作。对于oracle数据库来说,这是一个非常重要的性能特性。
    注意:执行COMMIT命令时,DBWn进程不会进行任何操作。 
    为了使某个事务持久,所需的全部工作是将组成这个事务的变更写入磁盘(不必使实际表数据存在于磁盘的数据文件上)。如果变更以多重重做日志文件的形式存在于磁盘上,那么在出现使数据库受损的事件时,通过从数据库受损前所做的备份中还原数据文件以及应用重做日志文件中的变更,就可以重新实例化事务。

    2.ROLLBACK命令

    在事务处理过程中,Oracle会保存事务处理之前数据的映像。在事务处理过程中,会将这个映像提供给查询数据的其他会话。如果出现错误,或者会话故意请求回滚,那么它也可以用来自动回滚事务。
    回滚之前数据的状态是,数据已经改变,但反转这些变更所需的信息是可用的。为了满足隔离性原则,会将这些信息提供给其他所有会话。回滚会恢复数据改变之前的映像,从而抛弃所有变更;事务插入的所有行都会删除,事务删除的所有行都会重新插入表中,已经更新的行会回到原始状态。其他会话根本不知道发生了什么,它们绝对看不到这些变更。处理事务的会话现在会将数据看做事务开始之前的数据。

    3.SAVEPOINT命令

    使用保存点就是允许编程人员在事务中设置一个标记,这个标记可以用来控制ROLLBACK命令的效果。除了回滚整个事务并终止它之外,还可以反转在特定点之后所做的所有变更,同时保持在该点之前所做的变更不变。事务本身继续进行:仍然没有提交,仍然可以回滚,仍然对其他会话不可见。

    4.SELECT FOR UPDATE

    最后一个事务控制语句是SELECT FOR UPDATE。在默认情况下,Oracle提供最高级别的并发性:读者不打断写者,写者也不打断读者。或者简单的说,一个会话查询另一个会话正在更新的数据,或者一个会话更新另一个会话正在查询的数据,这都没有问题。然而,有时需要改变这种行为,防止改变正在被查询的数据。
    应用程序使用SELECT命令检索一组行,将它们提供给用户精读,并给用户提示所做的变更,这种情况不是不常见。因为ORACLE是一个多用户数据库,所以另一个会话也要检索这些行也不是不可能。如果这两个会话都要做出变更,那么会出现一些奇怪的效果。
    第一个用户查询一个表:
    select * from emp;
    这时会出现N条数据,其中包括id=1的数据;
    第二个用户删除emp表一条数据
    delete from emp where id=1;
    然后第一个用户想修改id=1的数据
    update emp set name='test' where id=1;
    此时会出现“0 rows updated”。
    这使人感觉有点茫然。解决这个问题的方法之一就是锁定用户感兴趣的行:
    select * from emp for update;
    FOR UPDATE子句会锁定所有检索的行。除了发出命令的会话之外,其他任何会话都不能改变它们,因此后面的更新操作就会成功。这意味着一个会话有一致的数据视图(不会改变),但付出的代价是如果其他会话要更新锁定的行,它们就会挂起(当天他们可以查询)。
    在发出命令的会话发出COMMIT或ROLLBACK命令之前,会一直保持FOR UPDATE子句设置的锁定。必须这样来释放锁定,即使没有执行DML命令。

    5.所谓的“自动提交”

    在结束对提交处理的讨论之前,我们有必要阐明一下经常被提及的“自动提交”(有时候也被称为隐式提交)。您经常会听到这样的说法:Oracle在某些情况下可以进行”自动提交“。执行DDL语句就是其中一种情况,退出某个用户进程(SQL*Plus)则是另一种情况。
    ”自动提交“纯属子虚乌有。执行某条DDL语句时,实现这个DDL命令的源代码包含了一个完全正规的COMMIT命令。但是,退出用户进程时的情况是怎样呢?如果在WINDOWS终端上使用SQL*Plus并执行一条DML语句,然后再执行”退出“命令,就会提交事务。这是因为SQL*Plus中的”退出“命令嵌入了一条COMMIT语句。但是,单击SQL*Plus窗口的右上角会出现怎样的情况呢?此时,关闭SQL*Plus窗口,如果再次登录SQL*Plus,您会发现已回滚了事务。这是因为为Microsoft Windows编写SQL*Plus的编程人员在关闭SQL*Plus窗口的代码中嵌入了一条ROLLBACK语句。SQL*Plusz在其他平台上的行为可能有所不同,唯一的确认方法是测试。因此,以不同方式退出某个程序时是否能够进行”自动提交“完全取决于编程人员如果编写用户进程。Oracle服务器只是按照指令进行操作。






    展开全文
  • Oracle事务学习笔记

    千次阅读 2011-12-05 22:17:20
    ORACLE事务学习笔记   有关事务的语句 commit, rollback, savepoint, settransaction   drop table t2 purge; create table t2 (x int);     drop table t3 purge; create table t3 (x int check(x>0)...
  • oracle事务的隔离级别

    2019-12-11 09:44:04
    一、事务和隔离级别  事务的概念;事务是把对数据库的一系列操作都看做一个整体,要么全部成功,要么全部失败,利用事务我们可以保证数据库的完整性,事务具有原子性。  隔离级别:隔离级别定义了事务事务之间的...
  • oracle 事务隔离级别

    2012-04-07 16:47:27
    事务的4个基本特征   当事务处理系统创建事务时,将确保事务有某些特性。组件的开发者们假设事务的特性应该是一些不需要他们亲自管理的特性。这些特性称为ACID特性。 ACID就是:原子性(Atomicity )、一致性...
  • oracle事务学习与笔记

    2020-04-27 02:30:37
    1、 什么是事务 事务是作为单个逻辑工作单元执行的一系列操作。一个逻辑工作单元必须有四个属性,称为ACID(原子性、一致性、隔离性和持久性)属性,只有这样才能成为一个事务: 原子性:事务必须是原子工作单元;...
  • 回顾什么是事务? 一个不可分割的子操作形成一个整体,该整体要么全部执行成功,要么全部执行失败。例如:转帐 回顾为什么要用事务? 如果不用事务的话,为转帐为例,可能出现一个用户钱增加了,另一个用户钱...
  • 用示例比较Oracle的 Read committed 和Serializable 事务隔离等级的区别,给出SQL...Read committed读已提交事务隔离等级Oracle 默认隔离等级,支持不可重复读和幻读。 Serializable 事务隔离等级:只能
  • 设置一个事务的 隔离级别 SET   TRANSACTION   ISOLATION  LEVEL  READ  COMMITTED; SET   TRANSACTION   ISOLATION  LEVEL SERIALIZABLE; ET  TRANSACTION   READ   ONLY ; ...
  • 查看ORACLE事务隔离级别方法

    千次阅读 2015-02-11 17:03:32
    众所周知,事务的隔离级别有序列化(serializable),可重复读(repeatable read),读已提交(read committed),读未提交(read uncommitted)。根据隔离级别的等级,对事务隔...
  • Oracle事务探索与实例》 一数据库版本 SYS@LEO1>select*fromv$version; BANNER -------------------------------------------------------------------------------- OracleDatabase11gEnterprise...
  • 众所周知,事务的隔离级别有序列化...根据隔离级别的等级,对事务隔离的严格度也不同,如序列化的隔离级别最严格,并发的效果就越不理想,各种数据库都有对事务隔离的支持,那么如何查看ORACLE事务的隔离...
  • Oracle事务-视图-同义词-序列-索引 详解 -------------------------------------------------------------------------------------准备篇 col empno for 9999; col ename for a10; col job for a10; col mgr for ...
  • Oracle基础 事务

    2015-01-07 15:54:00
    一、事务  事务就是业务上的一个逻辑单元,它能够保证其中对数据所有的操作,要么全部成功,要么全部失败。 二、事务的特性:  1、原子性:事务是SQL中的最小执行单位,不能再进行分割。要么全部执行,要么...
  • 在前一篇文章中提到ANSI定义的事务隔离级别标准(http://blog.csdn.net/u010415792/article/details/8977635),但各个厂商实现的方式却不尽相同,本文主要介绍Oracle实现的事务隔离级别,Oracle所有的隔离等级都...
  • 事务自动提交,我们可以设置oracle自动提交事务 实例 LEO1@LEO1>show autocommit; 默认是不启动自动提交的 autocommit OFF LEO1@LEO1>set autocommit on; 手工启动 LEO1@LEO1>show autocommit; ...
  • [Oracle Transaction]Oracle数据库事务

    千次阅读 2007-07-09 22:47:00
    本人的Blog更新:http://www.iwllsea.com/default.asp?cateID=9,涉及更多Oracle文章,希望对大家有所帮助。 1.0摘要本篇主要介绍什么是事务以及对数据库操作时如何控制事务。2.0内容1、 什么是事务2、 事务的...
  • Oracle 嵌套事务与自治事务思考

    千次阅读 2010-10-14 23:58:00
    源文出自:http://hwhuang.javaeye.com/blog/650903 关键字  嵌套事务和自治事务的概念  嵌套事务的使用  自治事务的使用 一. 概念 1. 嵌套事务(Nested Transaction): 指在一个Parent事务中嵌套的一个或多...
  • 一. 概念 1. 嵌套事务(Nested Transaction): 指在一个Parent事务中嵌套的一个或多个Sub Transaction.并且主事务与其相互影响,这种事务就称为嵌套事务。以Commit作为事务的结束。 2. 自治事务(Autonomous ...
  • Oracle事务开始:第一条DML操作做为事务开始 Oracle的提交事务 (1)显示提交:commit (2)隐藏提交:DDL/DCL/exit(sqlplus工具) 注意:提交是的从事务开始到事务提交中间的内容,提交到ORCL数据库中的...
  • oracle 自主事务

    2011-10-11 10:19:04
     i_type number default 10 --错误等级0-9错误,10-99警告  ) is  pragma autonomous_transaction;  begin  insert into dw_log_error  (log_id, log_runid, log_type, log_append)  values  ...
  • (一)什么是事务 事务:  事务是指作为单个逻辑工作单元执行的一组相关操作。   这些操作要求全部完成或者全部不完成。 使用事务的原因:保证数据的安全有效。 事务的四个特点:(ACID)  1、原子性...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,185
精华内容 3,674
关键字:

oracle事务等级