/** * @return {@code True} if mvcc is enabled for cache. */ public boolean mvccEnabled() { return grp.mvccEnabled(); }
/** * @param grp Cache group. * @return Tree inner IO. */ private static IOVersions<? extends AbstractDataInnerIO> innerIO(CacheGroupContext grp) { if (grp.mvccEnabled()) return grp.sharedGroup() ? MvccCacheIdAwareDataInnerIO.VERSIONS : MvccDataInnerIO.VERSIONS; return grp.sharedGroup() ? CacheIdAwareDataInnerIO.VERSIONS : DataInnerIO.VERSIONS; }
/** * @return {@code True} if there are no items in the store. */ @Override public boolean isEmpty() { try { /* * TODO https://issues.apache.org/jira/browse/IGNITE-10082 * Using of counters is cheaper than tree operations. Return size checking after the ticked is resolved. */ return grp.mvccEnabled() ? dataTree.isEmpty() : storageSize.get() == 0; } catch (IgniteCheckedException e) { U.error(log, "Failed to perform operation.", e); return false; } }
/** * @param grp Cache group. * @return Tree leaf IO. */ private static IOVersions<? extends AbstractDataLeafIO> leafIO(CacheGroupContext grp) { if (grp.mvccEnabled()) return grp.sharedGroup() ? MvccCacheIdAwareDataLeafIO.VERSIONS : MvccDataLeafIO.VERSIONS; return grp.sharedGroup() ? CacheIdAwareDataLeafIO.VERSIONS : DataLeafIO.VERSIONS; }
/** * @param grp Cache group. * @return Row. * @throws IgniteCheckedException If failed. */ PendingRow initKey(CacheGroupContext grp) throws IgniteCheckedException { CacheDataRowAdapter rowData = grp.mvccEnabled() ? new MvccDataRow(link) : new CacheDataRowAdapter(link); rowData.initFromLink(grp, CacheDataRowAdapter.RowData.KEY_ONLY); key = rowData.key(); return this; }
/** {@inheritDoc} */ @Override public GridCursor<? extends CacheDataRow> cursor(MvccSnapshot mvccSnapshot) throws IgniteCheckedException { GridCursor<? extends CacheDataRow> cursor; if (mvccSnapshot != null) { assert grp.mvccEnabled(); cursor = dataTree.find(null, null, new MvccFirstVisibleRowTreeClosure(grp.singleCacheContext(), mvccSnapshot), null); } else cursor = dataTree.find(null, null); return cursor; }
/** * @param cctx Cache context. * @param oldRow Old row. * @param dataRow New row. * @return {@code True} if it is possible to update old row data. * @throws IgniteCheckedException If failed. */ private boolean canUpdateOldRow(GridCacheContext cctx, @Nullable CacheDataRow oldRow, DataRow dataRow) throws IgniteCheckedException { if (oldRow == null || cctx.queries().enabled() || grp.mvccEnabled()) return false; if (oldRow.expireTime() != dataRow.expireTime()) return false; // Use grp.sharedGroup() flag since it is possible cacheId is not yet set here. boolean sizeWithCacheId = grp.sharedGroup(); int oldLen = oldRow.size(); if (oldLen > updateValSizeThreshold) return false; int newLen = dataRow.size(); return oldLen == newLen; }
/** {@inheritDoc} */ @Override public void updateTxState(GridCacheContext cctx, CacheSearchRow row) throws IgniteCheckedException { assert grp.mvccEnabled(); assert mvccVersionIsValid(row.mvccCoordinatorVersion(), row.mvccCounter(), row.mvccOperationCounter()) : row; // Need an extra lookup because the row may be already cleaned by another thread. CacheDataRow row0 = dataTree.findOne(row, CacheDataRowAdapter.RowData.LINK_ONLY); if (row0 != null) rowStore.updateDataRow(row0.link(), mvccUpdateTxStateHint, null, grp.statisticsHolderData()); }
assert !grp.mvccEnabled() || row.mvccCoordinatorVersion() != 0 || (row.getClass() == SearchRow.class && row.key() == null) : row; if (cmp != 0 || !grp.mvccEnabled()) return cmp;
if (!grp.mvccEnabled()) return;
/** {@inheritDoc} */ @Override public List<IgniteBiTuple<Object, MvccVersion>> mvccFindAllVersions( GridCacheContext cctx, KeyCacheObject key) throws IgniteCheckedException { assert grp.mvccEnabled(); // Note: this method is intended for testing only. key.valueBytes(cctx.cacheObjectContext()); int cacheId = grp.sharedGroup() ? cctx.cacheId() : CU.UNDEFINED_CACHE_ID; GridCursor<CacheDataRow> cur = dataTree.find( new MvccMaxSearchRow(cacheId, key), new MvccMinSearchRow(cacheId, key) ); List<IgniteBiTuple<Object, MvccVersion>> res = new ArrayList<>(); long crd = MVCC_CRD_COUNTER_NA; long cntr = MVCC_COUNTER_NA; int opCntr = MVCC_OP_COUNTER_NA; while (cur.next()) { CacheDataRow row = cur.get(); if (compareNewVersion(row, crd, cntr, opCntr) != 0) // deleted row res.add(F.t(null, row.newMvccVersion())); res.add(F.t(row.value(), row.mvccVersion())); crd = row.mvccCoordinatorVersion(); cntr = row.mvccCounter(); opCntr = row.mvccOperationCounter(); } return res; }
/** {@inheritDoc} */ @Override public CacheDataRow getRow(BPlusIO<CacheSearchRow> io, long pageAddr, int idx, Object flags) { RowLinkIO rowIo = (RowLinkIO)io; long link = rowIo.getLink(pageAddr, idx); int hash = rowIo.getHash(pageAddr, idx); int cacheId = grp.sharedGroup() ? rowIo.getCacheId(pageAddr, idx) : CU.UNDEFINED_CACHE_ID; CacheDataRowAdapter.RowData x = asRowData(flags); if (grp.mvccEnabled()) { long mvccCrdVer = rowIo.getMvccCoordinatorVersion(pageAddr, idx); long mvccCntr = rowIo.getMvccCounter(pageAddr, idx); int mvccOpCntr = rowIo.getMvccOperationCounter(pageAddr, idx); return rowStore.mvccRow(cacheId, hash, link, x, mvccCrdVer, mvccCntr, mvccOpCntr); } else return rowStore.dataRow(cacheId, hash, link, x); }
/** {@inheritDoc} */ @Override @Nullable protected IgniteHistoricalIterator historicalIterator( CachePartitionPartialCountersMap partCntrs, Set<Integer> missing) throws IgniteCheckedException { if (partCntrs == null || partCntrs.isEmpty()) return null; if (grp.mvccEnabled()) // TODO IGNITE-7384 return super.historicalIterator(partCntrs, missing); GridCacheDatabaseSharedManager database = (GridCacheDatabaseSharedManager)grp.shared().database(); FileWALPointer minPtr = null; for (int i = 0; i < partCntrs.size(); i++) { int p = partCntrs.partitionAt(i); long initCntr = partCntrs.initialUpdateCounterAt(i); FileWALPointer startPtr = (FileWALPointer)database.checkpointHistory().searchPartitionCounter( grp.groupId(), p, initCntr); if (startPtr == null) throw new IgniteCheckedException("Could not find start pointer for partition [part=" + p + ", partCntrSince=" + initCntr + "]"); if (minPtr == null || startPtr.compareTo(minPtr) < 0) minPtr = startPtr; } WALIterator it = grp.shared().wal().replay(minPtr); WALHistoricalIterator iterator = new WALHistoricalIterator(grp, partCntrs, it); // Add historical partitions which are unabled to reserve to missing set. missing.addAll(iterator.missingParts); return iterator; }
/** {@inheritDoc} */ @Override public CacheDataRow find(GridCacheContext cctx, KeyCacheObject key) throws IgniteCheckedException { key.valueBytes(cctx.cacheObjectContext()); int cacheId = grp.sharedGroup() ? cctx.cacheId() : CU.UNDEFINED_CACHE_ID; CacheDataRow row; if (grp.mvccEnabled()) { MvccFirstRowTreeClosure clo = new MvccFirstRowTreeClosure(cctx); dataTree.iterate( new MvccMaxSearchRow(cacheId, key), new MvccMinSearchRow(cacheId, key), clo ); row = clo.row(); } else row = dataTree.findOne(new SearchRow(cacheId, key), CacheDataRowAdapter.RowData.NO_KEY); afterRowFound(row, key); return row; }
/** {@inheritDoc} */ @Override public GridCursor<? extends CacheDataRow> cursor(int cacheId, KeyCacheObject lower, KeyCacheObject upper, Object x, MvccSnapshot snapshot) throws IgniteCheckedException { SearchRow lowerRow; SearchRow upperRow; if (grp.sharedGroup()) { assert cacheId != CU.UNDEFINED_CACHE_ID; lowerRow = lower != null ? new SearchRow(cacheId, lower) : new SearchRow(cacheId); upperRow = upper != null ? new SearchRow(cacheId, upper) : new SearchRow(cacheId); } else { lowerRow = lower != null ? new SearchRow(CU.UNDEFINED_CACHE_ID, lower) : null; upperRow = upper != null ? new SearchRow(CU.UNDEFINED_CACHE_ID, upper) : null; } GridCursor<? extends CacheDataRow> cursor; if (snapshot != null) { assert grp.mvccEnabled(); GridCacheContext cctx = grp.sharedGroup() ? grp.shared().cacheContext(cacheId) : grp.singleCacheContext(); cursor = dataTree.find(lowerRow, upperRow, new MvccFirstVisibleRowTreeClosure(cctx, snapshot), x); } else cursor = dataTree.find(lowerRow, upperRow, x); return cursor; }
GridCacheContext cctx = cache.context(); if (!cctx.userCache() || !cctx.group().mvccEnabled() || F.isEmpty(cctx.group().caches()) || cctx.shared().closed(cctx)) continue;
/** {@inheritDoc} */ @Override public Boolean run(int cacheId, long pageId, long page, long pageAddr, PageIO io, Boolean walPlc, MvccVersion newVer, int itemId, IoStatisticsHolder statHolder) throws IgniteCheckedException { assert grp.mvccEnabled(); DataPageIO iox = (DataPageIO)io; int off = iox.getPayloadOffset(pageAddr, itemId, grp.dataRegion().pageMemory().realPageSize(grp.groupId()), MVCC_INFO_SIZE); long newCrd = iox.newMvccCoordinator(pageAddr, off); long newCntr = iox.newMvccCounter(pageAddr, off); int newOpCntr = iox.newMvccOperationCounter(pageAddr, off); assert newCrd == MVCC_CRD_COUNTER_NA || state(grp, newCrd, newCntr, newOpCntr) == TxState.ABORTED; iox.updateNewVersion(pageAddr, off, newVer, TxState.NA); if (isWalDeltaRecordNeeded(grp.dataRegion().pageMemory(), cacheId, pageId, page, ctx.wal(), walPlc)) ctx.wal().log(new DataPageMvccMarkUpdatedRecord(cacheId, pageId, itemId, newVer.coordinatorVersion(), newVer.counter(), newVer.operationCounter())); return TRUE; } }
assert cacheProc.cacheGroup(fullPageId.groupId()).mvccEnabled();
if (grp.mvccEnabled()) { grp.topology().readLock();
assert grp.mvccEnabled();