How to use

IgniteInternalCache

in

org.apache.ignite.internal.processors.cache

  @Override public Void call() throws Exception {
    try (GridNearTxLocal tx = CU.txStartInternal(ctx, cacheView, PESSIMISTIC, REPEATABLE_READ)) {
      GridCacheAtomicReferenceValue<T> ref = cacheView.get(key);
      if (ref == null)
        throw new IgniteException("Failed to find atomic reference with given name: " + name);
      cacheView.put(key, new GridCacheAtomicReferenceValue<>(val));
      tx.commit();
    }
    return null;
  }
});

/** {@inheritDoc} */
@Override public Affinity affinity() {
  return delegate.get().affinity();
}

/** {@inheritDoc} */
@Override public CacheConfiguration configuration() {
  return delegate.configuration();
}

/** {@inheritDoc} */
@Override public boolean containsKey(K key) {
  IgniteInternalCache<K, V> delegate = getDelegateSafe();
  if (isAsync()) {
    setFuture(delegate.containsKeyAsync(key));
    return false;
  }
  else
    return delegate.containsKey(key);
}

/** {@inheritDoc} */
@Nullable @Override public V getAndPutIfAbsent(K key, V val) throws CacheException {
  IgniteInternalCache<K, V> delegate = getDelegateSafe();
  try {
    if (isAsync()) {
      setFuture(delegate.getAndPutIfAbsentAsync(key, val));
      return null;
    }
    else
      return delegate.getAndPutIfAbsent(key, val);
  }
  catch (IgniteCheckedException | IgniteException e) {
    throw cacheException(e);
  }
}

/**
 * Success if explicit tx doesn't fail.
 *
 * @param cache Cache instance.
 * @throws Exception If failed.
 */
protected void checkStartTxSuccess(final IgniteInternalCache<Object, Object> cache) throws Exception {
  try (final GridNearTxLocal tx = CU.txStartInternal(cache.context(), cache, PESSIMISTIC, REPEATABLE_READ)) {
    assert tx != null;
    sleepForTxFailure();
    cache.put("key", "val");
    tx.commit();
  }
  assert cache.containsKey("key");
  cache.clear();
}

/**
 * Fill cache.
 *
 * @throws IgniteCheckedException if failed.
 */
private static Set<Integer> populateCache(IgniteEx ignite, boolean loc, int cnt,
  IgnitePredicate<Integer> expectedEntryFilter) throws IgniteCheckedException {
  IgniteInternalCache<Integer, Person> cache = ignite.cachex(PERSON_CACHE);
  assertNotNull(cache);
  Random rand = new Random();
  HashSet<Integer> exp = new HashSet<>();
  Affinity<Integer> aff = cache.affinity();
  ClusterNode localNode = cache.context().localNode();
  for (int i = 0; i < cnt; i++) {
    int val = rand.nextInt(cnt);
    cache.put(val, new Person(String.valueOf(val), val));
    if (expectedEntryFilter.apply(val) && (!loc || aff.isPrimary(localNode, val)))
      exp.add(val);
  }
  return exp;
}

/**
 * @throws Exception If failed.
 */
@Test
public void testSystemTxInsideUserTx() throws Exception {
  Assume.assumeFalse("https://issues.apache.org/jira/browse/IGNITE-10473", MvccFeatureChecker.forcedMvcc());
  IgniteKernal ignite = (IgniteKernal)grid(0);
  IgniteCache<Object, Object> jcache = ignite.cache(DEFAULT_CACHE_NAME);
  try (Transaction tx = ignite.transactions().txStart(PESSIMISTIC, REPEATABLE_READ)) {
    jcache.get("1");
    jcache.put("1", "11");
    IgniteInternalCache<Object, Object> utilityCache = ignite.context().cache().utilityCache();
    utilityCache.getAndPutIfAbsent("2", "2");
    try (GridNearTxLocal itx = utilityCache.txStartEx(PESSIMISTIC, REPEATABLE_READ)) {
      assertEquals(null, utilityCache.get("1"));
      assertEquals("2", utilityCache.get("2"));
      assertEquals(null, utilityCache.get("3"));
      utilityCache.getAndPut("3", "3");
      itx.commit();
    }
    jcache.put("2", "22");
    tx.commit();
  }
  checkTransactionsCommitted();
  checkEntries(DEFAULT_CACHE_NAME, "1", "11", "2", "22", "3", null);
  checkEntries(CU.UTILITY_CACHE_NAME, "1", null, "2", "2", "3", "3");
}

  @Override public Object call() throws Exception {
    qryProc.querySqlFields(cache.context(), qry, null, false, true);
    return null;
  }
}, IgniteSQLException.class, "Multiple statements queries are not supported");

  /** {@inheritDoc} */
  @Override protected void operation(int key) throws Exception {
    cache.get(key);
  }
}

