From 778f5b5dd307f09b89ac6f31c39c0e0236f16f5b Mon Sep 17 00:00:00 2001 From: Honghua Zhu Date: Sun, 10 May 2015 22:27:33 +0800 Subject: [PATCH] =?UTF-8?q?=E6=8F=92=E4=BB=B6=E5=8C=96=E4=BA=8B=E5=8A=A1?= =?UTF-8?q?=E5=BC=95=E6=93=8EAPI=EF=BC=8C=E5=A2=9E=E5=8A=A0=E4=B8=80?= =?UTF-8?q?=E4=B8=AAMemoryTransactionEngine=E9=AA=A8=E6=9E=B6=E4=BB=A3?= =?UTF-8?q?=E7=A0=81=E7=94=A8=E4=BA=8E=E6=BC=94=E7=A4=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../org/lealone/transaction/Transaction.java | 33 ++++ .../transaction/TransactionEngine.java | 9 + .../lealone/transaction/TransactionMap.java | 2 + .../dbobject/index/MVPrimaryIndex.java | 1 - .../org/lealone/storage/MVStorageEngine.java | 103 ++++++----- .../org/lealone/storage/WTStorageEngine.java | 2 +- .../test/storage/MemoryStorageEngine.java | 6 +- ...tionTest.java => MVCCTransactionTest.java} | 18 +- .../test/transaction/MemoryTransaction.java | 138 +++++++++++++++ .../transaction/MemoryTransactionEngine.java | 56 ++++++ .../transaction/MemoryTransactionMap.java | 165 ++++++++++++++++++ .../lealone/transaction/MVCCTransaction.java | 40 +++-- .../transaction/MVCCTransactionEngine.java | 11 +- .../transaction/MVCCTransactionMap.java | 7 +- 14 files changed, 514 insertions(+), 77 deletions(-) rename lealone-test/src/test/java/org/lealone/test/transaction/{TransactionTest.java => MVCCTransactionTest.java} (81%) create mode 100644 lealone-test/src/test/java/org/lealone/test/transaction/MemoryTransaction.java create mode 100644 lealone-test/src/test/java/org/lealone/test/transaction/MemoryTransactionEngine.java create mode 100644 lealone-test/src/test/java/org/lealone/test/transaction/MemoryTransactionMap.java diff --git a/lealone-common/src/main/java/org/lealone/transaction/Transaction.java b/lealone-common/src/main/java/org/lealone/transaction/Transaction.java index d4cfa2c4a..2035a4aa0 100644 --- a/lealone-common/src/main/java/org/lealone/transaction/Transaction.java +++ b/lealone-common/src/main/java/org/lealone/transaction/Transaction.java @@ -21,6 +21,39 @@ public interface Transaction { + /** + * The status of a closed transaction (committed or rolled back). + */ + public static final int STATUS_CLOSED = 0; + + /** + * The status of an open transaction. + */ + public static final int STATUS_OPEN = 1; + + /** + * The status of a prepared transaction. + */ + public static final int STATUS_PREPARED = 2; + + /** + * The status of a transaction that is being committed, but possibly not + * yet finished. A transactions can go into this state when the store is + * closed while the transaction is committing. When opening a store, + * such transactions should be committed. + */ + public static final int STATUS_COMMITTING = 3; + + String getName(); //用于2pc + + void setName(String name); //用于2pc + + void prepare(); //用于2pc + + int getStatus(); + + void setStatus(int status); + //long getTransactionId(); //long getCommitTimestamp(); diff --git a/lealone-common/src/main/java/org/lealone/transaction/TransactionEngine.java b/lealone-common/src/main/java/org/lealone/transaction/TransactionEngine.java index 6252b2078..55a0b6b49 100644 --- a/lealone-common/src/main/java/org/lealone/transaction/TransactionEngine.java +++ b/lealone-common/src/main/java/org/lealone/transaction/TransactionEngine.java @@ -17,10 +17,19 @@ */ package org.lealone.transaction; +import java.util.List; +import java.util.Set; + public interface TransactionEngine { Transaction beginTransaction(boolean autoCommit); void close(); boolean isValid(String localTransactionName); + + void init(Set storageMapNames); + + List getOpenTransactions(); + + void removeMap(TransactionMap map); } diff --git a/lealone-common/src/main/java/org/lealone/transaction/TransactionMap.java b/lealone-common/src/main/java/org/lealone/transaction/TransactionMap.java index 48649eb9c..b7d403d77 100644 --- a/lealone-common/src/main/java/org/lealone/transaction/TransactionMap.java +++ b/lealone-common/src/main/java/org/lealone/transaction/TransactionMap.java @@ -196,4 +196,6 @@ public interface TransactionMap { * @return the result */ public K lowerKey(K key); + + public int getMapId(); } diff --git a/lealone-mvdb/src/main/java/org/lealone/dbobject/index/MVPrimaryIndex.java b/lealone-mvdb/src/main/java/org/lealone/dbobject/index/MVPrimaryIndex.java index 2492a702d..861e2d7b1 100644 --- a/lealone-mvdb/src/main/java/org/lealone/dbobject/index/MVPrimaryIndex.java +++ b/lealone-mvdb/src/main/java/org/lealone/dbobject/index/MVPrimaryIndex.java @@ -55,7 +55,6 @@ public class MVPrimaryIndex extends IndexBase { private final MVTable mvTable; private final String mapName; - //private final TransactionMap dataMap; private final TransactionMap dataMap; private long lastKey; private int mainIndexColumn = -1; diff --git a/lealone-storage/engine/src/main/java/org/lealone/storage/MVStorageEngine.java b/lealone-storage/engine/src/main/java/org/lealone/storage/MVStorageEngine.java index 9d54b86c8..6fba84270 100644 --- a/lealone-storage/engine/src/main/java/org/lealone/storage/MVStorageEngine.java +++ b/lealone-storage/engine/src/main/java/org/lealone/storage/MVStorageEngine.java @@ -30,9 +30,9 @@ import org.lealone.mvstore.MVMap; import org.lealone.mvstore.MVStore; import org.lealone.mvstore.MVStoreTool; -import org.lealone.transaction.MVCCTransaction; import org.lealone.transaction.MVCCTransactionEngine; -import org.lealone.transaction.MVCCTransactionMap; +import org.lealone.transaction.Transaction; +import org.lealone.transaction.TransactionEngine; import org.lealone.transaction.TransactionMap; import org.lealone.type.DataType; import org.lealone.util.BitField; @@ -46,15 +46,11 @@ public class MVStorageEngine extends StorageEngineBase implements TransactionSto public static final String NAME = Constants.DEFAULT_STORAGE_ENGINE_NAME; private StorageMap.Builder mapBuilder; - - public MVStorageEngine() { - this(null); - } + private TransactionEngine transactionEngine; //见StorageEngineManager.StorageEngineService中的注释 - public MVStorageEngine(StorageMap.Builder mapBuilder) { + public MVStorageEngine() { StorageEngineManager.registerStorageEngine(this); - setMapBuilder(mapBuilder); } @Override @@ -62,10 +58,22 @@ public String getName() { return NAME; } - protected void setMapBuilder(StorageMap.Builder mapBuilder) { + public void setMapBuilder(StorageMap.Builder mapBuilder) { this.mapBuilder = mapBuilder; } + public StorageMap.Builder getMapBuilder() { + return mapBuilder; + } + + public void setTransactionEngine(TransactionEngine transactionEngine) { + this.transactionEngine = transactionEngine; + } + + public TransactionEngine getTransactionEngine() { + return transactionEngine; + } + @Override public Table createTable(CreateTableData data) { Database db = data.session.getDatabase(); @@ -73,10 +81,17 @@ public Table createTable(CreateTableData data) { if (store == null) { synchronized (stores) { if (stores.get(db.getName()) == null) { - store = init(db, mapBuilder); + + store = init(db, mapBuilder, transactionEngine); stores.put(db.getName(), store); + + if (mapBuilder == null) + mapBuilder = store.getMapBuilder(); + if (transactionEngine == null) + transactionEngine = store.getTransactionEngine(); + db.setStorageEngine(this); - db.setTransactionEngine(store.getTransactionEngine()); + db.setTransactionEngine(transactionEngine); db.setLobStorage(new LobStorageMap(db)); } } @@ -109,17 +124,13 @@ public static Store getStore(Database db) { * @param db the database * @return the store */ - public static Store init(final Database db) { - return init(db, null); - } - - public static Store init(final Database db, StorageMap.Builder mapBuilder) { + static Store init(final Database db, StorageMap.Builder mapBuilder, TransactionEngine transactionEngine) { Store store = null; byte[] key = db.getFileEncryptionKey(); String dbPath = db.getDatabasePath(); MVStore.Builder builder = new MVStore.Builder(); if (dbPath == null) { - store = new Store(db, builder); + store = new Store(db, builder, mapBuilder, transactionEngine); } else { String fileName = dbPath + Constants.SUFFIX_MV_FILE; builder.pageSplitSize(db.getPageSize()); @@ -158,7 +169,7 @@ public void uncaughtException(Thread t, Throwable e) { }); try { - store = new Store(db, builder, mapBuilder); + store = new Store(db, builder, mapBuilder, transactionEngine); } catch (IllegalStateException e) { int errorCode = DataUtils.getErrorCode(e.getMessage()); if (errorCode == DataUtils.ERROR_FILE_CORRUPT) { @@ -195,22 +206,28 @@ public static class Store { /** * The transaction engine. */ - private final MVCCTransactionEngine transactionEngine; + private final TransactionEngine transactionEngine; + private final StorageMap.Builder mapBuilder; private long statisticsStart; private int temporaryMapId; - public Store(Database db, MVStore.Builder builder) { - this(db, builder, null); - } - - public Store(Database db, MVStore.Builder builder, StorageMap.Builder mapBuilder) { + public Store(Database db, MVStore.Builder builder, StorageMap.Builder mapBuilder, + TransactionEngine transactionEngine) { this.store = builder.open(); + if (mapBuilder == null) - mapBuilder = new MVMapBuilder(store); - this.transactionEngine = new MVCCTransactionEngine(new ValueDataType(null, db, null), mapBuilder, - DatabaseEngine.getHostAndPort()); + this.mapBuilder = mapBuilder = new MVMapBuilder(store); + else + this.mapBuilder = mapBuilder; + + if (transactionEngine == null) + this.transactionEngine = new MVCCTransactionEngine(new ValueDataType(null, db, null), mapBuilder, + DatabaseEngine.getHostAndPort()); + else + this.transactionEngine = transactionEngine; + transactionEngine.init(store.getMapNames()); initTransactions(); } @@ -219,10 +236,14 @@ public MVStore getStore() { return store; } - public MVCCTransactionEngine getTransactionEngine() { + public TransactionEngine getTransactionEngine() { return transactionEngine; } + public StorageMap.Builder getMapBuilder() { + return mapBuilder; + } + public HashMap getTables() { return new HashMap(tableMap); } @@ -264,11 +285,11 @@ public void closeImmediately() { * rollback all open transactions. */ public void initTransactions() { - List list = transactionEngine.getOpenTransactions(); - for (MVCCTransaction t : list) { - if (t.getStatus() == MVCCTransaction.STATUS_COMMITTING) { + List list = transactionEngine.getOpenTransactions(); + for (Transaction t : list) { + if (t.getStatus() == Transaction.STATUS_COMMITTING) { t.commit(); - } else if (t.getStatus() != MVCCTransaction.STATUS_PREPARED) { + } else if (t.getStatus() != Transaction.STATUS_PREPARED) { t.rollback(); } } @@ -289,8 +310,8 @@ public void removeTemporaryMaps(BitField objectIds) { if (!objectIds.get(id)) { ValueDataType keyType = new ValueDataType(null, null, null); ValueDataType valueType = new ValueDataType(null, null, null); - MVCCTransaction t = transactionEngine.beginTransaction(false); - MVCCTransactionMap m = t.openMap(mapName, keyType, valueType); + Transaction t = transactionEngine.beginTransaction(false); + TransactionMap m = t.openMap(mapName, keyType, valueType); transactionEngine.removeMap(m); t.commit(); } @@ -314,17 +335,17 @@ public synchronized String nextTemporaryMapName() { * @param transactionName the transaction name (may be null) */ public void prepareCommit(Session session, String transactionName) { - MVCCTransaction t = (MVCCTransaction) session.getTransaction(); + Transaction t = session.getTransaction(); t.setName(transactionName); t.prepare(); store.commit(); } public ArrayList getInDoubtTransactions() { - List list = transactionEngine.getOpenTransactions(); + List list = transactionEngine.getOpenTransactions(); ArrayList result = New.arrayList(); - for (MVCCTransaction t : list) { - if (t.getStatus() == MVCCTransaction.STATUS_PREPARED) { + for (Transaction t : list) { + if (t.getStatus() == Transaction.STATUS_PREPARED) { result.add(new MVInDoubtTransaction(store, t)); } } @@ -443,10 +464,10 @@ public Map statisticsEnd() { private static class MVInDoubtTransaction implements InDoubtTransaction { private final MVStore store; - private final MVCCTransaction transaction; + private final Transaction transaction; private int state = InDoubtTransaction.IN_DOUBT; - MVInDoubtTransaction(MVStore store, MVCCTransaction transaction) { + MVInDoubtTransaction(MVStore store, Transaction transaction) { this.store = store; this.transaction = transaction; } @@ -505,7 +526,7 @@ public String nextTemporaryMapName(Database db) { @Override public TransactionMap openMap(Session session, String name, DataType keyType, DataType valueType) { - return ((MVCCTransaction) session.getTransaction()).openMap(name, keyType, valueType); + return session.getTransaction().openMap(name, keyType, valueType); } } diff --git a/lealone-storage/engine/src/main/java/org/lealone/storage/WTStorageEngine.java b/lealone-storage/engine/src/main/java/org/lealone/storage/WTStorageEngine.java index 59fba52bd..470a33ccf 100644 --- a/lealone-storage/engine/src/main/java/org/lealone/storage/WTStorageEngine.java +++ b/lealone-storage/engine/src/main/java/org/lealone/storage/WTStorageEngine.java @@ -53,7 +53,7 @@ public Table createTable(CreateTableData data) { conn = createConnection(dbName); connections.put(dbName, conn); - Store store = init(db, new WTMapBuilder(conn.open_session(null))); + Store store = init(db, new WTMapBuilder(conn.open_session(null)), getTransactionEngine()); stores.put(db.getName(), store); db.setStorageEngine(this); db.setTransactionEngine(store.getTransactionEngine()); diff --git a/lealone-test/src/test/java/org/lealone/test/storage/MemoryStorageEngine.java b/lealone-test/src/test/java/org/lealone/test/storage/MemoryStorageEngine.java index c8bc8babd..67ff05bc8 100644 --- a/lealone-test/src/test/java/org/lealone/test/storage/MemoryStorageEngine.java +++ b/lealone-test/src/test/java/org/lealone/test/storage/MemoryStorageEngine.java @@ -52,7 +52,9 @@ public static void register() { } public MemoryStorageEngine() { - super(new MemoryMapBuilder()); + super(); + setMapBuilder(new MemoryMapBuilder()); + //setTransactionEngine(new MemoryTransactionEngine()); } @Override @@ -124,7 +126,7 @@ public int compare(K k1, K k2) { } - static class MemoryMap extends ConcurrentSkipListMap implements StorageMap { + public static class MemoryMap extends ConcurrentSkipListMap implements StorageMap { private static final AtomicInteger counter = new AtomicInteger(0); diff --git a/lealone-test/src/test/java/org/lealone/test/transaction/TransactionTest.java b/lealone-test/src/test/java/org/lealone/test/transaction/MVCCTransactionTest.java similarity index 81% rename from lealone-test/src/test/java/org/lealone/test/transaction/TransactionTest.java rename to lealone-test/src/test/java/org/lealone/test/transaction/MVCCTransactionTest.java index 26b3002c8..2ceec564c 100644 --- a/lealone-test/src/test/java/org/lealone/test/transaction/TransactionTest.java +++ b/lealone-test/src/test/java/org/lealone/test/transaction/MVCCTransactionTest.java @@ -18,25 +18,25 @@ package org.lealone.test.transaction; import org.junit.Assert; +import org.junit.Test; import org.lealone.storage.StorageMap; import org.lealone.test.TestBase; import org.lealone.test.storage.MemoryStorageEngine; +import org.lealone.transaction.MVCCTransaction; import org.lealone.transaction.MVCCTransactionEngine; -import org.lealone.transaction.TransactionEngine; -import org.lealone.transaction.Transaction; -import org.lealone.transaction.TransactionMap; +import org.lealone.transaction.MVCCTransactionMap; import org.lealone.type.ObjectDataType; -public class TransactionTest { - public static void main(String[] args) { +public class MVCCTransactionTest { + @Test + public void run() { StorageMap.Builder mapBuilder = new MemoryStorageEngine.MemoryMapBuilder(); String hostAndPort = TestBase.getHost() + ":" + TestBase.getPort(); MVCCTransactionEngine e = new MVCCTransactionEngine(new ObjectDataType(), mapBuilder, hostAndPort); e.init(null); - TransactionEngine te = e; - Transaction t = te.beginTransaction(false); - TransactionMap map = t.openMap("test"); + MVCCTransaction t = e.beginTransaction(false); + MVCCTransactionMap map = t.openMap("test"); map.put("1", "a"); map.put("2", "b"); Assert.assertEquals("a", map.get("1")); @@ -44,7 +44,7 @@ public static void main(String[] args) { t.rollback(); - t = te.beginTransaction(false); + t = e.beginTransaction(false); Assert.assertNull(map.get("1")); Assert.assertNull(map.get("2")); diff --git a/lealone-test/src/test/java/org/lealone/test/transaction/MemoryTransaction.java b/lealone-test/src/test/java/org/lealone/test/transaction/MemoryTransaction.java new file mode 100644 index 000000000..2a86d9700 --- /dev/null +++ b/lealone-test/src/test/java/org/lealone/test/transaction/MemoryTransaction.java @@ -0,0 +1,138 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.lealone.test.transaction; + +import org.lealone.transaction.Transaction; +import org.lealone.transaction.TransactionMap; +import org.lealone.type.DataType; + +//TODO 实现所有API +public class MemoryTransaction implements Transaction { + + @Override + public String getName() { + + return null; + } + + @Override + public void setName(String name) { + + } + + @Override + public void prepare() { + + } + + @Override + public int getStatus() { + + return 0; + } + + @Override + public void setStatus(int status) { + + } + + @Override + public boolean isAutoCommit() { + + return false; + } + + @Override + public void setAutoCommit(boolean autoCommit) { + + } + + @Override + public void setLocal(boolean local) { + + } + + @Override + public void addLocalTransactionNames(String localTransactionNames) { + + } + + @Override + public String getLocalTransactionNames() { + + return null; + } + + @Override + public void setValidator(Validator validator) { + + } + + @Override + public void addParticipant(Participant participant) { + + } + + @Override + public TransactionMap openMap(String name) { + + return null; + } + + @Override + public TransactionMap openMap(String name, DataType keyType, DataType valueType) { + return new MemoryTransactionMap<>(); + } + + @Override + public void addSavepoint(String name) { + + } + + @Override + public long getSavepointId() { + + return 0; + } + + @Override + public void commit() { + + } + + @Override + public void commit(String allLocalTransactionNames) { + + } + + @Override + public void rollback() { + + } + + @Override + public void rollbackToSavepoint(String name) { + + } + + @Override + public void rollbackToSavepoint(long savepointId) { + + } + +} diff --git a/lealone-test/src/test/java/org/lealone/test/transaction/MemoryTransactionEngine.java b/lealone-test/src/test/java/org/lealone/test/transaction/MemoryTransactionEngine.java new file mode 100644 index 000000000..2b88ce5a4 --- /dev/null +++ b/lealone-test/src/test/java/org/lealone/test/transaction/MemoryTransactionEngine.java @@ -0,0 +1,56 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.lealone.test.transaction; + +import java.util.List; +import java.util.Set; + +import org.lealone.transaction.Transaction; +import org.lealone.transaction.TransactionEngine; +import org.lealone.transaction.TransactionMap; + +//TODO 实现所有API +public class MemoryTransactionEngine implements TransactionEngine { + + @Override + public Transaction beginTransaction(boolean autoCommit) { + return new MemoryTransaction(); + } + + @Override + public void close() { + } + + @Override + public boolean isValid(String localTransactionName) { + return false; + } + + @Override + public void init(Set storageMapNames) { + } + + @Override + public List getOpenTransactions() { + return java.util.Collections.emptyList(); + } + + @Override + public void removeMap(TransactionMap map) { + } +} diff --git a/lealone-test/src/test/java/org/lealone/test/transaction/MemoryTransactionMap.java b/lealone-test/src/test/java/org/lealone/test/transaction/MemoryTransactionMap.java new file mode 100644 index 000000000..6d011d2f8 --- /dev/null +++ b/lealone-test/src/test/java/org/lealone/test/transaction/MemoryTransactionMap.java @@ -0,0 +1,165 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.lealone.test.transaction; + +import java.util.Iterator; +import java.util.Map.Entry; + +import org.lealone.transaction.Transaction; +import org.lealone.transaction.TransactionMap; +import org.lealone.type.DataType; + +//TODO 实现所有API +public class MemoryTransactionMap implements TransactionMap { + + @Override + public void setVolatile(boolean isVolatile) { + + } + + @Override + public K lastKey() { + + return null; + } + + @Override + public long sizeAsLongMax() { + + return 0; + } + + @Override + public TransactionMap getInstance(Transaction transaction, long savepoint) { + + return null; + } + + @Override + public V getLatest(K key) { + + return null; + } + + @Override + public V put(K key, V value) { + + return null; + } + + @Override + public V remove(K key) { + + return null; + } + + @Override + public Iterator> entryIterator(K from) { + + return null; + } + + @Override + public V get(K key) { + + return null; + } + + @Override + public boolean isClosed() { + + return false; + } + + @Override + public void removeMap() { + + } + + @Override + public void clear() { + + } + + @Override + public K firstKey() { + + return null; + } + + @Override + public long sizeAsLong() { + + return 0; + } + + @Override + public DataType getKeyType() { + + return null; + } + + @Override + public V putCommitted(K key, V value) { + + return null; + } + + @Override + public Iterator keyIterator(K from) { + + return null; + } + + @Override + public Iterator keyIterator(K from, boolean includeUncommitted) { + + return null; + } + + @Override + public boolean isSameTransaction(K key) { + + return false; + } + + @Override + public K relativeKey(K key, long offset) { + + return null; + } + + @Override + public K higherKey(K key) { + + return null; + } + + @Override + public K lowerKey(K key) { + + return null; + } + + @Override + public int getMapId() { + + return 0; + } + +} diff --git a/lealone-transaction/src/main/java/org/lealone/transaction/MVCCTransaction.java b/lealone-transaction/src/main/java/org/lealone/transaction/MVCCTransaction.java index 987f30633..e28d8c182 100644 --- a/lealone-transaction/src/main/java/org/lealone/transaction/MVCCTransaction.java +++ b/lealone-transaction/src/main/java/org/lealone/transaction/MVCCTransaction.java @@ -88,6 +88,28 @@ public class MVCCTransaction implements Transaction { this.logId = logId; } + @Override + public String getName() { + return name; + } + + @Override + public void setName(String name) { + checkNotClosed(); + this.name = name; + transactionEngine.storeTransaction(this); + } + + @Override + public int getStatus() { + return status; + } + + @Override + public void setStatus(int status) { + this.status = status; + } + @Override public boolean isAutoCommit() { return autoCommit; @@ -300,24 +322,6 @@ public void rollbackToSavepoint(long savepointId) { logId = savepointId; } - public int getStatus() { - return status; - } - - void setStatus(int status) { - this.status = status; - } - - public void setName(String name) { - checkNotClosed(); - this.name = name; - transactionEngine.storeTransaction(this); - } - - public String getName() { - return name; - } - long getCommitTimestamp() { return commitTimestamp; } diff --git a/lealone-transaction/src/main/java/org/lealone/transaction/MVCCTransactionEngine.java b/lealone-transaction/src/main/java/org/lealone/transaction/MVCCTransactionEngine.java index 46c0a27a3..c8d476433 100644 --- a/lealone-transaction/src/main/java/org/lealone/transaction/MVCCTransactionEngine.java +++ b/lealone-transaction/src/main/java/org/lealone/transaction/MVCCTransactionEngine.java @@ -102,6 +102,7 @@ public MVCCTransactionEngine(DataType dataType, StorageMap.Builder mapBuilder, S * If the transaction store is corrupt, this method can throw an exception, * in which case the store can only be used for reading. */ + @Override public synchronized void init(Set storageMapNames) { init = true; @@ -177,9 +178,10 @@ static long getLogId(long operationId) { * * @return the list of transactions (sorted by id) */ - public List getOpenTransactions() { + @Override + public List getOpenTransactions() { synchronized (undoLog) { - ArrayList list = New.arrayList(); + ArrayList list = New.arrayList(); Long key = undoLog.firstKey(); while (key != null) { int transactionId = getTransactionId(key); @@ -338,8 +340,9 @@ public void logUndo(MVCCTransaction t, long logId) { * @param the value type * @param map the map */ - public synchronized void removeMap(MVCCTransactionMap map) { - maps.remove(map.mapId); + @Override + public synchronized void removeMap(TransactionMap map) { + maps.remove(map.getMapId()); map.removeMap(); //store.removeMap(map.map); } diff --git a/lealone-transaction/src/main/java/org/lealone/transaction/MVCCTransactionMap.java b/lealone-transaction/src/main/java/org/lealone/transaction/MVCCTransactionMap.java index afcb79c65..7ac68e27d 100644 --- a/lealone-transaction/src/main/java/org/lealone/transaction/MVCCTransactionMap.java +++ b/lealone-transaction/src/main/java/org/lealone/transaction/MVCCTransactionMap.java @@ -67,7 +67,7 @@ public void setSavepoint(long savepoint) { * @return the map */ @Override - public TransactionMap getInstance(Transaction transaction, long savepoint) { + public MVCCTransactionMap getInstance(Transaction transaction, long savepoint) { MVCCTransactionMap m = new MVCCTransactionMap((MVCCTransaction) transaction, map, mapId); m.setSavepoint(savepoint); return m; @@ -767,4 +767,9 @@ public void setVolatile(boolean isVolatile) { public void removeMap() { map.remove(); } + + @Override + public int getMapId() { + return mapId; + } }