Java Code Examples for org.apache.ignite.IgniteCache#remove()

/**
 * @param concurrency Concurrency.
 * @throws Exception If failed.
 */
private void checkPeekTxRemove(TransactionConcurrency concurrency) throws Exception {
    if (txShouldBeUsed()) {
        Ignite ignite = primaryIgnite("key");
        IgniteCache<String, Integer> cache = ignite.cache(DEFAULT_CACHE_NAME).withAllowAtomicOpsInTx();

        cache.put("key", 1);

        try (Transaction tx = ignite.transactions().txStart(concurrency, READ_COMMITTED)) {
            cache.remove("key");

            assertNull(cache.get("key")); // localPeek ignores transactions.
            assertNotNull(peek(cache, "key")); // localPeek ignores transactions.

            tx.commit();
        }
    }
}
 

/**
 * @param cache Cache.
 * @param reuseList Reuse list.
 */
private void putRemoveCycles(IgniteCache<Object, Object> cache, ReuseList reuseList) throws IgniteCheckedException {
    for (int i = 1; i <= ENTRIES; i++) {
        cache.put(i, new TestObject(PAGE_SIZE / 4 - 50));

        if (i % (ENTRIES / 10) == 0)
            System.out.println(">>> Entries put: " + i);
    }

    System.out.println("### Recycled pages count: " + reuseList.recycledPagesCount());

    for (int i = 1; i <= ENTRIES; i++) {
        cache.remove(i);

        if (i % (ENTRIES / 10) == 0)
            System.out.println(">>> Entries removed: " + i);
    }

    System.out.println("### Recycled pages count: " + reuseList.recycledPagesCount());

    Random rnd = new Random();

    for (int i = 1; i <= SMALL_ENTRIES; i++) {
        cache.put(i, rnd.nextInt());

        if (i % (SMALL_ENTRIES / 10) == 0)
            System.out.println(">>> Small entries put: " + i);
    }

    System.out.println("### Recycled pages count: " + reuseList.recycledPagesCount());

    for (int i = 1; i <= SMALL_ENTRIES; i++) {
        cache.remove(i);

        if (i % (SMALL_ENTRIES / 10) == 0)
            System.out.println(">>> Small entries removed: " + i);
    }

    System.out.println("### Recycled pages count: " + reuseList.recycledPagesCount());
}
 

/**
 * INternal routine for ATOMIC cache testing.
 *
 * @param caches Caches.
 * @throws Exception If failed.
 */
private void testAtomic0(IgniteCache<Integer, Object>[] caches) throws Exception {
    byte[] val = wrap(1);

    for (IgniteCache<Integer, Object> cache : caches) {
        cache.put(KEY_1, val);

        for (IgniteCache<Integer, Object> cacheInner : caches)
            assertArrayEquals(val, (byte[])cacheInner.get(KEY_1));

        cache.remove(KEY_1);

        assertNull(cache.get(KEY_1));
    }
}
 

/**
 * @throws Exception If failed.
 */
@Test
public void testRemoves() throws Exception {
    IgniteCache<Integer, Integer> cache = grid(0).cache(DEFAULT_CACHE_NAME);

    cache.put(1, 1);

    // +1 remove
    cache.remove(1);

    assertEquals(1L, cache.localMetrics().getCacheRemovals());
}
 

/**
 * @throws Exception If failed.
 */
private void checkPutRemoveGet() throws Exception {
    Ignite ignite0 = grid(0);

    IgniteCache<Integer, Integer> cache0 = ignite0.cache(DEFAULT_CACHE_NAME);

    Integer key = key(ignite0, NOT_PRIMARY_AND_BACKUP);

    cache0.put(key, key);

    for (int i = 0; i < GRID_CNT; i++)
        grid(i).cache(DEFAULT_CACHE_NAME).get(key);

    cache0.remove(key);

    cache0.put(key, key);

    for (int i = 0; i < GRID_CNT; i++)
        grid(i).cache(DEFAULT_CACHE_NAME).get(key);

    cache0.remove(key);
}
 

/**
 * Checks that gets work for implicit txs.
 *
 * @param ignite Ignite instance.
 * @param cache Cache to test.
 * @throws Exception If failed.
 */
