Android SQLite 支持嵌套事务吗？

Android SQLite相关java源码中多次提到支持 nested transaction。

而SQLite本身不支持嵌套事务，只能使用 savepoint 代替。 https://www.sqlite.org/lang_savepoint.html

嵌套事务即是类似于

BEGIN
     BEGIN
     ......

也许没有太多人会直接这样写，更多情况是，一个程序执行事务中调用了其他程序，而其他程序有自己的事务。

通过查看Android源码发现：

Android所谓的支持嵌套事务，只是屏蔽掉子事务的 begin end，只有最外层事务的begin end 有效。同时，子事务出错会导致整个嵌套事务出错，整个回滚。

当然，SQL SERVER好像也没有支持真正的嵌套事务，了解不太详细。

--------------------------------------------------------------------------------------

Android SQLite 关于嵌套事务的处理，均位于SqliteSession，多数数据库相关操作的调用流程均为 SQLiteDataBase --> SqliteSeesion --> SqliteConnectionPool --> SqliteConnection。稍后详细分析。只需知道，SQLiteDatabase.beginTransacion() 调用的是SQLiteSeesion.beginTransacion()，其他类似。如下

    public void beginTransaction() {
        beginTransaction(null, true);
    } 
    private void beginTransaction(SQLiteTransactionListener transactionListener, boolean exclusive) {
        acquireReference();
        try {
            getThreadSession().beginTransaction( //--- 获取线程session，开始事务
                    exclusive ? SQLiteSession.TRANSACTION_MODE_EXCLUSIVE :
                            SQLiteSession.TRANSACTION_MODE_IMMEDIATE,
                    transactionListener,
                    getThreadDefaultConnectionFlags(false /*readOnly*/), null);
        } finally {
            releaseReference();
        }
    }

--------------------------------------------------------------------

SQLiteSeesion中相关成员有以下需要注意：

    private Transaction mTransactionPool;   // 事务池
    private Transaction mTransactionStack;  // 事务栈

    private static final class Transaction {
        public Transaction mParent;
        public int mMode;
        public SQLiteTransactionListener mListener;
        public boolean mMarkedSuccessful;
        public boolean mChildFailed;
    }

可以猜想，事务栈、事务池其实是又 mParent联系起来的两条事务链。

先看 beginTransaction。

    public void beginTransaction( /*省略参数*/ ) {
        throwIfTransactionMarkedSuccessful();
        beginTransactionUnchecked( /*省略参数*/ );
    }

    private void beginTransactionUnchecked( /*省略参数*/ ) {
        //... 
        if (mTransactionStack == null) {  // 事务栈为空 获取新连接
            acquireConnection(null, connectionFlags, cancellationSignal);
        }
        try {
            if (mTransactionStack == null) {  // 事务栈为空 执行“begin” 
                switch (transactionMode) {    // 事务栈不为空 直接略过 
                    case TRANSACTION_MODE_IMMEDIATE:
                        mConnection.execute("BEGIN IMMEDIATE;", null, cancellationSignal);
                        break;
                    case TRANSACTION_MODE_EXCLUSIVE:
                        mConnection.execute("BEGIN EXCLUSIVE;", null, cancellationSignal);
                        break;
                    default:
                        mConnection.execute("BEGIN;", null, cancellationSignal);
                        break;
                }
            }

            //... 省略监听 transactionListener
                                                                                           
            Transaction transaction = obtainTransaction(transactionMode, transactionListener);	// 获取新的事务
            transaction.mParent = mTransactionStack;   // 将事务加入事务栈中
            mTransactionStack = transaction;
        } finally {
            if (mTransactionStack == null) {
                releaseConnection(); // might throw
            }
        }
    }

获取新事务 obtainTransaction()如下

    private Transaction obtainTransaction(int mode, SQLiteTransactionListener listener) {
        Transaction transaction = mTransactionPool;  // 事务池中有事务，直接提取事务
        if (transaction != null) {
            mTransactionPool = transaction.mParent;                                            
            transaction.mParent = null;
            transaction.mMarkedSuccessful = false;
            transaction.mChildFailed = false;
        } else {
            transaction = new Transaction();        // 否则新建
        }
        transaction.mMode = mode;
        transaction.mListener = listener;
        return transaction;
    }

由上可以看出，事务栈开始为空， 不断beginTransaction时会向事务栈中添加事务。那么事务池中的事务怎么来的呢？

在endTransaction中：

    public void endTransaction(CancellationSignal cancellationSignal) {
        throwIfNoTransaction();
        assert mConnection != null;

        endTransactionUnchecked(cancellationSignal, false);
    }

    private void endTransactionUnchecked(CancellationSignal cancellationSignal, boolean yielding) {
        final Transaction top = mTransactionStack;  // 获取事务栈的top事务
        boolean successful = (top.mMarkedSuccessful || yielding) && !top.mChildFailed;
                        	                                       
        //... 省略监听
        mTransactionStack = top.mParent; // 将top从事务栈中剔除
        recycleTransaction(top);         // 将top放入事务池中

        if (mTransactionStack != null) { // 事务栈不为空
            if (!successful) {           // 如果未成功 将该事务的子事务置为失败
                mTransactionStack.mChildFailed = true;
            }
        } else {
            try {                        // 事务栈为空
                if (successful) {        // 若成功 则提交 此时意味着所有事务都已经成功
                    mConnection.execute("COMMIT;", null, cancellationSignal); 
                } else {                 // 不成功 就回滚 此时一个子事务未成功 则整个事务体系未成功
                    mConnection.execute("ROLLBACK;", null, cancellationSignal);
                }
            } finally {
                releaseConnection(); 
            }
        }
    }

    private void recycleTransaction(Transaction transaction) { 
        transaction.mParent = mTransactionPool; // 其实就是将事务放入事务池
        transaction.mListener = null;
        mTransactionPool = transaction;
    }

可以看到，事务池中的事务由事务栈中使用完毕的事务组成。不用的放入事务池，使用时直接提取，并将状态初始化。

也可以看出，事务池是为了避免Transaction多次new delete 的开销。事务栈中保存了正在执行的嵌套事务。

事务栈、事务池如下

setTransactionSuccessful()就比较简单了：

    public void setTransactionSuccessful() {        // 标记当前事务成功
        throwIfNoTransaction();
        throwIfTransactionMarkedSuccessful();

        mTransactionStack.mMarkedSuccessful = true; // mTransactionStack指向的就是最近的一个事务 如图

    }

----------------------------------------------------------------------

执行beginTransaction()：

当事务栈为空，说明没有外层事务，获取transaction，执行“BEGIN”，然后将transaction放入事务栈。

事务栈不为空，说明含有外层事务，获取transaction，不执行“BEGIN”，将transaction放入事务栈。

执行endTransaction()：

查看successful，当本事务成功且内层事务成功，才算成功；将该事务从事务栈移入事务池。

当事务栈不为空，说明仍有外层事务，如果successful为价，将该事物置为子事务失败

当事务栈为空，说明已是最外层事务，successful则提交，否则回滚。

可以看到，嵌套事务中，无论哪一层事务出错，都会自其开始直至最外层事务标记为false，回滚。只有每一层都标记成功，最后才成功。

需要注意的是，yield会对嵌套事务successful的标记产生影响，使得当前事务无论如何都标记为成功。android不推荐在嵌套事务中使用yield。