Examples with CacheDataRow org.apache.ignite.internal.processors.cache.persistence.CacheDataRow used on opensource projects

Example 51 with CacheDataRow

use of org.apache.ignite.internal.processors.cache.persistence.CacheDataRow in project ignite by apache.

the class IgniteCacheOffheapManagerImpl method mvccRead.

/**
 * {@inheritDoc}
 */
@Nullable
@Override
public CacheDataRow mvccRead(GridCacheContext cctx, KeyCacheObject key, MvccSnapshot mvccSnapshot) throws IgniteCheckedException {
    assert mvccSnapshot != null;
    CacheDataStore dataStore = dataStore(cctx, key);
    CacheDataRow row = dataStore != null ? dataStore.mvccFind(cctx, key, mvccSnapshot) : null;
    assert row == null || row.value() != null : row;
    return row;
}

Example 52 with CacheDataRow

use of org.apache.ignite.internal.processors.cache.persistence.CacheDataRow in project ignite by apache.

the class IgniteCacheOffheapManagerImpl method rebalanceIterator.

/**
 * {@inheritDoc}
 */
@Override
public IgniteRebalanceIterator rebalanceIterator(IgniteDhtDemandedPartitionsMap parts, AffinityTopologyVersion topVer) throws IgniteCheckedException {
    TreeMap<Integer, GridCloseableIterator<CacheDataRow>> iterators = new TreeMap<>();
    Set<Integer> missing = new HashSet<>();
    for (Integer p : parts.fullSet()) {
        GridCloseableIterator<CacheDataRow> partIter = reservedIterator(p, topVer);
        if (partIter == null) {
            missing.add(p);
            continue;
        }
        iterators.put(p, partIter);
    }
    IgniteHistoricalIterator historicalIterator = historicalIterator(parts.historicalMap(), missing);
    IgniteRebalanceIterator iter = new IgniteRebalanceIteratorImpl(iterators, historicalIterator);
    for (Integer p : missing) iter.setPartitionMissing(p);
    return iter;
}

Example 53 with CacheDataRow

use of org.apache.ignite.internal.processors.cache.persistence.CacheDataRow in project ignite by apache.

the class IgniteCacheOffheapManagerImpl method cacheKeysIterator.

/**
 * {@inheritDoc}
 */
@Override
public GridCloseableIterator<KeyCacheObject> cacheKeysIterator(int cacheId, int part) throws IgniteCheckedException {
    CacheDataStore data = dataStore(part, true);
    if (data == null)
        return new GridEmptyCloseableIterator<>();
    GridCursor<? extends CacheDataRow> cur = data.cursor(cacheId, null, null, CacheDataRowAdapter.RowData.KEY_ONLY);
    return new GridCloseableIteratorAdapter<KeyCacheObject>() {

        /**
         */
        private KeyCacheObject next;

        @Override
        protected KeyCacheObject onNext() {
            KeyCacheObject res = next;
            next = null;
            return res;
        }

        @Override
        protected boolean onHasNext() throws IgniteCheckedException {
            if (next != null)
                return true;
            if (cur.next()) {
                CacheDataRow row = cur.get();
                next = row.key();
            }
            return next != null;
        }
    };
}

Example 54 with CacheDataRow

use of org.apache.ignite.internal.processors.cache.persistence.CacheDataRow in project ignite by apache.

the class IgniteCacheOffheapManagerImpl method cacheEntriesIterator.

/**
 * {@inheritDoc}
 */
@SuppressWarnings("unchecked")
@Override
public <K, V> GridCloseableIterator<Cache.Entry<K, V>> cacheEntriesIterator(GridCacheContext cctx, boolean primary, boolean backup, AffinityTopologyVersion topVer, boolean keepBinary, @Nullable MvccSnapshot mvccSnapshot, Boolean dataPageScanEnabled) {
    Iterator<CacheDataRow> it = cacheIterator(cctx.cacheId(), primary, backup, topVer, mvccSnapshot, dataPageScanEnabled);
    return new GridCloseableIteratorAdapter<Cache.Entry<K, V>>() {

        /**
         */
        private CacheEntryImplEx next;

        @Override
        protected Cache.Entry<K, V> onNext() {
            CacheEntryImplEx ret = next;
            next = null;
            return ret;
        }

        @Override
        protected boolean onHasNext() {
            if (next != null)
                return true;
            CacheDataRow nextRow = null;
            if (it.hasNext())
                nextRow = it.next();
            if (nextRow != null) {
                KeyCacheObject key = nextRow.key();
                CacheObject val = nextRow.value();
                Object key0 = cctx.unwrapBinaryIfNeeded(key, keepBinary, false, null);
                Object val0 = cctx.unwrapBinaryIfNeeded(val, keepBinary, false, null);
                next = new CacheEntryImplEx(key0, val0, nextRow.version());
                return true;
            }
            return false;
        }
    };
}

Example 55 with CacheDataRow

use of org.apache.ignite.internal.processors.cache.persistence.CacheDataRow in project ignite by apache.

the class IgniteCacheOffheapManagerImpl method evictionSafeIterator.

/**
 * @param cacheId Cache ID.
 * @param dataIt Data store iterator.
 * @return Rows iterator
 */
private GridCloseableIterator<CacheDataRow> evictionSafeIterator(int cacheId, Iterator<CacheDataStore> dataIt) {
    return new GridCloseableIteratorAdapter<CacheDataRow>() {

        /**
         */
        private GridCursor<? extends CacheDataRow> cur;

        /**
         */
        private GridDhtLocalPartition curPart;

        /**
         */
        private CacheDataRow next;

        @Override
        protected CacheDataRow onNext() {
            CacheDataRow res = next;
            next = null;
            return res;
        }

        @Override
        protected boolean onHasNext() throws IgniteCheckedException {
            if (next != null)
                return true;
            while (true) {
                if (cur == null) {
                    if (dataIt.hasNext()) {
                        CacheDataStore ds = dataIt.next();
                        if (!reservePartition(ds.partId()))
                            continue;
                        cur = cacheId == CU.UNDEFINED_CACHE_ID ? ds.cursor() : ds.cursor(cacheId);
                    } else
                        break;
                }
                if (cur.next()) {
                    next = cur.get();
                    next.key().partition(curPart.id());
                    break;
                } else {
                    cur = null;
                    releaseCurrentPartition();
                }
            }
            return next != null;
        }

        /**
         */
        private void releaseCurrentPartition() {
            GridDhtLocalPartition p = curPart;
            assert p != null;
            curPart = null;
            p.release();
        }

        /**
         * @param partId Partition number.
         * @return {@code True} if partition was reserved.
         */
        private boolean reservePartition(int partId) {
            GridDhtLocalPartition p = grp.topology().localPartition(partId);
            if (p != null && p.reserve()) {
                curPart = p;
                return true;
            }
            return false;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        protected void onClose() throws IgniteCheckedException {
            if (curPart != null)
                releaseCurrentPartition();
        }
    };
}