private void checkExplicitTx(Ignite ignite, IgniteCache<String, String> cache) throws Exception {
    Transaction tx = ignite.transactions().txStart();

    try {
        assertNull(cache.get("key1"));

        tx.commit();
    }
    finally {
        tx.close();
    }

    tx = ignite.transactions().txStart();

    try {
        assertNull(cache.getAsync("key2").get());

        tx.commit();
    }
    finally {
        tx.close();
    }

    tx = ignite.transactions().txStart();

    try {
        assertTrue(cache.getAll(F.asSet("key3", "key4")).isEmpty());

        tx.commit();
    }
    finally {
        tx.close();
    }

    tx = ignite.transactions().txStart();

    try {
        assertTrue(((Map)cache.getAllAsync(F.asSet("key5", "key6")).get()).isEmpty());

        tx.commit();
    }
    finally {
        tx.close();
    }

    tx = ignite.transactions().txStart();

    try {
        cache.put("key7", "key7");

        cache.remove("key7");

        assertNull(cache.get("key7"));

        tx.commit();
    }
    finally {
        tx.close();
    }

    checkEmpty(cache);
}
 

/**
 * Test that cache entry removes are rebalanced properly using WAL.
 *
 * @throws Exception If failed.
 */
@Test
public void testRebalanceRemoves() throws Exception {
    backups = 4;

    IgniteEx ig0 = startGrid(0);
    IgniteEx ig1 = startGrid(1);

    final int entryCnt = PARTS_CNT * 100;

    ig0.cluster().active(true);

    IgniteCache<Object, Object> cache = ig0.cache(CACHE_NAME);

    for (int k = 0; k < entryCnt; k++)
        cache.put(k, new IndexedObject(k));

    forceCheckpoint();

    stopGrid(1, false);

    for (int k = 0; k < entryCnt; k++) {
        if (k % 3 != 2)
            cache.put(k, new IndexedObject(k + 1));
        else // Spread removes across all partitions.
            cache.remove(k);
    }

    forceCheckpoint();

    ig1 = startGrid(1);

    awaitPartitionMapExchange();

    for (Ignite ig : G.allGrids()) {
        IgniteCache<Object, Object> cache1 = ig.cache(CACHE_NAME);

        for (int k = 0; k < entryCnt; k++) {
            if (k % 3 != 2)
                assertEquals(new IndexedObject(k + 1), cache1.get(k));
            else
                assertNull(cache1.get(k));
        }
    }
}
 

/**
 * @throws Exception If failed.
 */
@Test
public void testFreeListRecovery() throws Exception {
    try {
        pageSize = 1024;
        extraCcfg = new CacheConfiguration(CACHE2_NAME);

        Ignite ignite = startGrid(0);

        ignite.cluster().active(true);

        IgniteCache<Integer, IndexedValue> cache1 = ignite.cache(CACHE_NAME);
        IgniteCache<Object, Object> cache2 = ignite.cache(CACHE2_NAME);

        final int KEYS1 = 2048;

        for (int i = 0; i < KEYS1; i++)
            cache1.put(i, new IndexedValue(i));

        for (int i = 0; i < KEYS1; i++) {
            if (i % 2 == 0)
                cache1.remove(i);
        }

        ThreadLocalRandom rnd = ThreadLocalRandom.current();

        for (int i = 0; i < KEYS1; i++) {
            cache2.put(i, new byte[rnd.nextInt(512)]);

            if (rnd.nextBoolean())
                cache2.put(i, new byte[rnd.nextInt(512)]);

            if (rnd.nextBoolean())
                cache2.remove(i);
        }

        Map<Integer, T2<Map<Integer, long[]>, int[]>> cache1_1 = getFreeListData(ignite, CACHE_NAME);
        Map<Integer, T2<Map<Integer, long[]>, int[]>> cache2_1 = getFreeListData(ignite, CACHE2_NAME);
        T2<long[], Integer> rl1_1 = getReuseListData(ignite, CACHE_NAME);
        T2<long[], Integer> rl2_1 = getReuseListData(ignite, CACHE2_NAME);

        ignite.close();

        ignite = startGrid(0);

        ignite.cluster().active(true);

        cache1 = ignite.cache(CACHE_NAME);
        cache2 = ignite.cache(CACHE2_NAME);

        for (int i = 0; i < KEYS1; i++) {
            cache1.get(i);
            cache2.get(i);
        }

        Map<Integer, T2<Map<Integer, long[]>, int[]>> cache1_2 = getFreeListData(ignite, CACHE_NAME);
        Map<Integer, T2<Map<Integer, long[]>, int[]>> cache2_2 = getFreeListData(ignite, CACHE2_NAME);
        T2<long[], Integer> rl1_2 = getReuseListData(ignite, CACHE_NAME);
        T2<long[], Integer> rl2_2 = getReuseListData(ignite, CACHE2_NAME);

        checkEquals(cache1_1, cache1_2);
        checkEquals(cache2_1, cache2_2);
        checkEquals(rl1_1, rl1_2);
        checkEquals(rl2_1, rl2_2);
    }
    finally {
        stopAllGrids();
    }
}
 

