Examples with EntryList com.thinkaurelius.titan.diskstorage.EntryList used on opensource projects

Example 1 with EntryList

use of com.thinkaurelius.titan.diskstorage.EntryList in project titan by thinkaurelius.

the class MultiKeySliceQuery method execute.

public List<EntryList> execute(final BackendTransaction tx) {
    int total = 0;
    List<EntryList> result = new ArrayList<EntryList>(4);
    for (KeySliceQuery ksq : queries) {
        EntryList next = tx.indexQuery(ksq.updateLimit(getLimit() - total));
        result.add(next);
        total += next.size();
        if (total >= getLimit())
            break;
    }
    return result;
}

Example 2 with EntryList

use of com.thinkaurelius.titan.diskstorage.EntryList in project titan by thinkaurelius.

the class CacheVertex method loadRelations.

@Override
public EntryList loadRelations(final SliceQuery query, final Retriever<SliceQuery, EntryList> lookup) {
    if (isNew())
        return EntryList.EMPTY_LIST;
    EntryList result;
    synchronized (queryCache) {
        result = queryCache.get(query);
    }
    if (result == null) {
        //First check for super
        Map.Entry<SliceQuery, EntryList> superset = getSuperResultSet(query);
        if (superset == null) {
            result = lookup.get(query);
        } else {
            result = query.getSubset(superset.getKey(), superset.getValue());
        }
        addToQueryCache(query, result);
    }
    return result;
}

Example 3 with EntryList

use of com.thinkaurelius.titan.diskstorage.EntryList in project titan by thinkaurelius.

the class KCVSCacheTest method testSmallCache.

@Test
public void testSmallCache() throws Exception {
    final int numKeys = 100, numCols = 10;
    final int repeats = 100, clearEvery = 20, numMulti = 10;
    //Assumed below
    assertTrue(numCols >= 10);
    loadStore(numKeys, numCols);
    //Repeatedly read from cache and clear in between
    int calls = 0;
    assertEquals(calls, store.getSliceCalls());
    for (int t = 0; t < repeats; t++) {
        if (t % clearEvery == 0) {
            cache.clearCache();
            calls += numKeys * 2 + 1;
        }
        CacheTransaction tx = getCacheTx();
        for (int i = 1; i <= numKeys; i++) {
            assertEquals(10, cache.getSlice(getQuery(i, 0, numCols + 1).setLimit(10), tx).size());
            assertEquals(3, cache.getSlice(getQuery(i, 2, 5), tx).size());
        }
        //Multi-query
        List<StaticBuffer> keys = new ArrayList<StaticBuffer>();
        for (int i = 10; i < 10 + numMulti; i++) keys.add(BufferUtil.getIntBuffer(i));
        Map<StaticBuffer, EntryList> result = cache.getSlice(keys, getQuery(4, 9), tx);
        assertEquals(keys.size(), result.size());
        for (StaticBuffer key : keys) assertTrue(result.containsKey(key));
        for (EntryList r : result.values()) {
            assertEquals(5, r.size());
        }
        tx.commit();
        assertEquals(calls, store.getSliceCalls());
    }
    store.resetCounter();
    //Check invalidation
    StaticBuffer key = BufferUtil.getIntBuffer(23);
    List<StaticBuffer> keys = new ArrayList<StaticBuffer>();
    keys.add(key);
    keys.add(BufferUtil.getIntBuffer(12));
    keys.add(BufferUtil.getIntBuffer(5));
    //Read
    CacheTransaction tx = getCacheTx();
    assertEquals(numCols, cache.getSlice(new KeySliceQuery(key, getQuery(0, numCols + 1)), tx).size());
    Map<StaticBuffer, EntryList> result = cache.getSlice(keys, getQuery(2, 8), tx);
    assertEquals(keys.size(), result.size());
    assertEquals(6, result.get(key).size());
    //Update
    List<Entry> dels = new ArrayList<Entry>(numCols / 2);
    for (int j = 1; j <= numCols; j = j + 2) dels.add(getEntry(j, j));
    cache.mutateEntries(key, KeyColumnValueStore.NO_ADDITIONS, dels, tx);
    tx.commit();
    assertEquals(2, store.getSliceCalls());
    //Ensure updates are correctly read
    tx = getCacheTx();
    assertEquals(numCols / 2, cache.getSlice(new KeySliceQuery(key, getQuery(0, numCols + 1)), tx).size());
    result = cache.getSlice(keys, getQuery(2, 8), tx);
    assertEquals(keys.size(), result.size());
    assertEquals(3, result.get(key).size());
    tx.commit();
    assertEquals(4, store.getSliceCalls());
}

Example 4 with EntryList

use of com.thinkaurelius.titan.diskstorage.EntryList in project titan by thinkaurelius.

the class ExpirationCacheTest method verifyResults.

private void verifyResults(StaticBuffer key, List<StaticBuffer> keys, SliceQuery query, int expectedResults) throws Exception {
    CacheTransaction tx = getCacheTx();
    assertEquals(expectedResults, cache.getSlice(new KeySliceQuery(key, query), tx).size());
    Map<StaticBuffer, EntryList> results = cache.getSlice(keys, query, tx);
    assertEquals(keys.size(), results.size());
    assertEquals(expectedResults, results.get(key).size());
    tx.commit();
}

Example 5 with EntryList

use of com.thinkaurelius.titan.diskstorage.EntryList in project titan by thinkaurelius.

the class LockCleanerRunnableTest method testDeletionWithExpiredAndValidLocks.

/**
     * Test the cleaner against a set of locks where some locks have timestamps
     * before the cutoff and others have timestamps after the cutoff. One lock
     * has a timestamp equal to the cutoff.
     */
@Test
public void testDeletionWithExpiredAndValidLocks() throws BackendException {
    final int lockCount = 10;
    final int expiredCount = 3;
    assertTrue(expiredCount + 2 <= lockCount);
    final long timeIncr = 1L;
    final Instant timeStart = Instant.EPOCH;
    final Instant timeCutoff = timeStart.plusMillis(expiredCount * timeIncr);
    ImmutableList.Builder<Entry> locksBuilder = ImmutableList.builder();
    ImmutableList.Builder<Entry> delsBuilder = ImmutableList.builder();
    for (int i = 0; i < lockCount; i++) {
        final Instant ts = timeStart.plusMillis(timeIncr * i);
        Entry lock = StaticArrayEntry.of(codec.toLockCol(ts, defaultLockRid, TimestampProviders.MILLI), BufferUtil.getIntBuffer(0));
        if (ts.isBefore(timeCutoff)) {
            delsBuilder.add(lock);
        }
        locksBuilder.add(lock);
    }
    EntryList locks = StaticArrayEntryList.of(locksBuilder.build());
    EntryList dels = StaticArrayEntryList.of(delsBuilder.build());
    assertTrue(expiredCount == dels.size());
    del = new StandardLockCleanerRunnable(store, kc, tx, codec, timeCutoff, TimestampProviders.MILLI);
    expect(store.getSlice(eq(ksq), eq(tx))).andReturn(locks);
    store.mutate(eq(key), eq(ImmutableList.<Entry>of()), eq(columnsOf(dels)), anyObject(StoreTransaction.class));
    ctrl.replay();
    del.run();
}