Merge pull request #1058 from h2database/txcommit-atomic

Txcommit atomic

h2/src/main/org/h2/engine/Database.java

@@ -737,6 +737,9 @@ public class Database implements DataHandler {
         systemUser.setAdmin(true);
         systemSession = new Session(this, systemUser, ++nextSessionId);
         lobSession = new Session(this, systemUser, ++nextSessionId);
+        if(mvStore != null) {
+            mvStore.getTransactionStore().init(systemSession);
+        }
         CreateTableData data = new CreateTableData();
         ArrayList<Column> cols = data.columns;
         Column columnId = new Column("ID", Value.INT);
@@ -762,6 +765,7 @@ public class Database implements DataHandler {
         metaIdIndex = meta.addIndex(systemSession, "SYS_ID",
                 0, pkCols, IndexType.createPrimaryKey(
                 false, false), true, null);
+        systemSession.commit(true);
         objectIds.set(0);
         starting = true;
         Cursor cursor = metaIdIndex.find(systemSession, null, null);
@@ -777,6 +781,7 @@ public class Database implements DataHandler {
                 rec.execute(this, systemSession, eventListener);
             }
         }
+        systemSession.commit(true);
         if (mvStore != null) {
             mvStore.initTransactions();
             mvStore.removeTemporaryMaps(objectIds);

h2/src/main/org/h2/engine/Session.java

@@ -30,10 +30,12 @@ import org.h2.jdbc.JdbcConnection;
 import org.h2.message.DbException;
 import org.h2.message.Trace;
 import org.h2.message.TraceSystem;
+import org.h2.mvstore.MVMap;
 import org.h2.mvstore.db.MVTable;
 import org.h2.mvstore.db.MVTableEngine;
-import org.h2.mvstore.tx.TransactionStore.Change;
+import org.h2.mvstore.tx.TransactionStore;
 import org.h2.mvstore.tx.Transaction;
+import org.h2.mvstore.tx.VersionedValue;
 import org.h2.result.ResultInterface;
 import org.h2.result.Row;
 import org.h2.result.SortOrder;
@@ -59,7 +61,7 @@ import org.h2.value.ValueString;
  * mode, this object resides on the server side and communicates with a
  * SessionRemote object on the client side.
  */
-public class Session extends SessionWithState {
+public class Session extends SessionWithState implements TransactionStore.RollbackListener {
 
     /**
      * This special log position means that the log entry has been written.
@@ -649,20 +651,22 @@ public class Session extends SessionWithState {
         currentTransactionName = null;
         transactionStart = 0;
         if (transaction != null) {
-            // increment the data mod count, so that other sessions
-            // see the changes
-            // TODO should not rely on locking
-            if (!locks.isEmpty()) {
-                for (Table t : locks) {
-                    if (t instanceof MVTable) {
-                        ((MVTable) t).commit();
+            try {
+                // increment the data mod count, so that other sessions
+                // see the changes
+                // TODO should not rely on locking
+                if (!locks.isEmpty()) {
+                    for (Table t : locks) {
+                        if (t instanceof MVTable) {
+                            ((MVTable) t).commit();
+                        }
                     }
                 }
+                transaction.commit();
+            } finally {
+                transaction = null;
             }
-            transaction.commit();
-            transaction = null;
-        }
-        if (containsUncommitted()) {
+        } else if (containsUncommitted()) {
             // need to commit even if rollback is not possible
             // (create/drop table and so on)
             database.commit(this);
@@ -768,18 +772,9 @@ public class Session extends SessionWithState {
         checkCommitRollback();
         currentTransactionName = null;
         transactionStart = 0;
-        boolean needCommit = false;
-        if (undoLog.size() > 0) {
-            rollbackTo(null, false);
-            needCommit = true;
-        }
-        if (transaction != null) {
+        boolean needCommit = undoLog.size() > 0 || transaction != null;
+        if(needCommit) {
             rollbackTo(null, false);
-            needCommit = true;
-            // rollback stored the undo operations in the transaction
-            // committing will end the transaction
-            transaction.commit();
-            transaction = null;
         }
         if (!locks.isEmpty() || needCommit) {
             database.commit(this);
@@ -806,29 +801,11 @@ public class Session extends SessionWithState {
             undoLog.removeLast(trimToSize);
         }
         if (transaction != null) {
-            long savepointId = savepoint == null ? 0 : savepoint.transactionSavepoint;
-            HashMap<String, MVTable> tableMap =
-                    database.getMvStore().getTables();
-            Iterator<Change> it = transaction.getChanges(savepointId);
-            while (it.hasNext()) {
-                Change c = it.next();
-                MVTable t = tableMap.get(c.mapName);
-                if (t != null) {
-                    long key = ((ValueLong) c.key).getLong();
-                    ValueArray value = (ValueArray) c.value;
-                    short op;
-                    Row row;
-                    if (value == null) {
-                        op = UndoLogRecord.INSERT;
-                        row = t.getRow(this, key);
-                    } else {
-                        op = UndoLogRecord.DELETE;
-                        row = createRow(value.getList(), Row.MEMORY_CALCULATE);
-                    }
-                    row.setKey(key);
-                    UndoLogRecord log = new UndoLogRecord(t, op, row);
-                    log.undo(this);
-                }
+            if (savepoint == null) {
+                transaction.rollback();
+                transaction = null;
+            } else {
+                transaction.rollbackToSavepoint(savepoint.transactionSavepoint);
             }
         }
         if (savepoints != null) {
@@ -841,6 +818,13 @@ public class Session extends SessionWithState {
                 }
             }
         }
+
+        // Because cache may have captured query result (in Query.lastResult),
+        // which is based on data from uncommitted transaction.,
+        // It is not valid after rollback, therefore cache has to be cleared.
+        if(queryCache != null) {
+            queryCache.clear();
+        }
     }
 
     @Override
@@ -1112,7 +1096,7 @@ public class Session extends SessionWithState {
      */
     public boolean containsUncommitted() {
         if (database.getMvStore() != null) {
-            return transaction != null;
+            return transaction != null && transaction.hasChanges();
         }
         return firstUncommittedLog != Session.LOG_WRITTEN;
     }
@@ -1688,7 +1672,7 @@ public class Session extends SessionWithState {
                     database.shutdownImmediately();
                     throw DbException.get(ErrorCode.DATABASE_IS_CLOSED);
                 }
-                transaction = store.getTransactionStore().begin();
+                transaction = store.getTransactionStore().begin(this);
             }
             startStatement = -1;
         }
@@ -1768,6 +1752,62 @@ public class Session extends SessionWithState {
         tablesToAnalyze.add(table);
     }
 
+    @Override
+    public void onRollback(MVMap<Object, VersionedValue> map, Object key,
+                            VersionedValue existingValue,
+                            VersionedValue restoredValue) {
+        // Here we are relying on the fact that map which backs table's primary index
+        // has the same name as the table itself
+        MVTableEngine.Store store = database.getMvStore();
+        if(store != null) {
+            MVTable table = store.getTable(map.getName());
+            if (table != null) {
+                long recKey = ((ValueLong)key).getLong();
+                Row oldRow = getRowFromVersionedValue(table, recKey, existingValue);
+                Row newRow = getRowFromVersionedValue(table, recKey, restoredValue);
+                table.fireAfterRow(this, oldRow, newRow, true);
+
+                if (table.getContainsLargeObject()) {
+                    if (oldRow != null) {
+                        for (int i = 0, len = oldRow.getColumnCount(); i < len; i++) {
+                            Value v = oldRow.getValue(i);
+                            if (v.isLinkedToTable()) {
+                                removeAtCommit(v);
+                            }
+                        }
+                    }
+                    if (newRow != null) {
+                        for (int i = 0, len = newRow.getColumnCount(); i < len; i++) {
+                            Value v = newRow.getValue(i);
+                            if (v.isLinkedToTable()) {
+                                removeAtCommitStop(v);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private static Row getRowFromVersionedValue(MVTable table, long recKey,
+                                                VersionedValue versionedValue) {
+        Object value = versionedValue == null ? null : versionedValue.value;
+        if (value == null) {
+            return null;
+        }
+        Row result;
+        if(value instanceof Row) {
+            result = (Row) value;
+            assert result.getKey() == recKey : result.getKey() + " != " + recKey;
+        } else {
+            ValueArray array = (ValueArray) value;
+            result = table.createRow(array.getList(), 0);
+            result.setKey(recKey);
+        }
+        return result;
+    }
+
+
     /**
      * Represents a savepoint (a position in a transaction to where one can roll
      * back to).

h2/src/main/org/h2/mvstore/MVStore.java

@@ -1103,11 +1103,11 @@ public class MVStore {
                 }
             }
         } finally {
-             // in any case reset the current store version,
-             // to allow closing the store
-             currentStoreVersion = -1;
-             currentStoreThread.set(null);
-         }
+            // in any case reset the current store version,
+            // to allow closing the store
+            currentStoreVersion = -1;
+            currentStoreThread.set(null);
+        }
     }
 
     private void storeNow() {

h2/src/main/org/h2/mvstore/db/MVTableEngine.java

@@ -162,7 +162,7 @@ public class MVTableEngine implements TableEngine {
                 this.transactionStore = new TransactionStore(
                         store,
                         new ValueDataType(db.getCompareMode(), db, null));
-                transactionStore.init();
+//                transactionStore.init();
             } catch (IllegalStateException e) {
                 throw convertIllegalStateException(e);
             }
@@ -206,8 +206,8 @@ public class MVTableEngine implements TableEngine {
             return transactionStore;
         }
 
-        public HashMap<String, MVTable> getTables() {
-            return new HashMap<>(tableMap);
+        public MVTable getTable(String tableName) {
+            return tableMap.get(tableName);
         }
 
         /**

h2/src/main/org/h2/mvstore/tx/Transaction.java

@@ -81,13 +81,24 @@ public class Transaction {
      */
     final TransactionStore store;
 
+    /**
+     * Listener for this transaction's rollback changes.
+     */
+    final TransactionStore.RollbackListener listener;
+
     /**
      * The transaction id.
+     * More appropriate name for this field would be "slotId"
      */
     final int transactionId;
 
+    /**
+     * This is really a transaction identity, because it's not re-used.
+     */
+    public final long sequenceNum;
+
     /*
-     * Transation state is an atomic composite field:
+     * Transaction state is an atomic composite field:
      * bit  45      : flag whether transaction had rollback(s)
      * bits 44-41   : status
      * bits 40      : overflow control bit, 1 indicates overflow
@@ -99,12 +110,16 @@ public class Transaction {
 
     private String name;
 
-    Transaction(TransactionStore store, int transactionId, int status,
-                String name, long logId) {
+    boolean wasStored;
+
+    Transaction(TransactionStore store, int transactionId, long sequenceNum, int status,
+                String name, long logId, TransactionStore.RollbackListener listener) {
         this.store = store;
         this.transactionId = transactionId;
+        this.sequenceNum = sequenceNum;
         this.statusAndLogId = new AtomicLong(composeState(status, logId, false));
         this.name = name;
+        this.listener = listener;
     }
 
     public int getId() {
@@ -151,9 +166,9 @@ public class Transaction {
                             currentStatus == STATUS_COMMITTED ||
                             currentStatus == STATUS_ROLLED_BACK;
                     break;
-               default:
-                   valid = false;
-                   break;
+                default:
+                    valid = false;
+                    break;
             }
             if (!valid) {
                 throw DataUtils.newIllegalStateException(
@@ -168,6 +183,10 @@ public class Transaction {
         }
     }
 
+    public boolean hasChanges() {
+        return hasChanges(statusAndLogId.get());
+    }
+
     public void setName(String name) {
         checkNotClosed();
         this.name = name;
@@ -257,7 +276,7 @@ public class Transaction {
      * @return the transaction map
      */
     public <K, V> TransactionMap<K, V> openMap(String name,
-                                               DataType keyType, DataType valueType) {
+                                                DataType keyType, DataType valueType) {
         MVMap<K, VersionedValue> map = store.openMap(name, keyType, valueType);
         return openMap(map);
     }
@@ -289,10 +308,12 @@ public class Transaction {
      * Commit the transaction. Afterwards, this transaction is closed.
      */
     public void commit() {
+        assert store.openTransactions.get().get(transactionId);
         long state = setStatus(STATUS_COMMITTING);
         long logId = Transaction.getLogId(state);
-        int oldStatus = Transaction.getStatus(state);
-        store.commit(this, logId, oldStatus);
+        boolean hasChanges = hasChanges(state);
+
+        store.commit(this, logId, hasChanges);
     }
 
     /**
@@ -330,7 +351,7 @@ public class Transaction {
                 store.rollbackTo(this, logId, 0);
             }
         } finally {
-            store.endTransaction(this, STATUS_ROLLED_BACK);
+            store.endTransaction(this, true);
         }
     }
 
@@ -373,7 +394,7 @@ public class Transaction {
     @Override
     public String toString() {
         long state = statusAndLogId.get();
-        return transactionId + " " +  STATUS_NAMES[getStatus(state)] + " " + getLogId(state);
+        return transactionId + "(" + sequenceNum + ") " + STATUS_NAMES[getStatus(state)] + " " + getLogId(state);
     }
 
 

h2/src/main/org/h2/mvstore/tx/TransactionMap.java

@@ -47,7 +47,7 @@ public class TransactionMap<K, V> {
     final Transaction transaction;
 
     TransactionMap(Transaction transaction, MVMap<K, VersionedValue> map,
-                   int mapId) {
+                    int mapId) {
         this.transaction = transaction;
         this.map = map;
         this.mapId = mapId;

h2/src/main/org/h2/mvstore/tx/TransactionStore.java

@@ -11,6 +11,8 @@ import java.util.BitSet;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.atomic.AtomicReferenceArray;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import org.h2.mvstore.DataUtils;
 import org.h2.mvstore.MVMap;
@@ -18,7 +20,6 @@ import org.h2.mvstore.MVStore;
 import org.h2.mvstore.WriteBuffer;
 import org.h2.mvstore.type.DataType;
 import org.h2.mvstore.type.ObjectDataType;
-import org.h2.util.New;
 
 /**
  * A store that supports concurrent MVCC read-committed transactions.
@@ -62,17 +63,52 @@ public class TransactionStore {
 
     private final DataType dataType;
 
-    private final BitSet openTransactions = new BitSet();
+    /**
+     * This BitSet is used as vacancy indicator for transaction slots in transactions[].
+     * It provides easy way to find first unoccupied slot, and also allows for copy-on-write
+     * non-blocking updates.
+     */
+    final AtomicReference<VersionedBitSet> openTransactions = new AtomicReference<>(new VersionedBitSet());
+
+    /**
+     * This is intended to be the source of ultimate truth about transaction being committed.
+     * Once bit is set, corresponding transaction is logically committed,
+     * although it might be plenty of "uncommitted" entries in various maps
+     * and undo record are still around.
+     * Nevertheless, all of those should be considered by other transactions as committed.
+     */
+    final AtomicReference<BitSet> committingTransactions = new AtomicReference<>(new BitSet());
 
     private boolean init;
 
-    private int maxTransactionId = 0xffff;
+    /**
+     * Soft limit on the number of concurrently opened transactions.
+     * Not really needed but used by some test.
+     */
+    private int maxTransactionId = MAX_OPEN_TRANSACTIONS;
+
+    /**
+     * Array holding all open transaction objects.
+     * Position in array is "transaction id".
+     * VolatileReferenceArray would do the job here, but there is no such thing in Java yet
+     */
+    private final AtomicReferenceArray<Transaction> transactions =
+                                                        new AtomicReferenceArray<>(MAX_OPEN_TRANSACTIONS + 1);
 
     /**
      * The next id of a temporary map.
      */
     private int nextTempMapId;
 
+
+    /**
+     * Hard limit on the number of concurrently opened transactions
+     */
+    // TODO: introduce constructor parameter instead of a static field, driven by URL parameter
+    private static final int MAX_OPEN_TRANSACTIONS = 65535;
+
+
+
     /**
      * Create a new transaction store.
      *
@@ -113,25 +149,54 @@ public class TransactionStore {
      * If the transaction store is corrupt, this method can throw an exception,
      * in which case the store can only be used for reading.
      */
-    public synchronized void init() {
-        init = true;
-        // remove all temporary maps
-        for (String mapName : store.getMapNames()) {
-            if (mapName.startsWith("temp.")) {
-                MVMap<Object, Integer> temp = openTempMap(mapName);
-                store.removeMap(temp);
+    public void init() {
+        init(RollbackListener.NONE);
+    }
+
+    public synchronized void init(RollbackListener listener) {
+        if (!init) {
+            // remove all temporary maps
+            for (String mapName : store.getMapNames()) {
+                if (mapName.startsWith("temp.")) {
+                    MVMap<Object, Integer> temp = openTempMap(mapName);
+                    store.removeMap(temp);
+                }
             }
-        }
-        rwLock.writeLock().lock();
-        try {
-            if (undoLog.size() > 0) {
-                for (Long key : undoLog.keySet()) {
-                    int transactionId = getTransactionId(key);
-                    openTransactions.set(transactionId);
+            rwLock.writeLock().lock();
+            try {
+                if (!undoLog.isEmpty()) {
+                    Long key = undoLog.firstKey();
+                    while (key != null) {
+                        int transactionId = getTransactionId(key);
+                        if (!openTransactions.get().get(transactionId)) {
+                            Object[] data = preparedTransactions.get(transactionId);
+                            int status;
+                            String name;
+                            if (data == null) {
+                                if (undoLog.containsKey(getOperationId(transactionId, 0))) {
+                                    status = Transaction.STATUS_OPEN;
+                                } else {
+                                    status = Transaction.STATUS_COMMITTING;
+                                }
+                                name = null;
+                            } else {
+                                status = (Integer) data[0];
+                                name = (String) data[1];
+                            }
+                            long nextTxUndoKey = getOperationId(transactionId + 1, 0);
+                            Long lastUndoKey = undoLog.lowerKey(nextTxUndoKey);
+                            assert lastUndoKey != null;
+                            assert getTransactionId(lastUndoKey) == transactionId;
+                            long logId = getLogId(lastUndoKey) + 1;
+                            registerTransaction(transactionId, status, name, logId, listener);
+                            key = undoLog.ceilingKey(nextTxUndoKey);
+                        }
+                    }
                 }
+            } finally {
+                rwLock.writeLock().unlock();
             }
-        } finally {
-            rwLock.writeLock().unlock();
+            init = true;
         }
     }
 
@@ -143,6 +208,8 @@ public class TransactionStore {
      * @param max the maximum id
      */
     public void setMaxTransactionId(int max) {
+        DataUtils.checkArgument(max <= MAX_OPEN_TRANSACTIONS,
+                "Concurrent transactions limit is too high: {0}", max);
         this.maxTransactionId = max;
     }
 
@@ -200,32 +267,21 @@ public class TransactionStore {
      * @return the list of transactions (sorted by id)
      */
     public List<Transaction> getOpenTransactions() {
+        if(!init) {
+            init();
+        }
         rwLock.readLock().lock();
         try {
-            ArrayList<Transaction> list = New.arrayList();
-            Long key = undoLog.firstKey();
-            while (key != null) {
-                int transactionId = getTransactionId(key);
-                key = undoLog.lowerKey(getOperationId(transactionId + 1, 0));
-                long logId = getLogId(key) + 1;
-                Object[] data = preparedTransactions.get(transactionId);
-                int status;
-                String name;
-                if (data == null) {
-                    if (undoLog.containsKey(getOperationId(transactionId, 0))) {
-                        status = Transaction.STATUS_OPEN;
-                    } else {
-                        status = Transaction.STATUS_COMMITTING;
+            ArrayList<Transaction> list = new ArrayList<>();
+            int transactionId = 0;
+            BitSet bitSet = openTransactions.get();
+            while((transactionId = bitSet.nextSetBit(transactionId + 1)) > 0) {
+                Transaction transaction = getTransaction(transactionId);
+                if(transaction != null) {
+                    if(transaction.getStatus() != Transaction.STATUS_CLOSED) {
+                        list.add(transaction);
                     }
-                    name = null;
-                } else {
-                    status = (Integer) data[0];
-                    name = (String) data[1];
                 }
-                Transaction t = new Transaction(this, transactionId, status,
-                        name, logId);
-                list.add(t);
-                key = undoLog.ceilingKey(getOperationId(transactionId + 1, 0));
             }
             return list;
         } finally {
@@ -245,25 +301,54 @@ public class TransactionStore {
      *
      * @return the transaction
      */
-    public synchronized Transaction begin() {
+    public Transaction begin() {
+        return begin(RollbackListener.NONE);
+    }
+
+    /**
+     * Begin a new transaction.
+     * @param listener to be notified in case of a rollback
+     *
+     * @return the transaction
+     */
+    public Transaction begin(RollbackListener listener) {
+        Transaction transaction = registerTransaction(0, Transaction.STATUS_OPEN, null, 0, listener);
+        return transaction;
+    }
+
+    private Transaction registerTransaction(int txId, int status, String name, long logId,
+                                            RollbackListener listener) {
 
         int transactionId;
-        int status;
-        if (!init) {
-            throw DataUtils.newIllegalStateException(
-                    DataUtils.ERROR_TRANSACTION_ILLEGAL_STATE,
-                    "Not initialized");
-        }
-        transactionId = openTransactions.nextClearBit(1);
-        if (transactionId > maxTransactionId) {
-            throw DataUtils.newIllegalStateException(
-                    DataUtils.ERROR_TOO_MANY_OPEN_TRANSACTIONS,
-                    "There are {0} open transactions",
-                    transactionId - 1);
-        }
-        openTransactions.set(transactionId);
-        status = Transaction.STATUS_OPEN;
-        return new Transaction(this, transactionId, status, null, 0);
+        long sequenceNo;
+        boolean success;
+        do {
+            VersionedBitSet original = openTransactions.get();
+            if (txId == 0) {
+                transactionId = original.nextClearBit(1);
+            } else {
+                transactionId = txId;
+                assert !original.get(transactionId);
+            }
+            if (transactionId > maxTransactionId) {
+                throw DataUtils.newIllegalStateException(
+                        DataUtils.ERROR_TOO_MANY_OPEN_TRANSACTIONS,
+                        "There are {0} open transactions",
+                        transactionId - 1);
+            }
+            VersionedBitSet clone = original.clone();
+            clone.set(transactionId);
+            sequenceNo = clone.getVersion() + 1;
+            clone.setVersion(sequenceNo);
+            success = openTransactions.compareAndSet(original, clone);
+        } while(!success);
+
+        Transaction transaction = new Transaction(this, transactionId, sequenceNo, status, name, logId, listener);
+
+        assert transactions.get(transactionId) == null;
+        transactions.set(transactionId, transaction);
+
+        return transaction;
     }
 
     /**
@@ -276,6 +361,7 @@ public class TransactionStore {
                 t.getName() != null) {
             Object[] v = { t.getStatus(), t.getName() };
             preparedTransactions.put(t.getId(), v);
+            t.wasStored = true;
         }
     }
 
@@ -348,23 +434,30 @@ public class TransactionStore {
      *
      * @param t the transaction
      * @param maxLogId the last log id
-     * @param oldStatus last status
+     * @param hasChanges true if there were updates within specified
+     *                   transaction (even fully rolled back),
+     *                   false if just data access
      */
-    void commit(Transaction t, long maxLogId, int oldStatus) {
+    void commit(Transaction t, long maxLogId, boolean hasChanges) {
         if (store.isClosed()) {
             return;
         }
+        int transactionId = t.transactionId;
+        // this is an atomic action that causes all changes
+        // made by this transaction, to be considered as "committed"
+        flipCommittingTransactionsBit(transactionId, true);
+
         // TODO could synchronize on blocks (100 at a time or so)
         rwLock.writeLock().lock();
         try {
             for (long logId = 0; logId < maxLogId; logId++) {
-                Long undoKey = getOperationId(t.getId(), logId);
+                Long undoKey = getOperationId(transactionId, logId);
                 Object[] op = undoLog.get(undoKey);
                 if (op == null) {
                     // partially committed: load next
                     undoKey = undoLog.ceilingKey(undoKey);
                     if (undoKey == null ||
-                            getTransactionId(undoKey) != t.getId()) {
+                            getTransactionId(undoKey) != transactionId) {
                         break;
                     }
                     logId = getLogId(undoKey) - 1;
@@ -391,8 +484,20 @@ public class TransactionStore {
             }
         } finally {
             rwLock.writeLock().unlock();
+            flipCommittingTransactionsBit(transactionId, false);
         }
-        endTransaction(t, oldStatus);
+        endTransaction(t, hasChanges);
+    }
+
+    private void flipCommittingTransactionsBit(int transactionId, boolean flag) {
+        boolean success;
+        do {
+            BitSet original = committingTransactions.get();
+            assert original.get(transactionId) != flag : flag ? "Double commit" : "Mysterious bit's disappearance";
+            BitSet clone = (BitSet) original.clone();
+            clone.set(transactionId, flag);
+            success = committingTransactions.compareAndSet(original, clone);
+        } while(!success);
     }
 
     /**
@@ -465,7 +570,7 @@ public class TransactionStore {
      * @param mapName the map name
      * @return the map
      */
-    MVMap<Object, Integer> openTempMap(String mapName) {
+    private MVMap<Object, Integer> openTempMap(String mapName) {
         MVMap.Builder<Object, Integer> mapBuilder =
                 new MVMap.Builder<Object, Integer>().
                 keyType(dataType);
@@ -473,34 +578,56 @@ public class TransactionStore {
     }
 
     /**
-     * End this transaction
+     * End this transaction. Change status to CLOSED and vacate transaction slot.
+     * Will try to commit MVStore if autocommitDelay is 0 or if database is idle
+     * and amount of unsaved changes is sizable.
      *
      * @param t the transaction
-     * @param oldStatus status of this transaction
+     * @param hasChanges false for R/O tx
      */
-    synchronized void endTransaction(Transaction t, int oldStatus) {
-        if (oldStatus == Transaction.STATUS_PREPARED) {
-            preparedTransactions.remove(t.getId());
-        }
+    synchronized void endTransaction(Transaction t, boolean hasChanges) {
+        int txId = t.transactionId;
         t.setStatus(Transaction.STATUS_CLOSED);
-        openTransactions.clear(t.transactionId);
-        if (oldStatus == Transaction.STATUS_PREPARED || store.getAutoCommitDelay() == 0) {
-            store.tryCommit();
-            return;
-        }
-        // to avoid having to store the transaction log,
-        // if there is no open transaction,
-        // and if there have been many changes, store them now
-        if (undoLog.isEmpty()) {
-            int unsaved = store.getUnsavedMemory();
-            int max = store.getAutoCommitMemory();
-            // save at 3/4 capacity
-            if (unsaved * 4 > max * 3) {
+
+        assert transactions.get(txId) == t : transactions.get(txId) + " != " + t;
+        transactions.set(txId, null);
+
+        boolean success;
+        do {
+            VersionedBitSet original = openTransactions.get();
+            assert original.get(txId);
+            VersionedBitSet clone = original.clone();
+            clone.clear(txId);
+            success = openTransactions.compareAndSet(original, clone);
+        } while(!success);
+
+        if (hasChanges) {
+            boolean wasStored = t.wasStored;
+            if (wasStored && !preparedTransactions.isClosed()) {
+                preparedTransactions.remove(txId);
+            }
+            if (wasStored || store.getAutoCommitDelay() == 0) {
                 store.tryCommit();
+            } else {
+                // to avoid having to store the transaction log,
+                // if there is no open transaction,
+                // and if there have been many changes, store them now
+                if (undoLog.isEmpty()) {
+                    int unsaved = store.getUnsavedMemory();
+                    int max = store.getAutoCommitMemory();
+                    // save at 3/4 capacity
+                    if (unsaved * 4 > max * 3) {
+                        store.tryCommit();
+                    }
+                }
             }
         }
     }
 
+    Transaction getTransaction(int transactionId) {
+        return transactions.get(transactionId);
+    }
+
     /**
      * Rollback to an old savepoint.
      *
@@ -530,13 +657,15 @@ public class TransactionStore {
                 if (map != null) {
                     Object key = op[1];
                     VersionedValue oldValue = (VersionedValue) op[2];
+                    VersionedValue currentValue;
                     if (oldValue == null) {
                         // this transaction added the value
-                        map.remove(key);
+                        currentValue = map.remove(key);
                     } else {
                         // this transaction updated the value
-                        map.put(key, oldValue);
+                        currentValue = map.put(key, oldValue);
                     }
+                    t.listener.onRollback(map, key, currentValue, oldValue);
                 }
                 undoLog.remove(undoKey);
             }
@@ -561,22 +690,19 @@ public class TransactionStore {
             private long logId = maxLogId - 1;
             private Change current;
 
-            {
-                fetchNext();
-            }
-
             private void fetchNext() {
                 rwLock.writeLock().lock();
                 try {
+                    int transactionId = t.getId();
                     while (logId >= toLogId) {
-                        Long undoKey = getOperationId(t.getId(), logId);
+                        Long undoKey = getOperationId(transactionId, logId);
                         Object[] op = undoLog.get(undoKey);
                         logId--;
                         if (op == null) {
                             // partially rolled back: load previous
                             undoKey = undoLog.floorKey(undoKey);
                             if (undoKey == null ||
-                                    getTransactionId(undoKey) != t.getId()) {
+                                    getTransactionId(undoKey) != transactionId) {
                                 break;
                             }
                             logId = getLogId(undoKey);
@@ -584,15 +710,9 @@ public class TransactionStore {
                         }
                         int mapId = ((Integer) op[0]).intValue();
                         MVMap<Object, VersionedValue> m = openMap(mapId);
-                        if (m == null) {
-                            // map was removed later on
-                        } else {
-                            current = new Change();
-                            current.mapName = m.getName();
-                            current.key = op[1];
+                        if (m != null) { // could be null if map was removed later on
                             VersionedValue oldValue = (VersionedValue) op[2];
-                            current.value = oldValue == null ?
-                                    null : oldValue.value;
+                            current = new Change(m.getName(), op[1], oldValue == null ? null : oldValue.value);
                             return;
                         }
                     }
@@ -604,16 +724,19 @@ public class TransactionStore {
 
             @Override
             public boolean hasNext() {
+                if(current == null) {
+                    fetchNext();
+                }
                 return current != null;
             }
 
             @Override
             public Change next() {
-                if (current == null) {
+                if(!hasNext()) {
                     throw DataUtils.newUnsupportedOperationException("no data");
                 }
                 Change result = current;
-                fetchNext();
+                current = null;
                 return result;
             }
 
@@ -633,19 +756,53 @@ public class TransactionStore {
         /**
          * The name of the map where the change occurred.
          */
-        public String mapName;
+        public final String mapName;
 
         /**
          * The key.
          */
-        public Object key;
+        public final Object key;
 
         /**
          * The value.
          */
-        public Object value;
+        public final Object value;
+
+        public Change(String mapName, Object key, Object value) {
+            this.mapName = mapName;
+            this.key = key;
+            this.value = value;
+        }
     }
 
+    /**
+     * This listener can be registered with the transaction to be notified of
+     * every compensating change during transaction rollback.
+     * Normally this is not required, if no external resources were modified,
+     * because state of all transactional maps will be restored automatically.
+     * Only state of external resources, possibly modified by triggers
+     * need to be restored.
+     */
+    public interface RollbackListener {
+
+        RollbackListener NONE = new RollbackListener() {
+            @Override
+            public void onRollback(MVMap<Object, VersionedValue> map, Object key,
+                                    VersionedValue existingValue, VersionedValue restoredValue) {
+                // do nothing
+            }
+        };
+
+        /**
+         * Notified of a single map change (add/update/remove)
+         * @param map modified
+         * @param key of the modified entry
+         * @param existingValue value in the map (null if delete is rolled back)
+         * @param restoredValue value to be restored (null if add is rolled back)
+         */
+        void onRollback(MVMap<Object,VersionedValue> map, Object key,
+                        VersionedValue existingValue, VersionedValue restoredValue);
+    }
 
     /**
      * A data type that contains an array of objects with the specified data

h2/src/main/org/h2/mvstore/tx/VersionedBitSet.java

+/*
+ * Copyright 2004-2018 H2 Group. Multiple-Licensed under the MPL 2.0,
+ * and the EPL 1.0 (http://h2database.com/html/license.html).
+ * Initial Developer: H2 Group
+ */
+package org.h2.mvstore.tx;
+
+import java.util.BitSet;
+
+/**
+ * Class VersionedBitSet extends standard BitSet to add a version field.
+ * This will allow bit set and version to be changed atomically.
+ */
+final class VersionedBitSet extends BitSet
+{
+    private long version;
+
+    public VersionedBitSet() {}
+
+    public long getVersion() {
+        return version;
+    }
+
+    public void setVersion(long version) {
+        this.version = version;
+    }
+
+    @Override
+    public VersionedBitSet clone() {
+        return (VersionedBitSet)super.clone();
+    }
+}

h2/src/main/org/h2/mvstore/tx/VersionedValue.java

@@ -24,7 +24,7 @@ public class VersionedValue {
     /**
      * The value.
      */
-    final Object value;
+    public final Object value;
 
     VersionedValue(long operationId, Object value) {
         this.operationId = operationId;

h2/src/main/org/h2/table/Table.java

@@ -621,8 +621,12 @@ public abstract class Table extends SchemaObjectBase {
         }
     }
 
+    public Row createRow(Value[] data, int memory) {
+        return database.createRow(data, memory);
+    }
+
     public Row getTemplateRow() {
-        return database.createRow(new Value[columns.length], Row.MEMORY_CALCULATE);
+        return createRow(new Value[columns.length], Row.MEMORY_CALCULATE);
     }
 
     /**

h2/src/test/org/h2/test/store/TestMVStoreTool.java

@@ -107,7 +107,7 @@ public class TestMVStoreTool extends TestBase {
         assertEquals(size2, FileUtils.size(fileNameNew));
         MVStoreTool.compact(fileNameCompressed, true);
         assertEquals(size3, FileUtils.size(fileNameCompressed));
-        trace("Recompacted in " + (System.currentTimeMillis() - start) + " ms.");
+        trace("Re-compacted in " + (System.currentTimeMillis() - start) + " ms.");
 
         start = System.currentTimeMillis();
         MVStore s1 = new MVStore.Builder().

h2/src/tools/org/h2/build/doc/dictionary.txt

@@ -17,7 +17,7 @@ agent agentlib agg aggregate aggregated aggregates aggregating aggressive agile
 agrave agree agreeable agreed agreement agreements agrees ahead
 ahilmnqbjkcdeopfrsg aid air ajax alan alarm ale alefsym alert alessio alexander alfki
 algo algorithm algorithms alias aliased aliases aliasing align aligned alignment
-alive all allclasses alleged alleging allocate allocated allocates allocating
+alive all allclasses alleged alleging alloc allocate allocated allocates allocating
 allocation allow allowed allowing allows almost aload alone along alpha
 alphabetical alphabetically already also alt alter altering alternate alternative
 alternatives alters although always ambiguity ambiguous america among amount amp
@@ -108,11 +108,12 @@ combo combobox come comes coming comma command commands commas comment commented
 comments commercial commit commits committed committing common commonly commons
 communicates communication community comp compact compacted compacting compaction
 compacts companies company comparable comparative comparator compare compared
-compares comparing comparison comparisons compatibility compatible compensation
-compilable compilation compile compiled compiler compiles compiling complete
-completed completely completion complex complexity compliance compliant
+compares comparing comparison comparisons compatibility compatible
+compensation compensating compilable compilation compile compiled
+compiler compiles compiling complete completed completely
+completion complex complexity compliance compliant
 complicate complicated complies comply complying component components composed
-composite compound compounds compress compressed compresses compressibility
+compose composite compound compounds compress compressed compresses compressibility
 compressible compressing compression compressor compromise compsci computation
 compute computed computer computers computing con concat concatenate concatenated
 concatenates concatenating concatenation concentrate concept concerning concrete
@@ -187,8 +188,8 @@ differs dig digest digit digital digits diligence dim dimension dimensional
 dimensions dimitrijs dinamica dining dip dips dir direct direction directly
 directories directory directs dirname dirs dirty disable disabled
 disablelastaccess disables disabling disadvantage disadvantages disallow
-disallowed disappear disappeared disc disclaimed disclaimer disclaimers disclaims
-disclosed disconnect disconnected disconnecting disconnections disconnects
+disallowed disappear disappearance disappeared disc disclaimed disclaimer disclaimers
+disclaims disclosed disconnect disconnected disconnecting disconnections disconnects
 discontinue discount discriminator discussion disjunctive disk disks dispatch
 dispatcher display displayed displaying displays dispose disposed disposition
 disputes dist distance distinct distinguish distinguishable distinguished
@@ -212,16 +213,16 @@ effort egrave eid eing eins einstellung either elapsed eldest elect electronic
 element elements elephant elig eligible eliminate elisabetta ell ellipsis elm else
 elsewhere elton email emails embedded embedding embeds emergency emf emit emitted
 emma empire employee empty emsp emulate emulated emulates emulation enable
-enabled enables enabling enc encapsulates enclose enclosed enclosing encode
-encoded encoder encodes encoding encountered encounters encrypt encrypted
+enabled enables enabling enc encapsulate encapsulates enclose enclosed enclosing
+encode encoded encoder encodes encoding encountered encounters encrypt encrypted
 encrypting encryption encrypts end ended enderbury endif ending endings endless
 endlessly endorse ends enforce enforceability enforceable enforced engine engines
 english enhance enhanced enhancement enhancer enlarge enough enqueued ensp ensure
 ensures ensuring enter entered entering enterprise entire entities entity entrance
 entries entry enum enumerate enumerated enumerator enumerators enumeration env envelope
 environment environments enwiki eof eol epl epoch epoll epsilon equal equality equally
-equals equipment equitable equiv equivalent equivalents era erable eremainder eric
-erik err error errorlevel errors erwan ery esc escape escaped escapes escaping
+equals equipment equitable equiv equivalence equivalent equivalents era erable eremainder
+eric erik err error errorlevel errors erwan ery esc escape escaped escapes escaping
 escargots ese espa essential essentials established estimate estimated estimates
 estimating estimation estoppel eta etc eth etl euml euro europe europeu euros eva eval
 evaluatable evaluate evaluated evaluates evaluating evaluation evdokimov even evenly
@@ -301,8 +302,8 @@ ideas identical identification identified identifier identifiers identify identi
 identities identity idiomatic idiv idle ids idx idxname iee ieee iexcl iface ifeq
 ifexists ifge ifgt ifle iflt ifne ifnonnull ifnull iframe ifx ignore ignorecase ignored
 ignoredriverprivileges ignorelist ignores ignoring ignite igrave iinc ikura ikvm ikvmc
-illegal iload image imageio images imaginary img iml immediately immutable imola imp
-impact imperial impersonate impl imple implement implementation implementations
+illegal illegally iload image imageio images imaginary img iml immediately immutable
+imola imp impact imperial impersonate impl imple implement implementation implementations
 implemented implementing implements implication implicit implicitly implied
 implies import important imported importing imports impose imposes impossible
 improperly improve improved improvement improvements improves improving imul
@@ -373,8 +374,8 @@ literal literals litigation little live lives ljava llc lload lmul lneg lnot loa
 loaded loader loading loads lob lobs local localdb locale locales localhost
 locality localization localized localname locals locate located locates location
 locations locators lock locked locker locking locks log logback logged logger
-logging logic logical login logins logo logos logout logs logsize long longblob
-longer longest longitude longnvarchar longs longtext longvarbinary longvarchar
+logging logic logical logically login logins logo logos logout logs logsize long
+longblob longer longest longitude longnvarchar longs longtext longvarbinary longvarchar
 look lookahead looking looks lookup lookups lookupswitch loop loopback looping
 loops loose lor lore lose losing loss losses lossless losslessly lost lot lots
 low lowast lower lowercase lowercased lowest loz lpad lrem lreturn lrm lru lsaquo
@@ -412,20 +413,20 @@ mpl msg mssql mssqlserver msxml much mueller mul multi multianewarray multipart
 multiple multiples multiplication multiplied multiply multiplying multithreaded
 multithreading multiuser music must mutable mutate mutation mutationtest muttered
 mutton mutually mvc mvcc mvn mvr mvstore mydb myna myself mysql mysqladmin mysqld
-mystery mystic myydd nabla naive naked name namecnt named names namespace naming
-nan nano nanos nanosecond nanoseconds nantes napping national nations native
+mysterious mystery mystic myydd nabla naive naked name namecnt named names namespace
+naming nan nano nanos nanosecond nanoseconds nantes napping national nations native
 natural nature naur nav navigable navigate navigation navigator nbsp ncgc nchar
 nclob ncr ndash near nearest nearly necessarily necessary nederlands need needed
 needing needs neg negate negated negating negation negative negligence
 negotiations neighbor neither nelson neo nest nested nesterov nesting net
-netbeans netherlands netscape netstat network networked networks never new
-newarray newer newest newline newlines newly news newsfeed newsfeeds newsgroups
+netbeans netherlands netscape netstat network networked networks never nevertheless
+new newarray newer newest newline newlines newly news newsfeed newsfeeds newsgroups
 newsletter next nextval nfontes nger nice nicer nicolas night nih niklas nikolaj
 niku nine nio nls nlst noah nobody nobuffer nocache nocheck nocycle nodata nodded
-node nodelay nodes noel noframe noframes noindex noise nomaxvalue nominvalue non
-nonce noncompliance none noop nop nopack nopasswords nopmd nor noresize normal
-normalize normalized normally northern northwoods norway nosettings not nota
-notably notation notch note notes nothing notice notices notification notified
+node nodelay nodes noel noframe noframes noindex noinspection noise nomaxvalue
+nominvalue non nonce noncompliance none noop nop nopack nopasswords nopmd nor
+noresize normal normalize normalized normally northern northwoods norway nosettings
+not nota notably notation notch note notes nothing notice notices notification notified
 notifies notify notifying notin notranslate notwithstanding nougat nov novelist
 november now nowait nowrap npl nsi nsis nsub ntext ntfs nth ntilde nucleus nul
 null nullable nullid nullif nulls nullsoft num number numbering numbers numeral
@@ -471,7 +472,7 @@ petra pfgrc pfister pgdn pgup phane phantom phase phi philip philippe
 philosophers phone php phrase phrases phromros physical pick picked pickle pico
 pid pieces pier pietrzak pilot piman ping pinned pipe piped pit pitest piv pivot
 pkcolumn pkcs pktable place placed placeholders places placing plain plaintext
-plan planned planner planning plans plant platform platforms play player please
+plan planned planner planning plans plant plenty platform platforms play player please
 plug pluggable plugin plugins plus plusmn png point pointbase pointed pointer pointers
 pointing points poker poland polar pole poleposition policies policy polish poll
 polling polski poly polygon pom pondered poodle pool poolable pooled pooling
@@ -658,18 +659,18 @@ tools toolset top topic topics toplink topology tort total totals touch toward
 tpc trace traces tracing track tracked tracker tracking tracks trade trademark
 trademarks traditional traditionally trailing train trans transact transaction
 transactional transactionally transactions transfer transferred transferring
-transform transformation transient transiently transition transitional
+transform transformation transient transiently transition transitional transitioned
 transitions translatable translate translated translates translating translation
 translations translator transmission transmitted transparent transport travel
 traversal traverse traversing tray tread treat treated treatment trede tree trees
 trial trick tricky tried tries trig trigger triggered triggers trigonometric trim
 trimmed trims trip trivial trouble true trunc truncate truncated truncates
-truncating truncation trunk trust trusted trx try trying tsi tsmsys tsv tucc
+truncating truncation trunk trust trusted truth trx try trying tsi tsmsys tsv tucc
 tucker tuesday tune tunes tuning turkel turkish turn turned turns tutorial tweak
 tweaking tweet twelve twice twitter two txt tymczak type typed typeof types typesafe
 typical typically typing typlen typname typo typos typtypmod tzd tzh tzm tzr
 uacute uarr ubuntu ucase ucb ucirc ucs udt udts uffff ugly ugrave uid uint ujint
-ujlong ulimit uml umlaut umr unable unaligned unary unavailability unbound
+ujlong ulimit ultimate uml umlaut umr unable unaligned unary unavailability unbound
 uncached uncaught unchanged unchecked uncle unclear unclosed uncommitted uncommon
 uncompressed undefined under underflow undergraduate underline underlined
 underlying underneath underscore understand understanding understands understood
@@ -679,7 +680,7 @@ unindexed uninitialized uninstall uninteresting uninterpreted uninterruptible
 union unique uniquely uniqueness uniques unit united units universal universally
 unix unixtime unknown unless unlike unlikely unlimited unlink unlinked unload unloaded
 unloading unloads unlock unlocked unlocking unlocks unmaintained unmappable
-unmapped unmodified unmounted unnamed unnecessarily unnecessary unneeded uno
+unmapped unmodified unmounted unnamed unnecessarily unnecessary unneeded uno unoccupied
 unofficial unordered unpredictable unquoted unrecognized unrecoverable
 unreferenced unregister unregisters unrelated unreleased unsafe unsaved unscaled
 unset unsigned unsorted unspecified unstable unsuccessful unsupported
@@ -689,7 +690,7 @@ updating upgrade upgraded upgrader upgrades upgrading upload uploaded upon upper
 uppercase uppercased uppermost ups upsert upset upside upsih upsilon urgent urgently
 uri url urls usa usable usage usd use used useful user userbyid username userpwd
 users uses using usr usual usually utc ute utf util utilities utility utilization
-utilize utilizes utils uui uuid uuml vacuum vacuuming val valid validate
+utilize utilizes utils uui uuid uuml vacancy vacuum vacuuming val valid validate
 validated validates validating validation validities validity validly valign
 valuable value values van var varargs varbinary varchar variable variables
 variance variant variants varies various varp varray vars vary varying vasilakis