/** */
@Test
public void testRemoveTime() {
    IgniteCache<Integer, Integer> cache = grid(0).cache(DEFAULT_CACHE_NAME);

    HistogramMetricImpl m = metric("RemoveTime");

    assertTrue(Arrays.stream(m.value()).allMatch(v -> v == 0));

    cache.put(1, 1);

    assertTrue(Arrays.stream(m.value()).allMatch(v -> v == 0));

    cache.remove(1);

    assertEquals(1, Arrays.stream(m.value()).filter(v -> v == 1).count());
}
 

/**
 * @throws Exception If failed.
 */
@Test
public void testRecoveryRandomPutRemove() throws Exception {
    try {
        pageSize = 1024;

        extraCcfg = new CacheConfiguration(CACHE2_NAME);
        extraCcfg.setAffinity(new RendezvousAffinityFunction(false, PARTS));

        Ignite ignite = startGrid(0);

        ignite.cluster().active(true);

        GridCacheDatabaseSharedManager dbMgr = (GridCacheDatabaseSharedManager)((IgniteEx)ignite).context()
            .cache().context().database();

        dbMgr.enableCheckpoints(false).get();

        IgniteCache<Integer, IndexedValue> cache1 = ignite.cache(CACHE_NAME);
        IgniteCache<Object, Object> cache2 = ignite.cache(CACHE2_NAME);

        final int KEYS1 = 100;

        for (int i = 0; i < KEYS1; i++)
            cache1.put(i, new IndexedValue(i));

        for (int i = 0; i < KEYS1; i++) {
            if (i % 2 == 0)
                cache1.remove(i);
        }

        ThreadLocalRandom rnd = ThreadLocalRandom.current();

        for (int i = 0; i < KEYS1; i++) {
            cache2.put(i, new byte[rnd.nextInt(512)]);

            if (rnd.nextBoolean())
                cache2.put(i, new byte[rnd.nextInt(512)]);

            if (rnd.nextBoolean())
                cache2.remove(i);
        }

        ignite.close();

        ignite = startGrid(0);

        ignite.cluster().active(true);

        ignite.cache(CACHE_NAME).put(1, new IndexedValue(0));
    }
    finally {
        stopAllGrids();
    }
}
 

/**
 * @param concurrency Concurrency.
 * @param isolation Isolation.
 * @param op Operation to test.
 * @throws Exception If failed.
 */
private void testSimple0(TransactionConcurrency concurrency, TransactionIsolation isolation, int op) throws Exception {
    Ignite near = grid(0);

    final int key = 1, val = 1;

    final long TX_TIMEOUT = 250;

    IgniteCache<Object, Object> cache = near.cache(CACHE_NAME);

    try (Transaction tx = near.transactions().txStart(concurrency, isolation, TX_TIMEOUT, 1)) {
        cache.put(key, val);

        U.sleep(TX_TIMEOUT * 2);

        try {
            switch (op) {
                case 0:
                    cache.put(key + 1, val);

                    break;

                case 1:
                    cache.remove(key + 1);

                    break;

                case 2:
                    cache.get(key + 1);

                    break;

                case 3:
                    tx.commit();

                    break;

                default:
                    fail();
            }

            fail("Tx must timeout");
        }
        catch (CacheException | IgniteException e) {
            assertTrue("Expected exception: " + e, X.hasCause(e, TransactionTimeoutException.class));
        }
    }

    assertFalse("Must be removed by rollback on timeout", near.cache(CACHE_NAME).containsKey(key));
    assertFalse("Must be removed by rollback on timeout", near.cache(CACHE_NAME).containsKey(key + 1));

    assertNull(near.transactions().tx());
}
 

/**
 * @param cache Cache.
 */
private void checkRemovePut(IgniteCache<Key, Val> cache) {
    final int INT = 24;

    assertEquals(val(INT), cache.get(key(INT)));

    cache.remove(key(INT));

    assertNull(cache.get(key(INT)));

    cache.put(key(INT), val(INT));

    assertEquals(val(INT), cache.get(key(INT)));
}
 

/**
 * @throws Exception if failed.
 */
