@Override public KeyIterator getKeys(final KeyRangeQuery keyQuery, final StoreTransaction txh) throws BackendException { final KVQuery query = new KVQuery( concatenatePrefix(adjustToLength(keyQuery.getKeyStart()), keyQuery.getSliceStart()), concatenatePrefix(adjustToLength(keyQuery.getKeyEnd()), keyQuery.getSliceEnd()), keycolumn -> { final StaticBuffer key = getKey(keycolumn); return !(key.compareTo(keyQuery.getKeyStart()) < 0 || key.compareTo(keyQuery.getKeyEnd()) >= 0) && columnInRange(keycolumn, keyQuery.getSliceStart(), keyQuery.getSliceEnd()); }, BaseQuery.NO_LIMIT); //limit will be introduced in iterator return new KeyIteratorImpl(keyQuery,store.getSlice(query,txh)); }
@Override public KeyRangeQuery updateLimit(int newLimit) { return new KeyRangeQuery(keyStart,keyEnd,this).setLimit(newLimit); }
@Override public String toString() { return String.format("KeyRangeQuery(start: %s, end: %s, columns:[start: %s, end: %s], limit=%d)", keyStart, keyEnd, getSliceStart(), getSliceEnd(), getLimit()); } }
@Override public KeyIterator getKeys(final KeyRangeQuery query, final StoreTransaction txh) throws BackendException { return new RowIterator(kcv.subMap(query.getKeyStart(), query.getKeyEnd()).entrySet().iterator(), query, txh); }
@Override public KeyIterator call() throws Exception { return (storeFeatures.isKeyOrdered()) ? edgeStore.getKeys(new KeyRangeQuery(EDGESTORE_MIN_KEY, EDGESTORE_MAX_KEY, sliceQuery), storeTx) : edgeStore.getKeys(sliceQuery, storeTx); }
@Override public boolean hasNext() { Preconditions.checkState(open); if (current == null || count >= query.getLimit()) return false; // We need to check what is "current" right now and notify parent iterator // about change of main key otherwise we would be missing portion of the results StaticBuffer nextKey = getKey(current.getKey()); if (!nextKey.equals(currentKey)) { currentKey = nextKey; currentKeyReturned = false; return false; } return true; }
public static boolean matches(KeyRangeQuery query, StaticBuffer key, StaticBuffer column) { return matches(query,column) && query.getKeyStart().compareTo(key)<=0 && query.getKeyEnd().compareTo(key)>0; }
public static KeyIterator getKeys(KeyColumnValueStore store, SliceQuery slice, StoreFeatures features, int keyLength, StoreTransaction txh) throws BackendException { if (features.hasUnorderedScan()) { return store.getKeys(slice, txh); } else if (features.hasOrderedScan()) { return store.getKeys(new KeyRangeQuery(BufferUtil.zeroBuffer(1), BufferUtil.oneBuffer(keyLength), slice), txh); } else throw new UnsupportedOperationException("Provided stores does not support scan operations: " + store); }
@Override public KeyIterator getKeys(final KeyRangeQuery query, final StoreTransaction txh) throws BackendException { if (!this.storeManager.getFeatures().hasOrderedScan()) { throw new PermanentBackendException("This operation is only allowed when the byteorderedpartitioner is used."); } final Metadata metadata = this.session.getCluster().getMetadata(); return Try.of(() -> new CQLResultSetKeyIterator( query, this.getter, this.session.execute(this.getKeysRanged.bind() .setToken(KEY_START_BINDING, metadata.newToken(query.getKeyStart().asByteBuffer())) .setToken(KEY_END_BINDING, metadata.newToken(query.getKeyEnd().asByteBuffer())) .setBytes(SLICE_START_BINDING, query.getSliceStart().asByteBuffer()) .setBytes(SLICE_END_BINDING, query.getSliceEnd().asByteBuffer()) .setFetchSize(this.storeManager.getPageSize()) .setConsistencyLevel(getTransaction(txh).getReadConsistencyLevel())))) .getOrElseThrow(EXCEPTION_MAPPER); }
@Override public KeyIterator getKeys(KeyRangeQuery query, StoreTransaction txh) throws BackendException { return executeKeySliceQuery(query.getKeyStart().as(StaticBuffer.ARRAY_FACTORY), query.getKeyEnd().as(StaticBuffer.ARRAY_FACTORY), new FilterList(FilterList.Operator.MUST_PASS_ALL), query); }
KeyRangeQuery krq = new KeyRangeQuery(keyStart, keyEnd, sq);
public RecordIterator<Long> getVertexIDs(final BackendTransaction tx) { Preconditions.checkArgument(backend.getStoreFeatures().hasOrderedScan() || backend.getStoreFeatures().hasUnorderedScan(), "The configured storage backend does not support global graph operations - use Faunus instead"); final KeyIterator keyIterator; if (backend.getStoreFeatures().hasUnorderedScan()) { keyIterator = tx.edgeStoreKeys(vertexExistenceQuery); } else { keyIterator = tx.edgeStoreKeys(new KeyRangeQuery(IDHandler.MIN_KEY, IDHandler.MAX_KEY, vertexExistenceQuery)); } return new RecordIterator<Long>() { @Override public boolean hasNext() { return keyIterator.hasNext(); } @Override public Long next() { return idManager.getKeyID(keyIterator.next()); } @Override public void close() throws IOException { keyIterator.close(); } @Override public void remove() { throw new UnsupportedOperationException("Removal not supported"); } }; }
@Test @Category({OrderedKeyStoreTests.class}) public void testGetKeysWithKeyRange() throws Exception { if (!manager.getFeatures().hasOrderedScan()) { log.warn("Can't test ordered scans on incompatible store. " + "This warning could indicate reduced test coverage and " + "shouldn't happen in an ideal JUnit configuration. " + "Skipping test {}.", name.getMethodName()); return; } populateDBWith100Keys(); tx.commit(); tx = startTx(); KeyIterator keyIterator = store.getKeys(new KeyRangeQuery( KeyColumnValueStoreUtil.longToByteBuffer(10), // key start KeyColumnValueStoreUtil.longToByteBuffer(40), // key end new ReadArrayBuffer("b".getBytes()), // column start new ReadArrayBuffer("c".getBytes())), tx); examineGetKeysResults(keyIterator, 10, 40); }
keys = store.getKeys(new KeyRangeQuery(BufferUtil.getLongBuffer(minKey), BufferUtil.getLongBuffer(maxKey), columnSlice), tx); assertEquals(expectedKeyCount, KeyValueStoreUtil.count(keys)); keys = store.getKeys(new KeyRangeQuery(BufferUtil.getLongBuffer(minKey), BufferUtil.getLongBuffer(maxKey), columnSlice), tx); assertEquals(expectedKeyCount, KeyValueStoreUtil.count(keys));