2021-01-31 00:36:21 +01:00
|
|
|
package it.cavallium.dbengine.database.collections;
|
|
|
|
|
2022-10-02 03:09:50 +02:00
|
|
|
import io.netty5.buffer.Buffer;
|
|
|
|
import io.netty5.buffer.Drop;
|
|
|
|
import io.netty5.buffer.Owned;
|
|
|
|
import io.netty5.buffer.internal.ResourceSupport;
|
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;
|
2022-05-20 10:20:00 +02:00
|
|
|
import it.cavallium.dbengine.database.BufSupplier;
|
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-08-22 21:23:22 +02:00
|
|
|
import it.cavallium.dbengine.database.serialization.SerializationException;
|
|
|
|
import it.cavallium.dbengine.database.serialization.SerializationFunction;
|
2021-02-02 19:40:37 +01:00
|
|
|
import it.cavallium.dbengine.database.serialization.Serializer;
|
2022-07-19 23:45:39 +02:00
|
|
|
import it.cavallium.dbengine.utils.SimpleResource;
|
2022-03-11 17:59:46 +01:00
|
|
|
import java.util.concurrent.atomic.AtomicLong;
|
2021-12-17 01:48:49 +01:00
|
|
|
import org.apache.logging.log4j.LogManager;
|
|
|
|
import org.apache.logging.log4j.Logger;
|
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;
|
|
|
|
|
2022-07-19 23:45:39 +02:00
|
|
|
public class DatabaseMapSingle<U> extends SimpleResource implements DatabaseStageEntry<U> {
|
2021-01-31 00:36:21 +01:00
|
|
|
|
2022-03-20 14:33:27 +01:00
|
|
|
private static final Logger LOG = LogManager.getLogger(DatabaseMapSingle.class);
|
2021-10-01 19:17:33 +02:00
|
|
|
|
2022-03-11 17:59:46 +01:00
|
|
|
private final AtomicLong totalZeroBytesErrors = new AtomicLong();
|
2021-10-01 19:17:33 +02:00
|
|
|
|
2021-01-31 00:36:21 +01:00
|
|
|
private final LLDictionary dictionary;
|
2022-05-20 10:20:00 +02:00
|
|
|
private final Mono<Buffer> keyMono;
|
2021-09-02 17:15:40 +02:00
|
|
|
private final Serializer<U> serializer;
|
2022-07-19 23:45:39 +02:00
|
|
|
private final BufSupplier keySupplier;
|
2021-09-23 20:57:28 +02:00
|
|
|
|
2022-07-19 23:45:39 +02:00
|
|
|
public DatabaseMapSingle(LLDictionary dictionary, BufSupplier keySupplier, Serializer<U> serializer) {
|
2021-11-08 16:33:41 +01:00
|
|
|
this.dictionary = dictionary;
|
2022-05-20 10:20:00 +02:00
|
|
|
this.keySupplier = keySupplier;
|
|
|
|
this.keyMono = Mono.fromSupplier(() -> keySupplier.get());
|
2021-11-08 16:33:41 +01:00
|
|
|
this.serializer = serializer;
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private LLSnapshot resolveSnapshot(@Nullable CompositeSnapshot snapshot) {
|
|
|
|
if (snapshot == null) {
|
|
|
|
return null;
|
|
|
|
} else {
|
|
|
|
return snapshot.getSnapshot(dictionary);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-21 01:06:55 +02:00
|
|
|
private U deserializeValue(Buffer value) {
|
2021-10-19 00:22:05 +02:00
|
|
|
try {
|
2022-05-21 01:06:55 +02:00
|
|
|
return serializer.deserialize(value);
|
2022-03-11 17:59:46 +01:00
|
|
|
} catch (IndexOutOfBoundsException ex) {
|
|
|
|
var exMessage = ex.getMessage();
|
|
|
|
if (exMessage != null && exMessage.contains("read 0 to 0, write 0 to ")) {
|
2022-05-20 10:20:00 +02:00
|
|
|
try (var key = keySupplier.get()) {
|
|
|
|
LOG.error("Unexpected zero-bytes value at "
|
|
|
|
+ dictionary.getDatabaseName() + ":" + dictionary.getColumnName() + ":" + LLUtils.toStringSafe(key));
|
|
|
|
}
|
2022-05-21 01:06:55 +02:00
|
|
|
return null;
|
2022-03-11 17:59:46 +01:00
|
|
|
} else {
|
2022-05-21 01:06:55 +02:00
|
|
|
throw ex;
|
2022-03-11 17:59:46 +01:00
|
|
|
}
|
2021-08-22 21:23:22 +02:00
|
|
|
} catch (SerializationException ex) {
|
2022-05-21 01:06:55 +02:00
|
|
|
throw ex;
|
2021-08-22 21:23:22 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-20 10:20:00 +02:00
|
|
|
private Buffer serializeValue(U value) throws SerializationException {
|
2021-10-19 00:22:05 +02:00
|
|
|
var valSizeHint = serializer.getSerializedSizeHint();
|
|
|
|
if (valSizeHint == -1) valSizeHint = 128;
|
2022-05-20 10:20:00 +02:00
|
|
|
var valBuf = dictionary.getAllocator().allocate(valSizeHint);
|
|
|
|
try {
|
2021-10-19 00:22:05 +02:00
|
|
|
serializer.serialize(value, valBuf);
|
2022-05-20 10:20:00 +02:00
|
|
|
return valBuf;
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
valBuf.close();
|
|
|
|
throw ex;
|
2021-10-19 00:22:05 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-31 00:36:21 +01:00
|
|
|
@Override
|
2022-05-21 23:49:06 +02:00
|
|
|
public Mono<U> get(@Nullable CompositeSnapshot snapshot) {
|
2022-05-21 01:06:55 +02:00
|
|
|
return Mono.usingWhen(dictionary.get(resolveSnapshot(snapshot), keyMono),
|
|
|
|
buf -> Mono.fromSupplier(() -> deserializeValue(buf)),
|
2022-06-20 12:30:33 +02:00
|
|
|
LLUtils::finalizeResource
|
2022-05-21 01:06:55 +02:00
|
|
|
);
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2021-01-31 19:52:47 +01:00
|
|
|
public Mono<U> setAndGetPrevious(U value) {
|
2022-05-21 01:06:55 +02:00
|
|
|
return Mono.usingWhen(dictionary
|
|
|
|
.put(keyMono, Mono.fromCallable(() -> serializeValue(value)), LLDictionaryResultType.PREVIOUS_VALUE),
|
|
|
|
buf -> Mono.fromSupplier(() -> deserializeValue(buf)),
|
2022-06-20 12:30:33 +02:00
|
|
|
LLUtils::finalizeResource);
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|
|
|
|
|
2021-02-06 19:21:31 +01:00
|
|
|
@Override
|
2021-08-22 21:23:22 +02:00
|
|
|
public Mono<U> update(SerializationFunction<@Nullable U, @Nullable U> updater,
|
2022-03-02 18:33:58 +01:00
|
|
|
UpdateReturnMode updateReturnMode) {
|
2022-05-21 01:06:55 +02:00
|
|
|
var resultMono = dictionary
|
2021-08-22 18:20:05 +02:00
|
|
|
.update(keyMono, (oldValueSer) -> {
|
2022-05-26 13:13:14 +02:00
|
|
|
try (oldValueSer) {
|
|
|
|
U result;
|
|
|
|
if (oldValueSer == null) {
|
|
|
|
result = updater.apply(null);
|
|
|
|
} else {
|
|
|
|
U deserializedValue = serializer.deserialize(oldValueSer);
|
|
|
|
result = updater.apply(deserializedValue);
|
|
|
|
}
|
|
|
|
if (result == null) {
|
|
|
|
return null;
|
|
|
|
} else {
|
|
|
|
return serializeValue(result);
|
|
|
|
}
|
2021-05-12 19:02:51 +02:00
|
|
|
}
|
2022-05-21 01:06:55 +02:00
|
|
|
}, updateReturnMode);
|
|
|
|
return Mono.usingWhen(resultMono,
|
|
|
|
result -> Mono.fromSupplier(() -> deserializeValue(result)),
|
2022-06-20 12:30:33 +02:00
|
|
|
LLUtils::finalizeResource
|
2022-05-21 01:06:55 +02:00
|
|
|
);
|
2021-05-08 03:09:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2022-03-02 18:33:58 +01:00
|
|
|
public Mono<Delta<U>> updateAndGetDelta(SerializationFunction<@Nullable U, @Nullable U> updater) {
|
2021-08-22 18:20:05 +02:00
|
|
|
return dictionary
|
|
|
|
.updateAndGetDelta(keyMono, (oldValueSer) -> {
|
2022-04-01 01:30:56 +02:00
|
|
|
U result;
|
|
|
|
if (oldValueSer == null) {
|
|
|
|
result = updater.apply(null);
|
|
|
|
} else {
|
|
|
|
U deserializedValue = serializer.deserialize(oldValueSer);
|
|
|
|
result = updater.apply(deserializedValue);
|
|
|
|
}
|
|
|
|
if (result == null) {
|
|
|
|
return null;
|
|
|
|
} else {
|
2022-05-20 10:20:00 +02:00
|
|
|
return serializeValue(result);
|
2021-05-12 19:02:51 +02:00
|
|
|
}
|
2022-07-03 01:32:13 +02:00
|
|
|
}).transform(mono -> LLUtils.mapLLDelta(mono, serialized -> serializer.deserialize(serialized)));
|
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() {
|
2022-05-21 01:06:55 +02:00
|
|
|
return Mono.usingWhen(dictionary.remove(keyMono, LLDictionaryResultType.PREVIOUS_VALUE),
|
|
|
|
result -> Mono.fromSupplier(() -> deserializeValue(result)),
|
2022-06-20 12:30:33 +02:00
|
|
|
LLUtils::finalizeResource
|
2022-05-21 01:06:55 +02:00
|
|
|
);
|
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-08-22 18:20:05 +02:00
|
|
|
return dictionary
|
2022-07-03 01:32:13 +02:00
|
|
|
.isRangeEmpty(resolveSnapshot(snapshot), keyMono.map(single -> LLRange.singleUnsafe(single)), false)
|
2021-08-22 18:20:05 +02:00
|
|
|
.map(empty -> empty ? 0L : 1L);
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Mono<Boolean> isEmpty(@Nullable CompositeSnapshot snapshot) {
|
2021-08-22 18:20:05 +02:00
|
|
|
return dictionary
|
2022-07-03 01:32:13 +02:00
|
|
|
.isRangeEmpty(resolveSnapshot(snapshot), keyMono.map(single -> LLRange.singleUnsafe(single)), true);
|
2021-01-31 19:52:47 +01:00
|
|
|
}
|
2021-04-30 19:15:04 +02:00
|
|
|
|
|
|
|
@Override
|
2021-09-23 20:57:28 +02:00
|
|
|
public Flux<BadBlock> badBlocks() {
|
2022-07-03 01:32:13 +02:00
|
|
|
return dictionary.badBlocks(keyMono.map(single -> LLRange.singleUnsafe(single)));
|
2021-04-30 19:15:04 +02:00
|
|
|
}
|
2021-06-26 02:35:33 +02:00
|
|
|
|
|
|
|
@Override
|
2022-07-19 23:45:39 +02:00
|
|
|
protected void onClose() {
|
|
|
|
keySupplier.close();
|
2021-06-26 02:35:33 +02:00
|
|
|
}
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|