2021-01-31 00:36:21 +01:00
|
|
|
package it.cavallium.dbengine.database.collections;
|
|
|
|
|
2022-03-16 13:47:56 +01:00
|
|
|
import io.netty5.buffer.api.Buffer;
|
|
|
|
import io.netty5.buffer.api.Drop;
|
|
|
|
import io.netty5.buffer.api.Owned;
|
|
|
|
import io.netty5.buffer.api.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-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-03-20 14:33:27 +01:00
|
|
|
public class DatabaseMapSingle<U> extends ResourceSupport<DatabaseStage<U>, DatabaseMapSingle<U>> implements
|
2021-09-23 20:57:28 +02:00
|
|
|
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();
|
2022-03-20 14:33:27 +01:00
|
|
|
private static final Drop<DatabaseMapSingle<?>> DROP = new Drop<>() {
|
2021-10-01 19:17:33 +02:00
|
|
|
@Override
|
2022-03-20 14:33:27 +01:00
|
|
|
public void drop(DatabaseMapSingle<?> obj) {
|
2022-05-20 10:20:00 +02:00
|
|
|
if (obj.keySupplier != null) {
|
|
|
|
obj.keySupplier.close();
|
2021-10-01 19:17:33 +02:00
|
|
|
}
|
|
|
|
if (obj.onClose != null) {
|
|
|
|
obj.onClose.run();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2022-03-20 14:33:27 +01:00
|
|
|
public Drop<DatabaseMapSingle<?>> fork() {
|
2021-10-01 19:17:33 +02:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2022-03-20 14:33:27 +01:00
|
|
|
public void attach(DatabaseMapSingle<?> obj) {
|
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-05-20 10:20:00 +02:00
|
|
|
private BufSupplier keySupplier;
|
2021-10-01 19:17:33 +02:00
|
|
|
private Runnable onClose;
|
2021-09-23 20:57:28 +02:00
|
|
|
|
2021-10-01 19:17:33 +02:00
|
|
|
@SuppressWarnings({"unchecked", "rawtypes"})
|
2022-05-20 10:20:00 +02:00
|
|
|
public DatabaseMapSingle(LLDictionary dictionary, BufSupplier keySupplier, Serializer<U> serializer,
|
2021-10-01 19:17:33 +02:00
|
|
|
Runnable onClose) {
|
2022-03-20 14:33:27 +01:00
|
|
|
super((Drop<DatabaseMapSingle<U>>) (Drop) DROP);
|
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;
|
|
|
|
this.onClose = onClose;
|
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
|
2021-09-23 20:57:28 +02:00
|
|
|
protected RuntimeException createResourceClosedException() {
|
|
|
|
throw new IllegalStateException("Closed");
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2022-03-20 14:33:27 +01:00
|
|
|
protected Owned<DatabaseMapSingle<U>> prepareSend() {
|
2022-05-20 10:20:00 +02:00
|
|
|
var keySupplier = this.keySupplier;
|
2021-10-01 19:17:33 +02:00
|
|
|
var onClose = this.onClose;
|
|
|
|
return drop -> {
|
2022-05-20 10:20:00 +02:00
|
|
|
var instance = new DatabaseMapSingle<>(dictionary, keySupplier, serializer, onClose);
|
2021-10-01 19:17:33 +02:00
|
|
|
drop.attach(instance);
|
|
|
|
return instance;
|
|
|
|
};
|
2021-09-23 20:57:28 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
protected void makeInaccessible() {
|
2022-05-20 10:20:00 +02:00
|
|
|
this.keySupplier = null;
|
2021-10-01 19:17:33 +02:00
|
|
|
this.onClose = null;
|
2021-06-26 02:35:33 +02:00
|
|
|
}
|
2021-01-31 00:36:21 +01:00
|
|
|
}
|