精华内容
下载资源
问答
  • 关于oracle autonomous transaction autonomous transaction 翻译成中文叫自治事务,多好的名字,一听名字就明白 大半的意思了。autonmous transaction 是一...
    关于oracle autonomous transaction
     autonomous transaction 翻译成中文叫自治事务,多好的名字,一听名字就明白
    大半的意思了。autonmous transaction 是一个独立的事务,是由于main transaction调用而产生的。
    autonomous transaction的独立性
    autonomous transaction 是一个独立的事务,这一点是理解autonomous transaction 
    的关键,虽然受main transaction 的调用。下面用一个例子来加深理解。
    创建一个测试表,往其中插入两条记录,不提交,接着声明一个自治事务,在其中继续
    往表中插入记录,并且在自治事务对插入的记录进行提交。我们从输出中可以知道main
    transaction 和 autonomous transaction 的控制是独立开来的。autonomous transaction
    的提交不会提交main transaction ,main transaction 的回滚也不会影响到 autonomous 
    transaction。
    SQL> create table test_at(id number,name varchar2(20));
    Table created.
    SQL> insert into test_at values(1000,'oracle');
    1 row created.
    SQL> insert into test_at values(1001,'db2');
    1 row created.
    SQL> ed
    Wrote file afiedt.buf
      1  declare
      2    pragma autonomous_transaction;
      3  begin
      4    for i in 1002 .. 1010 loop
      5    insert into test_at values(i,'redis');
      6    end loop;
      7    commit;
      8* end;
    SQL> /
    PL/SQL procedure successfully completed.
    SQL> select * from test_at;
            ID NAME
    ---------- ----------------------------------------
          1000 oracle
          1001 db2
          1002 redis
          1003 redis
          1004 redis
          1005 redis
          1006 redis
          1007 redis
          1008 redis
          1009 redis
          1010 redis
    11 rows selected.
    SQL> rollback;
    Rollback complete.
    SQL> select * from test_at;
            ID NAME
    ---------- ----------------------------------------
          1002 redis
          1003 redis
          1004 redis
          1005 redis
          1006 redis
          1007 redis
          1008 redis
          1009 redis
          1010 redis
    9 rows selected.
    autonomous transaction 与dead lock 
    autonomous transaction 尝试lock main transaction lock 的资源的话,将会
    发生死锁。main transaction 调用autonomous transaction 后会被挂起,但是
    他所持有的资源还是保持着,这时候如果autonomous transaction 试图访问
    main transaction 持有的资源。autonomous transaction 不可能请求的到,
    所以autonomous transaction 不能继续下去,也就导致了main transaction
    无法继续走。死锁就发生了。
    SQL> ed
    Wrote file afiedt.buf
      1  create or replace procedure p_at as
      2    pragma autonomous_transaction;
      3  begin
      4    update test_at
      5    set name = 'mysql'
      6    where name = 'redis';
      7    commit;
      8* end p_at;
    SQL> /
    Procedure created.
    SQL> ed
    Wrote file afiedt.buf
      1  begin
      2    update test_at
      3    set name = 'mysql'
      4    where name = 'redis';
      5    p_at;
      6    commit;
      7* end;
    SQL> /
    begin
    *
    ERROR at line 1:
    ORA-00060: 等待资源时检测到死锁
    ORA-06512: 在 "SYS.P_AT", line 4
    ORA-06512: 在 line 5
    autonomous transaction 与 rollback
    autonomous transaction 中必须包括rollback,commit 。autonomous transaction 
    出错的时候将会被回滚掉,即使有exception handle.
    SQL> ed
    Wrote file afiedt.buf
      1  declare
      2     pragma autonomous_transaction;
      3  begin
      4     update test_at
      5     set name = 'mysql'
      6     where name = 'redis';
      7* end;
    SQL> /
    declare
    *
    ERROR at line 1:
    ORA-06519: 检测到活动的独立的事务处理, 已经回退
    ORA-06512: 在 line 7
    SQL> select * from test_at;
            ID NAME
    ---------- ----------------------------------------
          1002 redis
          1003 redis
          1004 redis
          1005 redis
          1006 redis
          1007 redis
          1008 redis
          1009 redis
          1010 redis
    9 rows selected.
    SQL> ed
    Wrote file afiedt.buf
      1  declare
      2     pragma autonomous_transaction;
      3  begin
      4     update test_at
      5     set name = 'mysql'
      6     where name = 'redis';
      7  exception
      8     when others then
      9     dbms_output.put_line('Error!,rollback or commit.');
     10* end;
    SQL> /
    PL/SQL procedure successfully completed.
    SQL>  select * from test_at;
            ID NAME
    ---------- ----------------------------------------
          1002 redis
          1003 redis
          1004 redis
          1005 redis
          1006 redis
          1007 redis
          1008 redis
          1009 redis
          1010 redis
    9 rows selected.
    autonomous transaction 的小运用
    autonomous transaction 的独立性是非常重要的,可以使调用他的main transaction
    不需要额外的事务控制语句来控制调用的模块,结合exception handle 可以实现简单的
    日志登记功能。
    SQL> ed
    Wrote file afiedt.buf
      1  create table error_logs
      2  ( id number(10),
      3    user_name varchar2(30),
      4    timestamp timestamp,
      5*   error_msg varchar2(1000))
    SQL> /
    Table created.
    SQL> alter table error_logs add constraint error_logs_pk primary key (id);
    Table altered.
    SQL> ed
    Wrote file afiedt.buf
      1* create sequence error_logs_seq
    SQL> /
    Sequence created.
    SQL> ed
    Wrote file afiedt.buf
      1  create or replace procedure log_errors(error_message in varchar2) as
      2    pragma autonomous_transaction;
      3  begin
      4    insert into error_logs(id,user_name,timestamp,error_msg)
      5    values(error_logs_seq.nextval,user,systimestamp,error_message);
      6    commit;
      7* end log_errors;
    SQL> /
    Procedure created.
    SQL> alter table test_at add constraint test_at_pk primary key (id);
    Table altered.
    SQL> ed
    Wrote file afiedt.buf
      1  begin
      2    insert into test_at
      3    values(1010,'mysql');
      4    insert into test_at
      5    values(1011,'mssql');
      6  exception
      7    when others then
      8      log_errors(sqlerrm);
      9      rollback;
     10* end;
    SQL> /
    PL/SQL procedure successfully completed.
    SQL> select * from test_at
      2  where id >= 1010;
            ID NAME
    ---------- ----------------------------------------
          1010 redis
    SQL> select * from error_logs;
            ID USER_NAME  TIMESTAMP                            ERROR_MSG
    ---------- ---------- ------------------------------------ ----------------------------------------------
             1 SYS        16-5月 -12 10.44.16.316000 下午      ORA-00001: 违反唯一约束条件 (SYS.TEST_AT_PK)
    小结:autonomous transaction 在pl/sql 编程中是比较重要的部分,也是比较容易出现问题的部分。虽然上面讨论了autonomous transaction 的几个方面,其实很多地方还可以继续深入,如果有兴趣可以自己找资料研究。不过我个人认为除非有需要,否则有些知识够用就好,人生有崖,学无涯啊。

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

    转载于:http://blog.itpub.net/26110315/viewspace-729971/

    展开全文
  • PRAGMA AUTONOMOUS_TRANSACTION(自治事务)

    万次阅读 2012-06-19 10:52:25
    这段时间遇到一个问题,程序里明明插入了一条记录,但在...PRAGMA AUTONOMOUS_TRANSACTION中文翻译过来叫“自治事务”(翻译的还算好理解),对于定义自治事务的Procedure,实际上相当于一段独立运行的程序段,这段程

    这段时间遇到一个问题,程序里明明插入了一条记录,但在后边的一段Procedure中却查不到刚刚插入的记录,最后发现这个Procedure的定义中加入了PRAGMA AUTONOMOUS_TRANSACTION

    PRAGMA AUTONOMOUS_TRANSACTION中文翻译过来叫“自治事务”(翻译的还算好理解),对于定义成自治事务的Procedure,实际上相当于一段独立运行的程序段,这段程序不依赖于主程序,也不干涉主程序


    自治事务的特点

    第一,这段程序不依赖于原有Main程序,比如Main程序中有未提交的数据,那么在自治事务中是查找不到的。

    第二,在自治事务中,commit或者rollback只会提交或回滚当前自治事务中的DML,不会影响到Main程序中的DML。


    Autonomous Transaction Demo 1

    Without Pragma Autonomous Transaction

    CREATE TABLE t (
    test_value VARCHAR2(25));
    
    CREATE OR REPLACE PROCEDURE child_block IS
    
    BEGIN
      INSERT INTO t
      (test_value)
      VALUES
      ('Child block insert');
      COMMIT;
    END child_block;
    /
    
    CREATE OR REPLACE PROCEDURE parent_block IS
    
    BEGIN
      INSERT INTO t
      (test_value)
      VALUES
      ('Parent block insert');
    
       child_block;
    
       ROLLBACK;
    END parent_block;
    /
    
    -- run the parent procedure
    exec parent_block
    
    -- check the results
    SELECT * FROM t;

    Output:
    Parent block insert
    Child block insert
    With Pragma Autonomous Transaction
    CREATE OR REPLACE PROCEDURE child_block IS
    
    PRAGMA AUTONOMOUS_TRANSACTION;
    
    BEGIN
      INSERT INTO t
      (test_value)
      VALUES
      ('Child block insert');
    
      COMMIT;
    END child_block;
    /
    
    CREATE OR REPLACE PROCEDURE parent_block IS
    
    BEGIN
      INSERT INTO t
      (test_value)
      VALUES
      ('Parent block insert');
    
       child_block;
    
       ROLLBACK;
    END parent_block;
    /
    -- empty the test table
    TRUNCATE TABLE t;
    
    -- run the parent procedure
    exec parent_block;
    
    -- check the results
    SELECT * FROM t;
    Output:
    Child block insert

    Autonomous Transaction Demo 2

    Without Pragma Autonomous Transaction

    DROP TABLE t;
    
    CREATE TABLE t (testcol NUMBER);
    
    CREATE OR REPLACE FUNCTION howmanyrows RETURN INTEGER IS
     i INTEGER;
    BEGIN
      SELECT COUNT(*)
      INTO i
      FROM t;
    
      RETURN i;
    END howmanyrows;
    /
    
    CREATE OR REPLACE PROCEDURE testproc IS
     a INTEGER;
     b INTEGER;
     c INTEGER;
    BEGIN
      SELECT COUNT(*)
      INTO a
      FROM t;
    
      INSERT INTO t VALUES (1);
      COMMIT;
    
      INSERT INTO t VALUES (2);
      INSERT INTO t VALUES (3);
    
      b := howmanyrows;
    
      INSERT INTO t VALUES (4);
      INSERT INTO t VALUES (5);
      INSERT INTO t VALUES (6);
      COMMIT;
    
      SELECT COUNT(*)
      INTO c
      FROM t;
    
      dbms_output.put_line(a);
      dbms_output.put_line(b);
      dbms_output.put_line(c);
    END testproc;
    /
    
    set serveroutput on
    
    exec testproc
    Output:
    0
    3
    6
    Total execution time 2.782 sec.
    With Pragma Autonomous Transaction

    CREATE OR REPLACE FUNCTION howmanyrows RETURN INTEGER IS
     i INTEGER;
    
     PRAGMA AUTONOMOUS_TRANSACTION;
    BEGIN
      SELECT COUNT(*)
      INTO i
      FROM t;
    
      RETURN i;
    END howmanyrows;
    /
    
    -- empty the test table
    TRUNCATE TABLE t;
    
    exec testproc;
    Output:
    0
    1
    6
    
    转载请注明出处:http://blog.csdn.net/pan_tian/article/details/7675800

    展开全文
  • 关于这个模式的中文翻译,网上有很多,有的翻译成补偿模式,个人认为也没有什么不妥,个人在阅读了官方材料后,结合模式的特点,翻译成事务修正模式.个人认为这个模式是云计算设计模式中,与云环境结合最紧密的模式,...

    1.前言

    上一篇我们讲到了云计算设计模式之断路器模式  今天我们来聊聊云计算设计模式之Compensating Transaction Pattern(事务修正模式).关于这个模式的中文翻译,网上有很多,有的翻译成补偿模式,个人认为也没有什么不妥,个人在阅读了官方材料后,结合模式的特点,翻译成事务修正模式.个人认为这个模式是云计算设计模式中,与云环境结合最紧密的模式,也是构建大型分布式应用最佳实践的模式.然而,官方文档中在讨论何时使用这种模式时却说:

    Use this pattern only for operations that must be undone if they fail. If possible, design solutions to avoid the complexity of requiring compensating transactions.

    仅仅在操作失败时必须回滚的情形下才使用这种模式,否则,就设计一种解决方案来避免使用这种设计模式带来的复杂度.

    翻译可能比较生硬,但大致的意思还是很明白的,那就是:不到万不得已,否则不要用这种模式.言外之意,这种模式的复杂度可能带来更为复杂而难以解决的问题.真是如著名的Martin Flower所说的那句名言,使用设计模式最好的方式就是不要使用任何设计模式.这也道出了设计模式使用的原则,不要为了使用模式而使用模式,必须是业务上确实有需要再使用,否则引起的问题比带来的好处还多,那就得不偿失了.

    2.背景

    事务的概念相信大家都十分清楚了,事务最重要的特性就是:要么不做,要么全做!.在传统的应用中,如果一个操作涉及多个数据表,那么在代码或者数据库层次都可以很好地做事务的控制,.NET和JAVA开发语言都提供了这种机制,数据库也可以使用try/catch结合Trsaction的机制做控制.那么在云环境中有什么不同呢?在云环境中,通常服务都是分布在不同服务器,甚至是不同的地理区域,数据也分布在不同的数据源中,一个操作可能设计到调用多个服务,如果一旦某个步骤调用失败,回滚就非常麻烦了.

    回滚不仅仅只是把原来的数据或者服务器状态置为开始状态这么简单,因为这条数据很可能被另外一个进程给修改掉了,如果考虑这种并发的情形,那么数据回滚就变得几乎不可能了;如果你觉得这种情形下事务回滚最麻烦的地方仅此而已,那就大错特错了,最麻烦的是,回滚的时候必须按照任务执行的反方向进行撤销操作,那么回滚的过程也可能会失败,这才是最可怕的地方。考虑到上面所述的情形,我们就很有必要解释事务修正模式了.

    3.事务修正模式

    官方对于事务修正模式是如何解决这个问题的是这样说的:

    A common approach to implementing an eventually consistent operation that requires compensation is to use a workflow. As the original operation proceeds, the system records information about each step and how the work performed by that step can be undone. If the operation fails at any point, the workflow rewinds back through the steps it has completed and performs the work that reverses each step. Note that a compensating transaction might not have to undo the work in the exact mirror-opposite order of the original operation, and it may be possible to perform some of the undo steps in parallel.

    实现事务修正模式的通常做法是使用工作流.在原始操作执行时,系统会记录每个执行步骤的信息及该步骤如何回滚的信息.如果事务在任何一步执行失败,工作流将根据这些记录的信息来回滚已经执行的操作。值得注意的是,在回滚的过程中,回滚的步骤不必与原始操作一一镜像对应(与原始步骤相反),每个回滚步骤都可以并行执行。

    官方的说法已经可以非常清除地解释了事务修正模式的基本原理和做法.每一个执行步骤自己负责自己的回滚.并且这些"自治"的回滚是幂等的,也就是说这些单个的回滚是可以retry的,回滚操作无论执行多少次,结果和执行一次都是一样的,这就最大程度地保证了回滚操作失败的可能性。不过万一某个步骤回滚retry也不行呢?那么这时候就需要应用发出警告或者错误给应用管理员,管理员可以根据失败步骤所记录的信息及回滚的操作命令,很轻松地定位问题及手动执行回滚。

    4.示例


    A travel website enables customers to book itineraries. A single itinerary may comprise a series of flights and hotels. A customer traveling from Seattle to London and then on to Paris could perform the following steps when creating an itinerary:

    1. Book a seat on flight F1 from Seattle to London.
    2. Book a seat on flight F2 from London to Paris.
    3. Book a seat on flight F3 from Paris to Seattle.
    4. Reserve a room at hotel H1 in London.
    5. Reserve a room at hotel H2 in Paris.

    These steps constitute an eventually consistent operation, although each step is essentially a separate atomic action in its own right. Therefore, as well as performing these steps,the system must also record the counter operations necessary to undo each step in case the customer decides to cancel the itinerary.The steps necessary to perform the counter operations can then run as a compensating transaction if necessary.

    Notice that the steps in the compensating transaction might not be the exact opposite of the original steps, and the logic in each step in the compensating transaction must take into account any business-specific rules. For example, “unbooking” a seat on a flight might not entitle the customer to a complete refund of any money paid.

    在这个例子中也并非所有时候都需要执行回滚.因为事务修正能不用则不用。

    In many business solutions, failure of a single step does not always necessitate rolling the system back by using a compensating transaction. For example, if—after having booked flights F1, F2, and F3 in the travel website scenario—the customer is unable to reserve a room at hotel H1, it is preferable to offer the customer a room at a different hotel in the same city rather than cancelling the flights. The customer may still elect to cancel (in which case the compensating transaction runs and undoes the bookings made on flights F1, F2, and F3), but this decision should be made by the customer rather than by the system.

    5.相关阅读

    The following patterns and guidance may also be relevant when implementing this pattern:

    • Data Consistency Primer. The Compensating Transaction pattern is frequently used to undo operations that implement the eventual consistency model. This primer provides more information on the benefits and tradeoffs of eventual consistency.
    • Scheduler-Agent-Supervisor Pattern. This pattern describes how to implement resilient systems that perform business operations that utilize distributed services and resources. In some circumstances, it may be necessary to undo the work performed by an operation by using a compensating transaction.
    • Retry Pattern. Compensating transactions can be expensive to perform, and it may be possible to minimize their use by implementing an effective policy of retrying failing operations by following the Retry pattern.

    展开全文
  • 这段时间遇到一个问题,程序里明明插入了一条记录,...PRAGMA AUTONOMOUS_TRANSACTION中文翻译过来叫“自治事务”(翻译的还算好理解),对于定义自治事务的Procedure,实际上相当于一段独立运行的程序段,这段程...

    这段时间遇到一个问题,程序里明明插入了一条记录,但在后边的一段Procedure中却查不到刚刚插入的记录,最后发现这个Procedure的定义中加入了PRAGMA AUTONOMOUS_TRANSACTION。

    PRAGMA AUTONOMOUS_TRANSACTION中文翻译过来叫“自治事务”(翻译的还算好理解),对于定义成自治事务的Procedure,实际上相当于一段独立运行的程序段,这段程序不依赖于主程序,也不干涉主程序

    自治事务的特点

    第一,这段程序不依赖于原有Main程序,比如Main程序中有未提交的数据,那么在自治事务中是查找不到的。

    第二,在自治事务中,commit或者rollback只会提交或回滚当前自治事务中的DML,不会影响到Main程序中的DML。

     

    Autonomous Transaction Demo 1

    Without Pragma Autonomous Transaction

     

    1.  
      CREATE TABLE t (
    2.  
      test_value VARCHAR2(25));
    3.  
       
    4.  
      CREATE OR REPLACE PROCEDURE child_block IS
    5.  
       
    6.  
      BEGIN
    7.  
      INSERT INTO t
    8.  
      (test_value)
    9.  
      VALUES
    10.  
      ('Child block insert');
    11.  
      COMMIT;
    12.  
      END child_block;
    13.  
      /
    14.  
       
    15.  
      CREATE OR REPLACE PROCEDURE parent_block IS
    16.  
       
    17.  
      BEGIN
    18.  
      INSERT INTO t
    19.  
      (test_value)
    20.  
      VALUES
    21.  
      ('Parent block insert');
    22.  
       
    23.  
      child_block;
    24.  
       
    25.  
      ROLLBACK;
    26.  
      END parent_block;
    27.  
      /
    28.  
       
    29.  
      -- run the parent procedure
    30.  
      exec parent_block
    31.  
       
    32.  
      -- check the results
    33.  
      SELECT * FROM t;

     

     

    1.  
      Output:
    2.  
      Parent block insert
    3.  
      Child block insert

    With Pragma Autonomous Transaction

    1.  
      CREATE OR REPLACE PROCEDURE child_block IS
    2.  
       
    3.  
      PRAGMA AUTONOMOUS_TRANSACTION;
    4.  
       
    5.  
      BEGIN
    6.  
      INSERT INTO t
    7.  
      (test_value)
    8.  
      VALUES
    9.  
      ('Child block insert');
    10.  
       
    11.  
      COMMIT;
    12.  
      END child_block;
    13.  
      /
    14.  
       
    15.  
      CREATE OR REPLACE PROCEDURE parent_block IS
    16.  
       
    17.  
      BEGIN
    18.  
      INSERT INTO t
    19.  
      (test_value)
    20.  
      VALUES
    21.  
      ('Parent block insert');
    22.  
       
    23.  
      child_block;
    24.  
       
    25.  
      ROLLBACK;
    26.  
      END parent_block;
    27.  
      /
    28.  
      -- empty the test table
    29.  
      TRUNCATE TABLE t;
    30.  
       
    31.  
      -- run the parent procedure
    32.  
      exec parent_block;
    33.  
       
    34.  
      -- check the results
    35.  
      SELECT * FROM t;
    1.  
      Output:
    2.  
      Child block insert

     

     

    Autonomous Transaction Demo 2

    Without Pragma Autonomous Transaction

     

     

    1.  
      DROP TABLE t;
    2.  
       
    3.  
      CREATE TABLE t (testcol NUMBER);
    4.  
       
    5.  
      CREATE OR REPLACE FUNCTION howmanyrows RETURN INTEGER IS
    6.  
      i INTEGER;
    7.  
      BEGIN
    8.  
      SELECT COUNT(*)
    9.  
      INTO i
    10.  
      FROM t;
    11.  
       
    12.  
      RETURN i;
    13.  
      END howmanyrows;
    14.  
      /
    15.  
       
    16.  
      CREATE OR REPLACE PROCEDURE testproc IS
    17.  
      a INTEGER;
    18.  
      b INTEGER;
    19.  
      c INTEGER;
    20.  
      BEGIN
    21.  
      SELECT COUNT(*)
    22.  
      INTO a
    23.  
      FROM t;
    24.  
       
    25.  
      INSERT INTO t VALUES (1);
    26.  
      COMMIT;
    27.  
       
    28.  
      INSERT INTO t VALUES (2);
    29.  
      INSERT INTO t VALUES (3);
    30.  
       
    31.  
      b := howmanyrows;
    32.  
       
    33.  
      INSERT INTO t VALUES (4);
    34.  
      INSERT INTO t VALUES (5);
    35.  
      INSERT INTO t VALUES (6);
    36.  
      COMMIT;
    37.  
       
    38.  
      SELECT COUNT(*)
    39.  
      INTO c
    40.  
      FROM t;
    41.  
       
    42.  
      dbms_output.put_line(a);
    43.  
      dbms_output.put_line(b);
    44.  
      dbms_output.put_line(c);
    45.  
      END testproc;
    46.  
      /
    47.  
       
    48.  
      set serveroutput on
    49.  
       
    50.  
      exec testproc
    1.  
      Output:
    2.  
      0
    3.  
      3
    4.  
      6
    5.  
      Total execution time 2.782 sec.

    With Pragma Autonomous Transaction

     

     

    1.  
      CREATE OR REPLACE FUNCTION howmanyrows RETURN INTEGER IS
    2.  
      i INTEGER;
    3.  
       
    4.  
      PRAGMA AUTONOMOUS_TRANSACTION;
    5.  
      BEGIN
    6.  
      SELECT COUNT(*)
    7.  
      INTO i
    8.  
      FROM t;
    9.  
       
    10.  
      RETURN i;
    11.  
      END howmanyrows;
    12.  
      /
    13.  
       
    14.  
      -- empty the test table
    15.  
      TRUNCATE TABLE t;
    16.  
       
    17.  
      exec testproc;
    1.  
      Output:
    2.  
      0
    3.  
      1
    4.  
      6

    转载请注明出处:http://blog.csdn.net/pan_tian/article/details/7675800

    转载于:https://www.cnblogs.com/circlesmart/p/9375539.html

    展开全文
  • 错误,翻译成中文就是“绑定器事务失败”,实际的原因就是使用intent的时候携带的数据太大导致传递失败。  Intent携带数据的大小受限Binder缓存的大小,Binder缓存的大小大约为1M,但有可能其他地方也存在缓存,...
  • 问题描述: ...中文翻译就是: 事务已回滚,因为它被标记了只回滚 代码片段: // 我的代码 @Transactional(readOnly = true, rollbackFor = Exception.class) public String select(Stri
  • 来解释一下我们平时使用事务遇到的一个问题但让很多人又很棘手的问题:Transaction rolled back because it has been marked as rollback-only,中文翻译为:事务已回滚,因为它被标记了只回滚。囧,中文翻译出来...
  • gtidgtid全称:Global transaction identifiers,翻译成中文:全局事务标记,由server的uuid和transation id拼接而成。00015630-1111-1111-1111-111111111111:200015630-1111-1111-1111-111111111111:4-700015630-...
  • UTXO的全称是Unspent Transaction Output 翻译成中文就是“未被花费的交易输出”,它是比特币采用的特有的一种账户结构。在比特币中,一笔交易的实际运作的方式是:花费UTXO的一个集合,这些输出由一个或多个之前的...
  • UTXO的全称是 Unspent Transaction Output 翻译成中文就是“未被花费的交易输出”,它是比特币采用的特有的一种账户结构。在比特币中,一笔交易的实际运作的方式是:花费UTXO的一个集合,这些输出由一个或多个之前的...
  • 一、(了解)定义全称(Transaction Control Language)翻译成中文 事务控制语言,事务是访问并可能更新数据库各种数据项的一个程序执行单元,是并发控制的单元,是用户定义的一个操作序列。这些操作要么都做,要么都不做...
  • 中文翻译为:事务已回滚,因为它被标记了只回滚。 这个异常,相信写代码多年的大家,都遇到过,什么原因呢?今天我们专门分析一下,以为前车之鉴。 报错信息详情 关键报错信息:org.springframework....
  • Spring的事物回滚问题

    2020-12-15 21:52:12
    来解释一下我们平时使用事务遇到的一个问题但让很多人又很棘手的问题:Transaction rolled back because it has been marked as rollback-only,中文翻译为:事务已回滚,因为它被标记了只回滚。囧,中文翻译出来...
  • PRAGMA AUTONOMOUS_TRANSACTION中文翻译过来叫“自治事务”,对于定义自治事务的Procedure,实际上相当于一段独立运行的程序段,这段程序不依赖于主程序,也不干涉主程序。 自治事务的常用于 事务的原子性会使将...
  • session和cookie关系

    2009-10-29 10:16:00
    一、术语session在被传递给客户端之前将被改写在我的经验里,session这个词被滥用的程度大概仅次于transaction,更加有趣的是transaction与session在某些语境下的含义是相同的。session,中文经常翻译为会话,其...
  • Java面试宝典2010版

    2011-06-27 09:48:27
    12.金额转换,阿拉伯数字的金额转换中国传统的形式如:(¥1011)->(一千零一拾一元整)输出。 三. html&JavaScript&ajax部分 1. 判断第二个日期比第一个日期大 2. 用table显示n条记录,每3行换一次颜色,即...
  • 最新Java面试宝典pdf版

    热门讨论 2011-08-31 11:29:22
    12.金额转换,阿拉伯数字的金额转换中国传统的形式如:(¥1011)->(一千零一拾一元整)输出。 81 三. html&JavaScript&ajax部分 82 1. 判断第二个日期比第一个日期大 82 2. 用table显示n条记录,每3行换一次...
  • 12.金额转换,阿拉伯数字的金额转换中国传统的形式如:(¥1011)->(一千零一拾一元整)输出。 81 三. html&JavaScript&ajax部分 82 1. 判断第二个日期比第一个日期大 82 2. 用table显示n条记录,每3行换一次...
  • Java 面试宝典

    2013-02-01 10:02:08
    7、char 型变量中能不能存贮一个中文汉字?为什么? ................................................ 10 8、用最有效率的方法算出 2 乘以 8 等於几? ..............................................................

空空如也

空空如也

1 2
收藏数 21
精华内容 8
关键字:

transaction翻译成中文