@Test
public void testCreateUpdate0() throws Exception {
    startGrids(1);

    long ttl = 60L;

    final String key = "key1";

    final IgniteCache<String, String> cache = jcache();

    for (int i = 0; i < 1000; i++) {
        final IgniteCache<String, String> cache0 = cache.withExpiryPolicy(new ModifiedExpiryPolicy(new Duration(TimeUnit.HOURS, ttl)));

        cache0.put(key, key);

        info("PUT DONE");
    }

    long pSize = grid(0).context().cache().internalCache(DEFAULT_CACHE_NAME).context().ttl().pendingSize();

    assertTrue("Too many pending entries: " + pSize, pSize <= 1);

    cache.remove(key);

    pSize = grid(0).context().cache().internalCache(DEFAULT_CACHE_NAME).context().ttl().pendingSize();

    assertEquals(0, pSize);
}
 

/**
 * @throws Exception If failed.
 */
@Test
public void testChangeValueType2() throws Exception {
    Ignite srv0 = startGrid(0);

    CacheConfiguration<Object, Object> ccfg = cacheConfiguration(cacheMode(), FULL_SYNC, 0, DFLT_PARTITION_COUNT).
        setIndexedTypes(Integer.class, MvccTestSqlIndexValue.class, Integer.class, Integer.class);

    IgniteCache<Object, Object> cache = srv0.createCache(ccfg);

    cache.put(1, new MvccTestSqlIndexValue(1));
    cache.put(1, new MvccTestSqlIndexValue(2));

    checkSingleResult(cache, new SqlFieldsQuery("select idxVal1 from MvccTestSqlIndexValue"), 2);

    cache.remove(1);

    assertEquals(0, cache.query(new SqlFieldsQuery("select idxVal1 from MvccTestSqlIndexValue")).getAll().size());

    cache.put(1, 1);

    assertEquals(0, cache.query(new SqlFieldsQuery("select idxVal1 from MvccTestSqlIndexValue")).getAll().size());

    checkSingleResult(cache, new SqlFieldsQuery("select _val from Integer"), 1);

    cache.put(1, 2);

    checkSingleResult(cache, new SqlFieldsQuery("select _val from Integer"), 2);
}
 

/**
 * Test that changes in cache affect index, and vice versa.
 */
@Test
public void testIndexState() throws SQLException {
    IgniteCache<String, Person> cache = cache();

    assertSize(3);

    assertColumnValues(30, 20, 10);

    jdbcRun(CREATE_INDEX);

    assertSize(3);

    assertColumnValues(30, 20, 10);

    cache.remove("m");

    assertColumnValues(30, 10);

    cache.put("a", new Person(4, "someVal", "a", 5));

    assertColumnValues(5, 30, 10);

    jdbcRun(DROP_INDEX);

    assertColumnValues(5, 30, 10);
}
 

/**
 * @param backups Number of backups.
 * @throws Exception If failed.
 */
private void cacheOperations(int backups) throws Exception {
    ccfg = cacheConfiguration(backups, FULL_SYNC);

    final int SRVS = 4;

    startServers(SRVS);

    Ignite clientNode = startClientGrid(SRVS);

    final IgniteCache<Integer, Integer> nearCache = clientNode.cache(TEST_CACHE);

    Integer key = primaryKey(ignite(0).cache(TEST_CACHE));

    nearCache.replace(key, 1);

    nearCache.remove(key);

    nearCache.invoke(key, new SetValueEntryProcessor(null));

    Map<Integer, SetValueEntryProcessor> map = new HashMap<>();

    List<Integer> keys = primaryKeys(ignite(0).cache(TEST_CACHE), 2);

    map.put(keys.get(0), new SetValueEntryProcessor(1));
    map.put(keys.get(1), new SetValueEntryProcessor(null));

    nearCache.invokeAll(map);

    Set<Integer> rmvAllKeys = new HashSet<>();

    for (int i = 0; i < 100; i++) {
        nearCache.put(i, i);

        if (i % 2 == 0)
            rmvAllKeys.add(i);
    }

    nearCache.removeAll(rmvAllKeys);
}
 

/**
 * Checks that enabled near cache does not affect metrics.
 */
@Test
public void testNearCachePutRemoveGetMetrics() {
    IgniteEx initiator = grid(0);

    IgniteCache<Integer, Integer> cache0 = initiator.cache(DEFAULT_CACHE_NAME);

    for (int i = 0; ; i++) {
        if (!initiator.affinity(DEFAULT_CACHE_NAME).isPrimaryOrBackup(initiator.cluster().localNode(), i)) {
            cache0.put(i, i);

            GridCacheEntryEx nearEntry = near(cache0).peekEx(i);

            assertTrue("Near cache doesn't contain the key", nearEntry.hasValue());

            cache0.remove(i);

            nearEntry = near(cache0).peekEx(i);

            assertFalse("Near cache contains key which was deleted", nearEntry.hasValue());

            cache0.get(i);

            assertEquals(1, cache0.localMetrics().getCachePuts());
            assertEquals(1, cache0.localMetrics().getCacheRemovals());
            assertEquals(1, cache0.localMetrics().getCacheGets());

            break;
        }
    }
}
 

