2021-01-31 00:36:21 +01:00
|
|
|
package it.cavallium.dbengine.database.collections;
|
|
|
|
|
2021-04-30 19:15:04 +02:00
|
|
|
import io.netty.buffer.ByteBuf;
|
2021-05-12 19:02:51 +02:00
|
|
|
import io.netty.util.ReferenceCounted;
|
2021-06-26 02:35:33 +02:00
|
|
|
import it.cavallium.dbengine.client.BadBlock;
|
2021-01-31 00:36:21 +01:00
|
|
|
import it.cavallium.dbengine.client.CompositeSnapshot;
|
2021-06-26 02:35:33 +02:00
|
|
|
import it.cavallium.dbengine.database.Column;
|
2021-05-08 03:09:00 +02:00
|
|
|
import it.cavallium.dbengine.database.Delta;
|
2021-01-31 00:36:21 +01:00
|
|
|
import it.cavallium.dbengine.database.LLDictionary;
|
|
|
|
import it.cavallium.dbengine.database.LLDictionaryResultType;
|
|
|
|
import it.cavallium.dbengine.database.LLRange;
|
|
|
|
import it.cavallium.dbengine.database.LLSnapshot;
|
2021-05-08 03:09:00 +02:00
|
|
|
import it.cavallium.dbengine.database.LLUtils;
|
|
|
|
import it.cavallium.dbengine.database.UpdateReturnMode;
|
2021-02-02 19:40:37 +01:00
|
|
|
import it.cavallium.dbengine.database.serialization.Serializer;
|
2021-06-26 02:35:33 +02:00
|
|
|
import it.unimi.dsi.fastutil.bytes.ByteList;
|
2021-02-06 19:21:31 +01:00
|
|
|
import java.util.Optional;
|
|
|
|
import java.util.function.Function;
|
2021-01-31 00:36:21 +01:00
|
|
|
import org.jetbrains.annotations.Nullable;
|
2021-06-26 02:35:33 +02:00
|
|
|
import reactor.core.publisher.Flux;
|
2021-01-31 00:36:21 +01:00
|
|
|
import reactor.core.publisher.Mono;
|
2021-04-30 19:15:04 +02:00
|
|
|
import static io.netty.buffer.Unpooled.*;
|
2021-01-31 00:36:21 +01:00
|
|
|
|
2021-01-31 19:52:47 +01:00
|
|
|
public class DatabaseSingle<U> implements DatabaseStageEntry<U> {
|
2021-01-31 00:36:21 +01:00
|
|
|
|
|
|
|
private final LLDictionary dictionary;
|
2021-04-30 19:15:04 +02:00
|
|
|
private final ByteBuf key;
|
|
|
|
private final Serializer<U, ByteBuf> serializer;
|
2021-01-31 00:36:21 +01:00
|
|
|
|
2021-04-30 19:15:04 +02:00
|
|
|
public DatabaseSingle(LLDictionary dictionary, ByteBuf key, Serializer<U, ByteBuf> serializer) {
|
2021-05-02 19:18:15 +02:00
|
|
|
try {
|
|
|
|
this.dictionary = dictionary;
|
|
|
|
this.key = key.retain();
|
|
|
|
this.serializer = serializer;
|
|
|
|
} finally {
|
|
|
|
key.release();
|
2021-04-30 19:15:04 +02:00
|
|
|
}
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private LLSnapshot resolveSnapshot(@Nullable CompositeSnapshot snapshot) {
|
|
|
|
if (snapshot == null) {
|
|
|
|
return null;
|
|
|
|
} else {
|
|
|
|
return snapshot.getSnapshot(dictionary);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2021-03-18 16:19:41 +01:00
|
|
|
public Mono<U> get(@Nullable CompositeSnapshot snapshot, boolean existsAlmostCertainly) {
|
2021-05-12 19:02:51 +02:00
|
|
|
return Mono
|
|
|
|
.defer(() -> dictionary.get(resolveSnapshot(snapshot), key.retain(), existsAlmostCertainly))
|
|
|
|
.map(this::deserialize)
|
2021-05-12 21:41:47 +02:00
|
|
|
.doFirst(key::retain)
|
|
|
|
.doAfterTerminate(key::release);
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2021-01-31 19:52:47 +01:00
|
|
|
public Mono<U> setAndGetPrevious(U value) {
|
2021-05-12 19:02:51 +02:00
|
|
|
return Mono
|
|
|
|
.using(
|
|
|
|
() -> serialize(value),
|
|
|
|
valueByteBuf -> dictionary
|
|
|
|
.put(key.retain(), valueByteBuf.retain(), LLDictionaryResultType.PREVIOUS_VALUE)
|
|
|
|
.map(this::deserialize),
|
|
|
|
ReferenceCounted::release
|
|
|
|
)
|
2021-05-12 21:41:47 +02:00
|
|
|
.doFirst(key::retain)
|
|
|
|
.doAfterTerminate(key::release);
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|
|
|
|
|
2021-02-06 19:21:31 +01:00
|
|
|
@Override
|
2021-05-08 03:09:00 +02:00
|
|
|
public Mono<U> update(Function<@Nullable U, @Nullable U> updater,
|
|
|
|
UpdateReturnMode updateReturnMode,
|
|
|
|
boolean existsAlmostCertainly) {
|
2021-05-12 19:02:51 +02:00
|
|
|
return Mono
|
|
|
|
.defer(() -> dictionary.update(key.retain(), (oldValueSer) -> {
|
|
|
|
var result = updater.apply(oldValueSer == null ? null : this.deserialize(oldValueSer));
|
|
|
|
if (result == null) {
|
|
|
|
return null;
|
|
|
|
} else {
|
|
|
|
return this.serialize(result);
|
|
|
|
}
|
|
|
|
}, updateReturnMode, existsAlmostCertainly))
|
|
|
|
.map(this::deserialize)
|
2021-05-12 21:41:47 +02:00
|
|
|
.doFirst(key::retain)
|
|
|
|
.doAfterTerminate(key::release);
|
2021-05-08 03:09:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Mono<Delta<U>> updateAndGetDelta(Function<@Nullable U, @Nullable U> updater,
|
|
|
|
boolean existsAlmostCertainly) {
|
2021-05-12 19:02:51 +02:00
|
|
|
return Mono
|
|
|
|
.defer(() -> dictionary.updateAndGetDelta(key.retain(), (oldValueSer) -> {
|
|
|
|
var result = updater.apply(oldValueSer == null ? null : this.deserialize(oldValueSer));
|
|
|
|
if (result == null) {
|
|
|
|
return null;
|
|
|
|
} else {
|
|
|
|
return this.serialize(result);
|
|
|
|
}
|
|
|
|
}, existsAlmostCertainly).transform(mono -> LLUtils.mapDelta(mono, this::deserialize)))
|
2021-05-12 21:41:47 +02:00
|
|
|
.doFirst(key::retain)
|
|
|
|
.doAfterTerminate(key::release);
|
2021-02-06 19:21:31 +01:00
|
|
|
}
|
|
|
|
|
2021-01-31 00:36:21 +01:00
|
|
|
@Override
|
2021-01-31 19:52:47 +01:00
|
|
|
public Mono<U> clearAndGetPrevious() {
|
2021-05-12 19:02:51 +02:00
|
|
|
return Mono
|
|
|
|
.defer(() -> dictionary
|
|
|
|
.remove(key.retain(), LLDictionaryResultType.PREVIOUS_VALUE)
|
|
|
|
)
|
|
|
|
.map(this::deserialize)
|
2021-05-12 21:41:47 +02:00
|
|
|
.doFirst(key::retain)
|
|
|
|
.doAfterTerminate(key::release);
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2021-02-24 16:43:07 +01:00
|
|
|
public Mono<Long> leavesCount(@Nullable CompositeSnapshot snapshot, boolean fast) {
|
2021-05-12 19:02:51 +02:00
|
|
|
return Mono
|
|
|
|
.defer(() -> dictionary
|
|
|
|
.isRangeEmpty(resolveSnapshot(snapshot), LLRange.single(key.retain()))
|
|
|
|
)
|
|
|
|
.map(empty -> empty ? 0L : 1L)
|
2021-05-12 21:41:47 +02:00
|
|
|
.doFirst(key::retain)
|
|
|
|
.doAfterTerminate(key::release);
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Mono<Boolean> isEmpty(@Nullable CompositeSnapshot snapshot) {
|
2021-05-12 19:02:51 +02:00
|
|
|
return Mono
|
|
|
|
.defer(() -> dictionary
|
|
|
|
.isRangeEmpty(resolveSnapshot(snapshot), LLRange.single(key.retain()))
|
|
|
|
)
|
2021-05-12 21:41:47 +02:00
|
|
|
.doFirst(key::retain)
|
|
|
|
.doAfterTerminate(key::release);
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|
2021-01-31 19:52:47 +01:00
|
|
|
|
|
|
|
//todo: temporary wrapper. convert the whole class to buffers
|
2021-04-30 19:15:04 +02:00
|
|
|
private U deserialize(ByteBuf bytes) {
|
2021-02-01 12:19:17 +01:00
|
|
|
return serializer.deserialize(bytes);
|
2021-01-31 19:52:47 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
//todo: temporary wrapper. convert the whole class to buffers
|
2021-04-30 19:15:04 +02:00
|
|
|
private ByteBuf serialize(U bytes) {
|
2021-02-01 12:19:17 +01:00
|
|
|
return serializer.serialize(bytes);
|
2021-01-31 19:52:47 +01:00
|
|
|
}
|
2021-04-30 19:15:04 +02:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public void release() {
|
|
|
|
key.release();
|
|
|
|
}
|
2021-06-26 02:35:33 +02:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public Flux<BadBlock> badBlocks() {
|
|
|
|
return this
|
|
|
|
.get(null, true)
|
2021-06-26 23:57:24 +02:00
|
|
|
.doOnNext(entry -> {
|
|
|
|
if (entry instanceof ReferenceCounted referenceCounted) {
|
|
|
|
referenceCounted.release();
|
|
|
|
}
|
|
|
|
})
|
2021-06-26 02:35:33 +02:00
|
|
|
.then(Mono.<BadBlock>empty())
|
|
|
|
.onErrorResume(ex -> Mono.just(new BadBlock(dictionary.getDatabaseName(),
|
|
|
|
Column.special(dictionary.getDatabaseName()),
|
|
|
|
ByteList.of(LLUtils.toArray(key)),
|
|
|
|
ex
|
|
|
|
)))
|
|
|
|
.flux();
|
|
|
|
}
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|