@Override public boolean commit() { checkIsFinished(); return getEnvironment().commitTransaction(this, false); }
public boolean forceFlush() { checkIsFinished(); return getEnvironment().flushTransaction(this, true); }
@NotNull ITreeMutable getMutableTree(@NotNull final StoreImpl store) { checkIsFinished(); if (getEnvironment().getEnvironmentConfig().getEnvTxnSingleThreadWrites()) { final Thread creatingThread = getCreatingThread(); if (!creatingThread.equals(Thread.currentThread())) { throw new ExodusException("Can't create mutable tree in a thread different from the one which transaction was created in"); } } final int structureId = store.getStructureId(); ITreeMutable result = mutableTrees.get(structureId); if (result == null) { result = getTree(store).getMutableCopy(); mutableTrees.put(structureId, result); } return result; }
@Override public void abort() { checkIsFinished(); clearImmutableTrees(); doRevert(); getEnvironment().finishTransaction(this); }
@NotNull public StoreImpl openStoreByStructureId(final int structureId) { checkIsFinished(); final EnvironmentImpl env = getEnvironment(); final String storeName = getMetaTree().getStoreNameByStructureId(structureId, env); return storeName == null ? new TemporaryEmptyStore(env) : env.openStoreImpl(storeName, StoreConfig.USE_EXISTING, this, getTreeMetaInfo(storeName)); }
Iterable<ExpiredLoggableInfo>[] doCommit(@NotNull final MetaTreeImpl.Proto[] out) { final Set<Map.Entry<Integer, ITreeMutable>> entries = mutableTrees.entrySet(); final Set<Map.Entry<Long, Pair<String, ITree>>> removedEntries = removedStores.entrySet(); final int size = entries.size() + removedEntries.size(); //noinspection unchecked final Iterable<ExpiredLoggableInfo>[] expiredLoggables = new Iterable[size + 1]; int i = 0; final ITreeMutable metaTreeMutable = getMetaTree().tree.getMutableCopy(); for (final Map.Entry<Long, Pair<String, ITree>> entry : removedEntries) { final Pair<String, ITree> value = entry.getValue(); MetaTreeImpl.removeStore(metaTreeMutable, value.getFirst(), entry.getKey()); expiredLoggables[i++] = TreeMetaInfo.getTreeLoggables(value.getSecond()); } removedStores.clear(); for (final Map.Entry<String, TreeMetaInfo> entry : createdStores.entrySet()) { MetaTreeImpl.addStore(metaTreeMutable, entry.getKey(), entry.getValue()); } createdStores.clear(); final Collection<ExpiredLoggableInfo> last; for (final Map.Entry<Integer, ITreeMutable> entry : entries) { final ITreeMutable treeMutable = entry.getValue(); expiredLoggables[i++] = treeMutable.getExpiredLoggables(); MetaTreeImpl.saveTree(metaTreeMutable, treeMutable); } clearImmutableTrees(); mutableTrees.clear(); expiredLoggables[i] = last = metaTreeMutable.getExpiredLoggables(); out[0] = MetaTreeImpl.saveMetaTree(metaTreeMutable, getEnvironment(), last); return expiredLoggables; }
ReadWriteTransaction(@NotNull final TransactionBase origin, @Nullable final Runnable beginHook) { super(origin.getEnvironment(), false); mutableTrees = new TreeMap<>(); removedStores = new LongHashMap<>(); createdStores = new HashMapDecorator<>(); final EnvironmentImpl env = getEnvironment(); this.beginHook = getWrappedBeginHook(beginHook); replayCount = 0; setMetaTree(origin.getMetaTree()); setExclusive(env.shouldTransactionBeExclusive(this)); env.acquireTransaction(this); env.registerTransaction(this); env.getStatistics().getStatisticsItem(TRANSACTIONS).incTotal(); }
@Override public boolean flush() { checkIsFinished(); final EnvironmentImpl env = getEnvironment(); final boolean result = env.flushTransaction(this, false); if (result) { // if the transaction was upgraded to exclusive during re-playing // then it should be downgraded back after successful flush(). if (!wasCreatedExclusive() && isExclusive() && env.getEnvironmentConfig().getEnvTxnDowngradeAfterFlush()) { env.downgradeTransaction(this); setExclusive(false); } setStarted(System.currentTimeMillis()); } else { incReplayCount(); } return result; }
@Override public void revert() { checkIsFinished(); if (isReadonly()) { throw new ExodusException("Attempt ot revert read-only transaction"); } final long oldRoot = getMetaTree().root; final boolean wasExclusive = isExclusive(); final EnvironmentImpl env = getEnvironment(); if (isIdempotent()) { env.holdNewestSnapshotBy(this, false); } else { doRevert(); if (wasExclusive || !env.shouldTransactionBeExclusive(this)) { env.holdNewestSnapshotBy(this, false); } else { env.releaseTransaction(this); setExclusive(true); env.holdNewestSnapshotBy(this); } } if (!env.isRegistered(this)) { throw new ExodusException("Transaction should remain registered after revert"); } if (!checkVersion(oldRoot)) { clearImmutableTrees(); env.runTransactionSafeTasks(); } setStarted(System.currentTimeMillis()); }