/** */
@Test
public void testObjectKeyHandling() throws Exception {
    Ignite ignite = startGrid();

    IgniteCache<Object, TestObject> cache = ignite.getOrCreateCache(cacheCfg());

    UUID uid = UUID.randomUUID();

    cache.put(uid, new TestObject("A"));

    assertItemsNumber(1);

    cache.put(1, new TestObject("B"));

    assertItemsNumber(2);

    cache.put(uid, new TestObject("C"));

    // Key should have been replaced
    assertItemsNumber(2);

    List<List<?>> res = cache.query(new SqlFieldsQuery("select _key, name from TestObject order by name")).getAll();

    assertEquals(res,
        Arrays.asList(
            Arrays.asList(1, "B"),
            Arrays.asList(uid, "C")
        )
    );

    cache.remove(1);

    assertItemsNumber(1);

    res = cache.query(new SqlFieldsQuery("select _key, name from TestObject")).getAll();

    assertEquals(res,
        Collections.singletonList(
            Arrays.asList(uid, "C")
        )
    );

    cache.remove(uid);

    // Removal has worked for both keys although the table was the same and keys were of different type
    assertItemsNumber(0);
}
 

/**
 * @param client Node executing cache operation.
 * @param ccfg Cache configuration.
 * @param c Cache update closure.
 * @throws Exception If failed.
 */
private void singleKeyPrimaryNodeLeft(
    Ignite client,
    final CacheConfiguration<Object, Object> ccfg,
    final IgniteBiInClosure<Integer, IgniteCache<Object, Object>> c) throws Exception {
    Ignite ignite = startGrid(NODES);

    awaitPartitionMapExchange();

    final TestRecordingCommunicationSpi commSpiClient =
        (TestRecordingCommunicationSpi)client.configuration().getCommunicationSpi();

    IgniteCache<Object, Object> cache = ignite.cache(ccfg.getName());

    final Integer key = primaryKey(cache);

    cache.remove(key);

    waitKeyRemoved(ccfg.getName(), key);

    commSpiClient.blockMessages(GridNearTxFinishRequest.class, ignite.name());

    final IgniteCache<Object, Object> clientCache = client.cache(ccfg.getName());

    IgniteInternalFuture<?> fut = GridTestUtils.runAsync(new Callable<Void>() {
        @Override public Void call() throws Exception {
            c.apply(key, clientCache);

            return null;
        }
    });

    boolean waitMsgSnd = GridTestUtils.waitForCondition(new GridAbsPredicate() {
        @Override public boolean apply() {
            return commSpiClient.hasBlockedMessages();
        }
    }, 5000);

    assertTrue(waitMsgSnd);

    ignite.close();

    commSpiClient.stopBlock(false);

    fut.get();

    awaitPartitionMapExchange();

    waitKeyUpdated(client, ccfg.getBackups() + 1, ccfg.getName(), key);

    clientCache.remove(key);

    waitKeyRemoved(ccfg.getName(), key);

    c.apply(key, clientCache);

    waitKeyUpdated(client, ccfg.getBackups() + 1, ccfg.getName(), key);
}
 

/**
 * @throws Exception If failed.
 */
private void checkRemove() throws Exception {
    log.info("Check remove.");

    Ignite ignite0 = grid(0);

    IgniteCache<Integer, Integer> cache0 = ignite0.cache(DEFAULT_CACHE_NAME);

    Integer primaryKey = key(ignite0, PRIMARY);

    log.info("Put from primary.");

    cache0.put(primaryKey, primaryKey);

    for (int i = 0; i < GRID_CNT; i++)
        checkEntry(grid(i), primaryKey, primaryKey, false);

    log.info("Remove from primary.");

    cache0.remove(primaryKey);

    for (int i = 0; i < GRID_CNT; i++)
        checkEntry(grid(i), primaryKey, null, false);

    if (backups > 0) {
        Integer backupKey = key(ignite0, BACKUP);

        log.info("Put from backup.");

        cache0.put(backupKey, backupKey);

        for (int i = 0; i < GRID_CNT; i++)
            checkEntry(grid(i), backupKey, backupKey, false);

        log.info("Remove from backup.");

        cache0.remove(backupKey);

        for (int i = 0; i < GRID_CNT; i++)
            checkEntry(grid(i), backupKey, null, false);
    }
}