Java KCVEntryMutation类代码示例

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.cache.KCVEntryMutation; //导入依赖的package包/类
@Test
public void mutateManyStressTest() throws BackendException {

    Map<StaticBuffer, Map<StaticBuffer, StaticBuffer>> state =
            new HashMap<StaticBuffer, Map<StaticBuffer, StaticBuffer>>();

    int dels = 1024;
    int adds = 4096;

    for (int round = 0; round < 5; round++) {
        Map<StaticBuffer, KCVEntryMutation> changes = mutateState(state, dels, adds);

        applyChanges(changes, store1, tx);
        applyChanges(changes, store2, tx);
        newTx();

        int deletesExpected = 0 == round ? 0 : dels;

        int stateSizeExpected = adds + (adds - dels) * round;

        Assert.assertEquals(stateSizeExpected, checkThatStateExistsInStore(state, store1, round));
        Assert.assertEquals(deletesExpected, checkThatDeletionsApplied(changes, store1, round));

        Assert.assertEquals(stateSizeExpected, checkThatStateExistsInStore(state, store2, round));
        Assert.assertEquals(deletesExpected, checkThatDeletionsApplied(changes, store2, round));
    }
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.cache.KCVEntryMutation; //导入依赖的package包/类
public int checkThatDeletionsApplied(Map<StaticBuffer, KCVEntryMutation> changes, KeyColumnValueStore store, int round) throws BackendException {
    int checked = 0;
    int skipped = 0;

    for (StaticBuffer key : changes.keySet()) {
        KCVEntryMutation m = changes.get(key);

        if (!m.hasDeletions())
            continue;

        List<Entry> deletions = m.getDeletions();

        List<Entry> additions = m.getAdditions();

        for (Entry entry : deletions) {
            StaticBuffer col = entry.getColumn();

            if (null != additions && additions.contains(StaticArrayEntry.of(col, col))) {
                skipped++;
                continue;
            }

            Assert.assertNull(KCVSUtil.get(store, key, col, tx));

            checked++;
        }
    }

    log.debug("Checked absence of {} key-column-value deletions on round {} (skipped {})", new Object[]{checked, round, skipped});

    return checked;
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.cache.KCVEntryMutation; //导入依赖的package包/类
@Test
public void deletionsAppliedBeforeAdditions() throws BackendException {

    StaticBuffer b1 = KeyColumnValueStoreUtil.longToByteBuffer(1);

    Assert.assertNull(KCVSUtil.get(store1, b1, b1, tx));

    List<Entry> additions = Lists.newArrayList(StaticArrayEntry.of(b1, b1));

    List<Entry> deletions = Lists.newArrayList(additions);

    Map<StaticBuffer, KCVEntryMutation> combination = new HashMap<StaticBuffer, KCVEntryMutation>(1);
    Map<StaticBuffer, KCVEntryMutation> deleteOnly = new HashMap<StaticBuffer, KCVEntryMutation>(1);
    Map<StaticBuffer, KCVEntryMutation> addOnly = new HashMap<StaticBuffer, KCVEntryMutation>(1);

    combination.put(b1, new KCVEntryMutation(additions, deletions));
    deleteOnly.put(b1, new KCVEntryMutation(KeyColumnValueStore.NO_ADDITIONS, deletions));
    addOnly.put(b1, new KCVEntryMutation(additions, KCVSCache.NO_DELETIONS));

    store1.mutateEntries(b1, additions, deletions, tx);
    newTx();

    StaticBuffer result = KCVSUtil.get(store1, b1, b1, tx);

    Assert.assertEquals(b1, result);

    store1.mutateEntries(b1, NO_ADDITIONS, deletions, tx);
    newTx();

    for (int i = 0; i < 100; i++) {
        StaticBuffer n = KCVSUtil.get(store1, b1, b1, tx);
        Assert.assertNull(n);
        store1.mutateEntries(b1, additions, KCVSCache.NO_DELETIONS, tx);
        newTx();
        store1.mutateEntries(b1, NO_ADDITIONS, deletions, tx);
        newTx();
        n = KCVSUtil.get(store1, b1, b1, tx);
        Assert.assertNull(n);
    }

    for (int i = 0; i < 100; i++) {
        store1.mutateEntries(b1, NO_ADDITIONS, deletions, tx);
        newTx();
        store1.mutateEntries(b1, additions, KCVSCache.NO_DELETIONS, tx);
        newTx();
        Assert.assertEquals(b1, KCVSUtil.get(store1, b1, b1, tx));
    }

    for (int i = 0; i < 100; i++) {
        store1.mutateEntries(b1, additions, deletions, tx);
        newTx();
        Assert.assertEquals(b1, KCVSUtil.get(store1, b1, b1, tx));
    }
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.cache.KCVEntryMutation; //导入依赖的package包/类
public void applyChanges(Map<StaticBuffer, KCVEntryMutation> changes, KCVSCache store, StoreTransaction tx) throws BackendException {
    for (Map.Entry<StaticBuffer, KCVEntryMutation> change : changes.entrySet()) {
        store.mutateEntries(change.getKey(), change.getValue().getAdditions(), change.getValue().getDeletions(), tx);
    }
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.cache.KCVEntryMutation; //导入依赖的package包/类
@Override
public void consolidate() {
    super.consolidate(KCVEntryMutation.ENTRY2COLUMN_FCT, Functions.<StaticBuffer>identity());
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.cache.KCVEntryMutation; //导入依赖的package包/类
@Override
public boolean isConsolidated() {
    return super.isConsolidated(KCVEntryMutation.ENTRY2COLUMN_FCT, Functions.<StaticBuffer>identity());
}