((IgniteKernal)grid(0)).getCache(cacheName).getAndPut(new GridCacheInternalKeyImpl("LONG", ""), new GridCacheAtomicLongValue(0));
  ((IgniteKernal)grid(0)).getCache(intCache.getName()).context().queries().sqlMetadata();
((IgniteKernal)grid(0)).getCache(intCache.getName()).remove(new GridCacheInternalKeyImpl("LONG", ""));

/**
 * Must be called when the grid is up.
 */
private List<Path> getIndexBinPaths() {
  return G.allGrids().stream()
    .map(grid -> (IgniteEx) grid)
    .map(grid -> {
      IgniteInternalCache<Object, Object> cachex = grid.cachex(DEFAULT_CACHE_NAME);
      assertNotNull(cachex);
      FilePageStoreManager pageStoreMgr = (FilePageStoreManager) cachex.context().shared().pageStore();
      assertNotNull(pageStoreMgr);
      File cacheWorkDir = pageStoreMgr.cacheWorkDir(cachex.configuration());
      return cacheWorkDir.toPath().resolve("index.bin");
    })
    .collect(Collectors.toList());
}

/**
 * Saves task name metadata to utility cache.
 *
 * @param taskName Task name.
 * @throws IgniteCheckedException If failed.
 */
private void saveTaskMetadata(String taskName) throws IgniteCheckedException {
  if (ctx.isDaemon())
    return;
  assert ctx.security().enabled();
  int nameHash = taskName.hashCode();
  // 0 is reserved for no task.
  if (nameHash == 0)
    nameHash = 1;
  GridTaskNameHashKey key = new GridTaskNameHashKey(nameHash);
  IgniteInternalCache<GridTaskNameHashKey, String> tasksMetaCache = taskMetaCache();
  String existingName = tasksMetaCache.get(key);
  if (existingName == null)
    existingName = tasksMetaCache.getAndPutIfAbsent(key, taskName);
  if (existingName != null && !F.eq(existingName, taskName))
    throw new IgniteCheckedException("Task name hash collision for security-enabled node " +
      "[taskName=" + taskName +
      ", existing taskName=" + existingName + ']');
}

hdr = new GridCacheQueueHeader(IgniteUuid.randomUuid(), cap, colloc, 0, 0, null);
GridCacheQueueHeader old = queueHdrView.withNoRetries().getAndPutIfAbsent(key, hdr);
hdr = queueHdrView.get(key);

/** {@inheritDoc} */
@Nullable @Override public EntryProcessorResult invoke(
  @Nullable AffinityTopologyVersion topVer,
  Object key,
  EntryProcessor entryProcessor,
  Object... args
) throws IgniteCheckedException {
  return delegate.get().invoke(topVer, key, entryProcessor, args);
}

/**
 * Generates next affinity key for local node based on current topology. If previous affinity key maps
 * on local node, return previous affinity key to prevent unnecessary file map growth.
 *
 * @param prevAffKey Affinity key of previous block.
 * @return Affinity key.
 */
@SuppressWarnings("ConstantConditions")
public IgniteUuid nextAffinityKey(@Nullable IgniteUuid prevAffKey) {
  // Do not generate affinity key for non-affinity nodes.
  if (!dataCache.context().affinityNode())
    return null;
  UUID nodeId = igfsCtx.kernalContext().localNodeId();
  if (prevAffKey != null && dataCache.affinity().mapKeyToNode(prevAffKey).isLocal())
    return prevAffKey;
  while (true) {
    IgniteUuid key = new IgniteUuid(nodeId, affKeyGen.getAndIncrement());
    if (dataCache.affinity().mapKeyToNode(key).isLocal())
      return key;
  }
}

/** {@inheritDoc} */
@Override public IgniteInternalFuture<EntryProcessorResult> invokeAsync(
  Object key,
  EntryProcessor entryProcessor,
  Object... args
) {
  return delegate.get().invokeAsync(keyTransformer.transform(key), entryProcessor, args);
}

if (separated && (cache == null || !cache.containsKey(new GridCacheSetHeaderKey(dsName)))) {
  cacheName += "#" + dsType.name() + "_" + dsName;
  IgnitePredicate<ClusterNode> cacheNodeFilter = cache.context().group().nodeFilter();

/** {@inheritDoc} */
@Override public boolean containsKeys(Collection keys) {
  return delegate.get().containsKey(transform(keys));
}

  @Override public GridRestResponse applyx(IgniteInternalFuture<?> f) throws IgniteCheckedException {
    GridCacheRestResponse resp = new GridCacheRestResponse();
    resp.setResponse(f.get());
    if (key != null)
      resp.setAffinityNodeId(c.cache().affinity().mapKeyToNode(key).id().toString());
    return resp;
  }
};