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

Example 1 with GridCacheContext

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

the class DmlStatementsProcessor method streamUpdateQuery.

/**
     * Perform given statement against given data streamer. Only rows based INSERT and MERGE are supported
     * as well as key bound UPDATE and DELETE (ones with filter {@code WHERE _key = ?}).
     *
     * @param streamer Streamer to feed data to.
     * @param stmt Statement.
     * @param args Statement arguments.
     * @return Number of rows in given statement for INSERT and MERGE, {@code 1} otherwise.
     * @throws IgniteCheckedException if failed.
     */
@SuppressWarnings({ "unchecked", "ConstantConditions" })
long streamUpdateQuery(IgniteDataStreamer streamer, PreparedStatement stmt, Object[] args) throws IgniteCheckedException {
    args = U.firstNotNull(args, X.EMPTY_OBJECT_ARRAY);
    Prepared p = GridSqlQueryParser.prepared(stmt);
    assert p != null;
    UpdatePlan plan = UpdatePlanBuilder.planForStatement(p, null);
    if (!F.eq(streamer.cacheName(), plan.tbl.rowDescriptor().context().name()))
        throw new IgniteSQLException("Cross cache streaming is not supported, please specify cache explicitly" + " in connection options", IgniteQueryErrorCode.UNSUPPORTED_OPERATION);
    if (plan.mode == UpdateMode.INSERT && plan.rowsNum > 0) {
        assert plan.isLocSubqry;
        final GridCacheContext cctx = plan.tbl.rowDescriptor().context();
        QueryCursorImpl<List<?>> cur;
        final ArrayList<List<?>> data = new ArrayList<>(plan.rowsNum);
        final GridQueryFieldsResult res = idx.queryLocalSqlFields(idx.schema(cctx.name()), plan.selectQry, F.asList(args), null, false, 0, null);
        QueryCursorImpl<List<?>> stepCur = new QueryCursorImpl<>(new Iterable<List<?>>() {

            @Override
            public Iterator<List<?>> iterator() {
                try {
                    return new GridQueryCacheObjectsIterator(res.iterator(), idx.objectContext(), cctx.keepBinary());
                } catch (IgniteCheckedException e) {
                    throw new IgniteException(e);
                }
            }
        }, null);
        data.addAll(stepCur.getAll());
        cur = new QueryCursorImpl<>(new Iterable<List<?>>() {

            @Override
            public Iterator<List<?>> iterator() {
                return data.iterator();
            }
        }, null);
        if (plan.rowsNum == 1) {
            IgniteBiTuple t = rowToKeyValue(cctx, cur.iterator().next(), plan);
            streamer.addData(t.getKey(), t.getValue());
            return 1;
        }
        Map<Object, Object> rows = new LinkedHashMap<>(plan.rowsNum);
        for (List<?> row : cur) {
            final IgniteBiTuple t = rowToKeyValue(cctx, row, plan);
            rows.put(t.getKey(), t.getValue());
        }
        streamer.addData(rows);
        return rows.size();
    } else
        throw new IgniteSQLException("Only tuple based INSERT statements are supported in streaming mode", IgniteQueryErrorCode.UNSUPPORTED_OPERATION);
}

Example 2 with GridCacheContext

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

the class IgniteH2Indexing method checkCacheIndexSegmentation.

/**
     * @throws IllegalStateException if segmented indices used with non-segmented indices.
     */
private void checkCacheIndexSegmentation(List<Integer> cacheIds) {
    if (cacheIds.isEmpty())
        // Nothing to check
        return;
    GridCacheSharedContext sharedCtx = ctx.cache().context();
    int expectedParallelism = 0;
    for (Integer cacheId : cacheIds) {
        GridCacheContext cctx = sharedCtx.cacheContext(cacheId);
        assert cctx != null;
        if (!cctx.isPartitioned())
            continue;
        if (expectedParallelism == 0)
            expectedParallelism = cctx.config().getQueryParallelism();
        else if (cctx.config().getQueryParallelism() != expectedParallelism) {
            throw new IllegalStateException("Using indexes with different parallelism levels in same query is " + "forbidden.");
        }
    }
}

Example 3 with GridCacheContext

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

the class IgniteTxStateImpl method hasNearCache.

/** {@inheritDoc} */
@Override
public boolean hasNearCache(GridCacheSharedContext cctx) {
    for (int i = 0; i < activeCacheIds.size(); i++) {
        int cacheId = activeCacheIds.get(i);
        GridCacheContext cacheCtx = cctx.cacheContext(cacheId);
        if (cacheCtx.isNear())
            return true;
    }
    return false;
}

Example 4 with GridCacheContext

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

the class GridDistributedCacheEntry method checkThreadChain.

/**
 * {@inheritDoc}
 */
@Override
protected final void checkThreadChain(GridCacheMvccCandidate owner) {
    assert !lockedByCurrentThread();
    assert owner != null;
    assert owner.owner() || owner.used() : "Neither owner or used flags are set on ready local candidate: " + owner;
    if (owner.local() && owner.next() != null) {
        for (GridCacheMvccCandidate cand = owner.next(); cand != null; cand = cand.next()) {
            assert cand.local() : "Remote candidate cannot be part of thread chain: " + cand;
            // Allow next lock in the thread to proceed.
            if (!cand.used()) {
                GridCacheContext cctx0 = cand.parent().context();
                GridDistributedCacheEntry e = (GridDistributedCacheEntry) cctx0.cache().peekEx(cand.parent().key());
                if (e != null)
                    e.recheck();
                break;
            }
        }
    }
}

Example 5 with GridCacheContext

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

the class GridDhtTxFinishResponse method prepareMarshal.

/**
 * {@inheritDoc}
 */
@Override
public void prepareMarshal(GridCacheSharedContext ctx) throws IgniteCheckedException {
    super.prepareMarshal(ctx);
    if (checkCommittedErr != null && checkCommittedErrBytes == null)
        checkCommittedErrBytes = U.marshal(ctx, checkCommittedErr);
    if (retVal != null && retVal.cacheId() != 0) {
        GridCacheContext cctx = ctx.cacheContext(retVal.cacheId());
        assert cctx != null : retVal.cacheId();
        retVal.prepareMarshal(cctx);
    }
}