Method getMappedRange

fdbclient/MultiVersionTransaction.actor.cpp:157–193

}

ThreadFuture<MappedRangeResult> DLTransaction::getMappedRange(const KeySelectorRef& begin,
                                                              const KeySelectorRef& end,
                                                              const StringRef& mapper,
                                                              GetRangeLimits limits,
                                                              int matchIndex,
                                                              bool snapshot,
                                                              bool reverse) {
	FdbCApi::FDBFuture* f = api->transactionGetMappedRange(tr,
	                                                       begin.getKey().begin(),
	                                                       begin.getKey().size(),
	                                                       begin.orEqual,
	                                                       begin.offset,
	                                                       end.getKey().begin(),
	                                                       end.getKey().size(),
	                                                       end.orEqual,
	                                                       end.offset,
	                                                       mapper.begin(),
	                                                       mapper.size(),
	                                                       limits.rows,
	                                                       limits.bytes,
	                                                       FDB_STREAMING_MODE_EXACT,
	                                                       0,
	                                                       matchIndex,
	                                                       snapshot,
	                                                       reverse);
	return toThreadFuture<MappedRangeResult>(api, f, [](FdbCApi::FDBFuture* f, FdbCApi* api) {
		const FdbCApi::FDBMappedKeyValue* kvms;
		int count;
		FdbCApi::fdb_bool_t more;
		FdbCApi::fdb_error_t error = api->futureGetMappedKeyValueArray(f, &kvms, &count, &more);
		ASSERT(!error);

		// The memory for this is stored in the FDBFuture and is released when the future gets destroyed
		return MappedRangeResult(
		    MappedRangeResultRef(VectorRef<MappedKeyValueRef>((MappedKeyValueRef*)kvms, count), more), Arena());
	});
}

ThreadFuture<Standalone<VectorRef<const char*>>> DLTransaction::getAddressesForKey(const KeyRef& key) {
	FdbCApi::FDBFuture* f = api->transactionGetAddressesForKey(tr, key.begin(), key.size());