Java KeySliceQuery类代码示例

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
@Test
public void testMutateWithLockUsesConsistentTx() throws BackendException {
    final ImmutableList<Entry> adds = ImmutableList.of(StaticArrayEntry.of(DATA_COL, DATA_VAL));
    final ImmutableList<StaticBuffer> dels = ImmutableList.<StaticBuffer>of();
    final KeyColumn kc = new KeyColumn(LOCK_KEY, LOCK_COL);

    // 1. Acquire a lock
    backingLocker.writeLock(kc, consistentTx);

    // 2. Run a mutation
    // N.B. mutation coordinates do not overlap with the lock, but consistentTx should be used anyway
    // 2.1. Check locks & expected values before mutating data
    backingLocker.checkLocks(consistentTx);
    StaticBuffer nextBuf = BufferUtil.nextBiggerBuffer(kc.getColumn());
    KeySliceQuery expectedValueQuery = new KeySliceQuery(kc.getKey(), kc.getColumn(), nextBuf);
    expect(backingStore.getSlice(expectedValueQuery, consistentTx)) // expected value read must use strong consistency
        .andReturn(StaticArrayEntryList.of(StaticArrayEntry.of(LOCK_COL, LOCK_VAL)));
    // 2.2. Mutate data
    backingStore.mutate(DATA_KEY, adds, dels, consistentTx); // writes by txs with locks must use strong consistency

    ctrl.replay();
    // 1. Lock acquisition
    expectStore.acquireLock(LOCK_KEY, LOCK_COL, LOCK_VAL, expectTx);
    // 2. Mutate
    expectStore.mutate(DATA_KEY, adds, dels, expectTx);
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
private long getCurrentID(final StaticBuffer partitionKey) throws BackendException {
    List<Entry> blocks = BackendOperation.execute(new BackendOperation.Transactional<List<Entry>>() {
        @Override
        public List<Entry> call(StoreTransaction txh) throws BackendException {
            return idStore.getSlice(new KeySliceQuery(partitionKey, LOWER_SLICE, UPPER_SLICE).setLimit(5), txh);
        }
    },this,times);

    if (blocks == null) throw new TemporaryBackendException("Could not read from storage");
    long latest = BASE_ID;

    for (Entry e : blocks) {
        long counterVal = getBlockValue(e);
        if (latest < counterVal) {
            latest = counterVal;
        }
    }
    return latest;
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
private void runWithExceptions() throws BackendException {
    StaticBuffer lockKey = serializer.toLockKey(target.getKey(), target.getColumn());
    List<Entry> locks = store.getSlice(new KeySliceQuery(lockKey, LOCK_COL_START, LOCK_COL_END), tx); // TODO reduce LOCK_COL_END based on cutoff

    ImmutableList.Builder<StaticBuffer> b = ImmutableList.builder();

    for (Entry lc : locks) {
        TimestampRid tr = serializer.fromLockColumn(lc.getColumn(), times);
        if (tr.getTimestamp().isBefore(cutoff)) {
            log.info("Deleting expired lock on {} by rid {} with timestamp {} (before or at cutoff {})",
                    new Object[] { target, tr.getRid(), tr.getTimestamp(), cutoff });
            b.add(lc.getColumn());
        } else {
            log.debug("Ignoring lock on {} by rid {} with timestamp {} (timestamp is after cutoff {})",
                    new Object[] { target, tr.getRid(), tr.getTimestamp(), cutoff });
        }
    }

    List<StaticBuffer> dels = b.build();

    if (!dels.isEmpty()) {
        store.mutate(lockKey, ImmutableList.<Entry>of(), dels, tx);
        log.info("Deleted {} expired locks (before or at cutoff {})", dels.size(), cutoff);
    }
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
private void runWithExceptions() throws BackendException {
    StaticBuffer lockKey = serializer.toLockKey(target.getKey(), target.getColumn());
    List<Entry> locks = store.getSlice(new KeySliceQuery(lockKey, LOCK_COL_START, LOCK_COL_END), tx); // TODO reduce LOCK_COL_END based on cutoff

    ImmutableList.Builder<StaticBuffer> b = ImmutableList.builder();

    for (Entry lc : locks) {
        TimestampRid tr = serializer.fromLockColumn(lc.getColumn());
        if (tr.getTimestamp() < cutoff) {
            log.info("Deleting expired lock on {} by rid {} with timestamp {} (before or at cutoff {})",
                    new Object[] { target, tr.getRid(), tr.getTimestamp(), cutoff });
            b.add(lc.getColumn());
        } else {
            log.debug("Ignoring lock on {} by rid {} with timestamp {} (timestamp is after cutoff {})",
                    new Object[] { target, tr.getRid(), tr.getTimestamp(), cutoff });
        }
    }

    List<StaticBuffer> dels = b.build();

    if (!dels.isEmpty()) {
        store.mutate(lockKey, ImmutableList.<Entry>of(), dels, tx);
        log.info("Deleted {} expired locks (before or at cutoff {})", dels.size(), cutoff);
    }
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
@Test
public void testMutateManyWithLockUsesConsistentTx() throws BackendException {
    final ImmutableList<Entry> adds = ImmutableList.of(StaticArrayEntry.of(DATA_COL, DATA_VAL));
    final ImmutableList<StaticBuffer> dels = ImmutableList.<StaticBuffer>of();

    Map<String, Map<StaticBuffer, KCVMutation>> mutations =
            ImmutableMap.<String, Map<StaticBuffer, KCVMutation>>of(STORE_NAME,
                    ImmutableMap.<StaticBuffer, KCVMutation>of(DATA_KEY, new KCVMutation(adds, dels)));
    final KeyColumn kc = new KeyColumn(LOCK_KEY, LOCK_COL);

    // Acquire a lock
    backingLocker.writeLock(kc, consistentTx);

    // 2. Run mutateMany
    // 2.1. Check locks & expected values before mutating data
    backingLocker.checkLocks(consistentTx);
    StaticBuffer nextBuf = BufferUtil.nextBiggerBuffer(kc.getColumn());
    KeySliceQuery expectedValueQuery = new KeySliceQuery(kc.getKey(), kc.getColumn(), nextBuf);
    expect(backingStore.getSlice(expectedValueQuery, consistentTx)) // expected value read must use strong consistency
        .andReturn(StaticArrayEntryList.of(StaticArrayEntry.of(LOCK_COL, LOCK_VAL)));
    // 2.2. Run mutateMany on backing manager to modify data
    backingManager.mutateMany(mutations, consistentTx); // writes by txs with locks must use strong consistency

    ctrl.replay();
    // Lock acquisition
    expectStore.acquireLock(LOCK_KEY, LOCK_COL, LOCK_VAL, expectTx);
    // Mutate
    expectManager.mutateMany(mutations, expectTx);
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
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();
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
public EntryList edgeStoreQuery(final KeySliceQuery query) {
    return executeRead(new Callable<EntryList>() {
        @Override
        public EntryList call() throws Exception {
            return cacheEnabled?edgeStore.getSlice(query, storeTx):
                                edgeStore.getSliceNoCache(query,storeTx);
        }

        @Override
        public String toString() {
            return "EdgeStoreQuery";
        }
    });
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
private SliceQueryRunner(KeySliceQuery kq, CountDownLatch doneSignal, AtomicInteger failureCount,
                         Object[] resultArray, int resultPosition) {
    this.kq = kq;
    this.doneSignal = doneSignal;
    this.failureCount = failureCount;
    this.resultArray = resultArray;
    this.resultPosition = resultPosition;
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
public EntryList indexQuery(final KeySliceQuery query) {
    return executeRead(new Callable<EntryList>() {
        @Override
        public EntryList call() throws Exception {
            return cacheEnabled?indexStore.getSlice(query, storeTx):
                                indexStore.getSliceNoCache(query, storeTx);
        }

        @Override
        public String toString() {
            return "VertexIndexQuery";
        }
    });

}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
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;
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
public MultiKeySliceQuery getQuery(final CompositeIndexType index, List<Object[]> values) {
    List<KeySliceQuery> ksqs = new ArrayList<KeySliceQuery>(values.size());
    for (Object[] value : values) {
        ksqs.add(new KeySliceQuery(getIndexKey(index,value), BufferUtil.zeroBuffer(1), BufferUtil.oneBuffer(1)));
    }
    return new MultiKeySliceQuery(ksqs);
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
private void testGracePeriod(Duration graceWait) throws Exception {
    final int minCleanupTriggerCalls = 5;
    final int numKeys = 100, numCols = 10;
    loadStore(numKeys,numCols);
    //Replace cache with proper times
    cache = getCache(store,Duration.ofDays(200),graceWait);

    StaticBuffer key = BufferUtil.getIntBuffer(81);
    List<StaticBuffer> keys = new ArrayList<StaticBuffer>();
    keys.add(key);
    keys.add(BufferUtil.getIntBuffer(37));
    keys.add(BufferUtil.getIntBuffer(2));
    SliceQuery query = getQuery(2,8);

    verifyResults(key,keys,query,6);
    //If we modify through cache store...
    CacheTransaction tx = getCacheTx();
    cache.mutateEntries(key,KeyColumnValueStore.NO_ADDITIONS, Lists.newArrayList(getEntry(4,4)),tx);
    tx.commit();
    Instant utime = times.getTime();
    store.resetCounter();
    //...invalidation should happen and the result set is updated immediately
    verifyResults(key, keys, query, 5);
    assertEquals(2,store.getSliceCalls());
    //however, the key is expired and hence repeated calls need to go through to the store
    verifyResults(key, keys, query, 5);
    assertEquals(4,store.getSliceCalls());

    //however, when we sleep past the grace wait time and trigger a cleanup...
    times.sleepPast(utime.plus(graceWait));
    for (int t=0; t<minCleanupTriggerCalls;t++) {
        assertEquals(5,cache.getSlice(new KeySliceQuery(key,query),tx).size());
        times.sleepFor(Duration.ofMillis(5));
    }
    //...the cache should cache results again
    store.resetCounter();
    verifyResults(key, keys, query, 5);
    assertEquals(0,store.getSliceCalls());
    verifyResults(key, keys, query, 5);
    assertEquals(0,store.getSliceCalls());
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
private void recordLockGetSlice(EntryList returnedEntries) throws BackendException {
    final KeySliceQuery ksq = new KeySliceQuery(defaultLockKey, LOCK_COL_START, LOCK_COL_END);
    expect(store.getSlice(eq(ksq), eq(defaultTx))).andReturn(returnedEntries);
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
private void recordExceptionalLockGetSlice(Throwable t) throws BackendException {
    final KeySliceQuery ksq = new KeySliceQuery(defaultLockKey, LOCK_COL_START, LOCK_COL_END);
    expect(store.getSlice(eq(ksq), eq(defaultTx))).andThrow(t);
}
 

import com.thinkaurelius.titan.diskstorage.keycolumnvalue.KeySliceQuery; //导入依赖的package包/类
public MultiKeySliceQuery(List<KeySliceQuery> queries) {
    Preconditions.checkArgument(queries!=null && !queries.isEmpty());
    this.queries = queries;
}