Support Redis 8 vector sets redis#3296 (redis#3295)

* Initial implementation

* Part 2. Modified signature accordingly, added hallucinated JavaDoc

* Fix copyright

* Part 2. Adding the commands, partial implementation of the command builder, stubs for the outputs

* Unit tests fixed, Integration tests added

* Implemented parsing of complex data, fixed failing tests

* More testing. Advanced test cases added.

* Polishing

* Fixed some regressions from last change

* Leftovers : remove commented out values in the apigenerator, add some more JavaDoc

* Missed some formatting

* Fix Kotlin code with the large axe, not making any apologies

* Formatter

* Add vector set examples

Port of https://github.com/redis/redis-py/blob/master/doctests/dt_vec_set.py

* Use redis:8.0.2 image in doctests

* Add JSON in the mix

* Add vClearAttributes

---------

Co-authored-by: Igor Malinovskiy <[email protected]>

Author: 2 people

.github/workflows/doctests.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     services:
       redis-stack:
-        image: redis/redis-stack-server:latest
+        image: redis:8.0.2
         options: >-
           --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
         ports:
@@ -37,4 +37,4 @@ jobs:
             ${{ runner.os }}-maven-
       - name: Run doctests
         run: |
-          mvn -Pdoctests test
+          mvn -Pdoctests test

src/main/java/io/lettuce/core/AbstractRedisAsyncCommands.java

@@ -48,6 +48,8 @@
 import io.lettuce.core.protocol.CommandType;
 import io.lettuce.core.protocol.ProtocolKeyword;
 import io.lettuce.core.protocol.RedisCommand;
+import io.lettuce.core.vector.RawVector;
+import io.lettuce.core.vector.VectorMetadata;
 
 import java.time.Duration;
 import java.time.Instant;
@@ -79,14 +81,17 @@ public abstract class AbstractRedisAsyncCommands<K, V> implements RedisAclAsyncC
         RedisKeyAsyncCommands<K, V>, RedisStringAsyncCommands<K, V>, RedisListAsyncCommands<K, V>, RedisSetAsyncCommands<K, V>,
         RedisSortedSetAsyncCommands<K, V>, RedisScriptingAsyncCommands<K, V>, RedisServerAsyncCommands<K, V>,
         RedisHLLAsyncCommands<K, V>, BaseRedisAsyncCommands<K, V>, RedisTransactionalAsyncCommands<K, V>,
-        RedisGeoAsyncCommands<K, V>, RedisClusterAsyncCommands<K, V>, RedisJsonAsyncCommands<K, V> {
+        RedisGeoAsyncCommands<K, V>, RedisClusterAsyncCommands<K, V>, RedisJsonAsyncCommands<K, V>,
+        RedisVectorSetAsyncCommands<K, V> {
 
     private final StatefulConnection<K, V> connection;
 
     private final RedisCommandBuilder<K, V> commandBuilder;
 
     private final RedisJsonCommandBuilder<K, V> jsonCommandBuilder;
 
+    private final RedisVectorSetCommandBuilder<K, V> vectorSetCommandBuilder;
+
     private final Supplier<JsonParser> parser;
 
     /**
@@ -102,6 +107,7 @@ public AbstractRedisAsyncCommands(StatefulConnection<K, V> connection, RedisCode
         this.connection = connection;
         this.commandBuilder = new RedisCommandBuilder<>(codec);
         this.jsonCommandBuilder = new RedisJsonCommandBuilder<>(codec, parser);
+        this.vectorSetCommandBuilder = new RedisVectorSetCommandBuilder<>(codec, parser);
     }
 
     /**
@@ -1684,6 +1690,141 @@ public RedisFuture<List<JsonType>> jsonType(K key) {
         return dispatch(jsonCommandBuilder.jsonType(key, JsonPath.ROOT_PATH));
     }
 
+    @Override
+    public RedisFuture<Boolean> vadd(K key, V element, Double... vectors) {
+        return dispatch(vectorSetCommandBuilder.vadd(key, element, null, vectors));
+    }
+
+    @Override
+    public RedisFuture<Boolean> vadd(K key, int dimensionality, V element, Double... vectors) {
+        return dispatch(vectorSetCommandBuilder.vadd(key, dimensionality, element, null, vectors));
+    }
+
+    @Override
+    public RedisFuture<Boolean> vadd(K key, V element, VAddArgs args, Double... vectors) {
+        return dispatch(vectorSetCommandBuilder.vadd(key, element, args, vectors));
+    }
+
+    @Override
+    public RedisFuture<Boolean> vadd(K key, int dimensionality, V element, VAddArgs args, Double... vectors) {
+        return dispatch(vectorSetCommandBuilder.vadd(key, dimensionality, element, args, vectors));
+    }
+
+    @Override
+    public RedisFuture<Long> vcard(K key) {
+        return dispatch(vectorSetCommandBuilder.vcard(key));
+    }
+
+    @Override
+    public RedisFuture<Boolean> vClearAttributes(K key, V element) {
+        return dispatch(vectorSetCommandBuilder.vsetattr(key, element, ""));
+    }
+
+    @Override
+    public RedisFuture<Long> vdim(K key) {
+        return dispatch(vectorSetCommandBuilder.vdim(key));
+    }
+
+    @Override
+    public RedisFuture<List<Double>> vemb(K key, V element) {
+        return dispatch(vectorSetCommandBuilder.vemb(key, element));
+    }
+
+    @Override
+    public RedisFuture<RawVector> vembRaw(K key, V element) {
+        return dispatch(vectorSetCommandBuilder.vembRaw(key, element));
+    }
+
+    @Override
+    public RedisFuture<String> vgetattr(K key, V element) {
+        return dispatch(vectorSetCommandBuilder.vgetattr(key, element));
+    }
+
+    @Override
+    public RedisFuture<List<JsonValue>> vgetattrAsJsonValue(K key, V element) {
+        return dispatch(vectorSetCommandBuilder.vgetattrAsJsonValue(key, element));
+    }
+
+    @Override
+    public RedisFuture<VectorMetadata> vinfo(K key) {
+        return dispatch(vectorSetCommandBuilder.vinfo(key));
+    }
+
+    @Override
+    public RedisFuture<List<V>> vlinks(K key, V element) {
+        return dispatch(vectorSetCommandBuilder.vlinks(key, element));
+    }
+
+    @Override
+    public RedisFuture<Map<V, Double>> vlinksWithScores(K key, V element) {
+        return dispatch(vectorSetCommandBuilder.vlinksWithScores(key, element));
+    }
+
+    @Override
+    public RedisFuture<V> vrandmember(K key) {
+        return dispatch(vectorSetCommandBuilder.vrandmember(key));
+    }
+
+    @Override
+    public RedisFuture<List<V>> vrandmember(K key, int count) {
+        return dispatch(vectorSetCommandBuilder.vrandmember(key, count));
+    }
+
+    @Override
+    public RedisFuture<Boolean> vrem(K key, V element) {
+        return dispatch(vectorSetCommandBuilder.vrem(key, element));
+    }
+
+    @Override
+    public RedisFuture<Boolean> vsetattr(K key, V element, String json) {
+        return dispatch(vectorSetCommandBuilder.vsetattr(key, element, json));
+    }
+
+    @Override
+    public RedisFuture<Boolean> vsetattr(K key, V element, JsonValue json) {
+        return dispatch(vectorSetCommandBuilder.vsetattr(key, element, json));
+    }
+
+    @Override
+    public RedisFuture<List<V>> vsim(K key, Double... vectors) {
+        return dispatch(vectorSetCommandBuilder.vsim(key, null, vectors));
+    }
+
+    @Override
+    public RedisFuture<List<V>> vsim(K key, V element) {
+        return dispatch(vectorSetCommandBuilder.vsim(key, null, element));
+    }
+
+    @Override
+    public RedisFuture<List<V>> vsim(K key, VSimArgs args, Double... vectors) {
+        return dispatch(vectorSetCommandBuilder.vsim(key, args, vectors));
+    }
+
+    @Override
+    public RedisFuture<List<V>> vsim(K key, VSimArgs args, V element) {
+        return dispatch(vectorSetCommandBuilder.vsim(key, args, element));
+    }
+
+    @Override
+    public RedisFuture<Map<V, Double>> vsimWithScore(K key, Double... vectors) {
+        return dispatch(vectorSetCommandBuilder.vsimWithScore(key, null, vectors));
+    }
+
+    @Override
+    public RedisFuture<Map<V, Double>> vsimWithScore(K key, V element) {
+        return dispatch(vectorSetCommandBuilder.vsimWithScore(key, null, element));
+    }
+
+    @Override
+    public RedisFuture<Map<V, Double>> vsimWithScore(K key, VSimArgs args, Double... vectors) {
+        return dispatch(vectorSetCommandBuilder.vsimWithScore(key, args, vectors));
+    }
+
+    @Override
+    public RedisFuture<Map<V, Double>> vsimWithScore(K key, VSimArgs args, V element) {
+        return dispatch(vectorSetCommandBuilder.vsimWithScore(key, args, element));
+    }
+
     @Override
     public RedisFuture<List<K>> keys(K pattern) {
         return dispatch(commandBuilder.keys(pattern));

src/main/java/io/lettuce/core/AbstractRedisReactiveCommands.java

@@ -52,6 +52,8 @@
 import io.lettuce.core.tracing.TraceContext;
 import io.lettuce.core.tracing.TraceContextProvider;
 import io.lettuce.core.tracing.Tracing;
+import io.lettuce.core.vector.RawVector;
+import io.lettuce.core.vector.VectorMetadata;
 import io.netty.util.concurrent.EventExecutorGroup;
 import io.netty.util.concurrent.ImmediateEventExecutor;
 import reactor.core.publisher.Flux;
@@ -84,19 +86,21 @@
  * @author Tihomir Mateev
  * @since 4.0
  */
-public abstract class AbstractRedisReactiveCommands<K, V>
-        implements RedisAclReactiveCommands<K, V>, RedisHashReactiveCommands<K, V>, RedisKeyReactiveCommands<K, V>,
-        RedisStringReactiveCommands<K, V>, RedisListReactiveCommands<K, V>, RedisSetReactiveCommands<K, V>,
-        RedisSortedSetReactiveCommands<K, V>, RedisScriptingReactiveCommands<K, V>, RedisServerReactiveCommands<K, V>,
-        RedisHLLReactiveCommands<K, V>, BaseRedisReactiveCommands<K, V>, RedisTransactionalReactiveCommands<K, V>,
-        RedisGeoReactiveCommands<K, V>, RedisClusterReactiveCommands<K, V>, RedisJsonReactiveCommands<K, V> {
+public abstract class AbstractRedisReactiveCommands<K, V> implements RedisAclReactiveCommands<K, V>,
+        RedisHashReactiveCommands<K, V>, RedisKeyReactiveCommands<K, V>, RedisStringReactiveCommands<K, V>,
+        RedisListReactiveCommands<K, V>, RedisSetReactiveCommands<K, V>, RedisSortedSetReactiveCommands<K, V>,
+        RedisScriptingReactiveCommands<K, V>, RedisServerReactiveCommands<K, V>, RedisHLLReactiveCommands<K, V>,
+        BaseRedisReactiveCommands<K, V>, RedisTransactionalReactiveCommands<K, V>, RedisGeoReactiveCommands<K, V>,
+        RedisClusterReactiveCommands<K, V>, RedisJsonReactiveCommands<K, V>, RedisVectorSetReactiveCommands<K, V> {
 
     private final StatefulConnection<K, V> connection;
 
     private final RedisCommandBuilder<K, V> commandBuilder;
 
     private final RedisJsonCommandBuilder<K, V> jsonCommandBuilder;
 
+    private final RedisVectorSetCommandBuilder<K, V> vectorSetCommandBuilder;
+
     private final Supplier<JsonParser> parser;
 
     private final ClientResources clientResources;
@@ -118,6 +122,7 @@ public AbstractRedisReactiveCommands(StatefulConnection<K, V> connection, RedisC
         this.parser = parser;
         this.commandBuilder = new RedisCommandBuilder<>(codec);
         this.jsonCommandBuilder = new RedisJsonCommandBuilder<>(codec, parser);
+        this.vectorSetCommandBuilder = new RedisVectorSetCommandBuilder<>(codec, parser);
         this.clientResources = connection.getResources();
         this.tracingEnabled = clientResources.tracing().isEnabled();
     }
@@ -1752,6 +1757,141 @@ public Flux<JsonType> jsonType(K key) {
         return createDissolvingFlux(() -> jsonCommandBuilder.jsonType(key, JsonPath.ROOT_PATH));
     }
 
+    @Override
+    public Mono<Boolean> vadd(K key, V element, Double... vectors) {
+        return createMono(() -> vectorSetCommandBuilder.vadd(key, element, null, vectors));
+    }
+
+    @Override
+    public Mono<Boolean> vadd(K key, int dimensionality, V element, Double... vectors) {
+        return createMono(() -> vectorSetCommandBuilder.vadd(key, dimensionality, element, null, vectors));
+    }
+
+    @Override
+    public Mono<Boolean> vadd(K key, V element, VAddArgs args, Double... vectors) {
+        return createMono(() -> vectorSetCommandBuilder.vadd(key, element, args, vectors));
+    }
+
+    @Override
+    public Mono<Boolean> vadd(K key, int dimensionality, V element, VAddArgs args, Double... vectors) {
+        return createMono(() -> vectorSetCommandBuilder.vadd(key, dimensionality, element, args, vectors));
+    }
+
+    @Override
+    public Mono<Long> vcard(K key) {
+        return createMono(() -> vectorSetCommandBuilder.vcard(key));
+    }
+
+    @Override
+    public Mono<Boolean> vClearAttributes(K key, V element) {
+        return createMono(() -> vectorSetCommandBuilder.vsetattr(key, element, ""));
+    }
+
+    @Override
+    public Mono<Long> vdim(K key) {
+        return createMono(() -> vectorSetCommandBuilder.vdim(key));
+    }
+
+    @Override
+    public Flux<Double> vemb(K key, V element) {
+        return createDissolvingFlux(() -> vectorSetCommandBuilder.vemb(key, element));
+    }
+
+    @Override
+    public Mono<RawVector> vembRaw(K key, V element) {
+        return createMono(() -> vectorSetCommandBuilder.vembRaw(key, element));
+    }
+
+    @Override
+    public Mono<String> vgetattr(K key, V element) {
+        return createMono(() -> vectorSetCommandBuilder.vgetattr(key, element));
+    }
+
+    @Override
+    public Flux<JsonValue> vgetattrAsJsonValue(K key, V element) {
+        return createDissolvingFlux(() -> vectorSetCommandBuilder.vgetattrAsJsonValue(key, element));
+    }
+
+    @Override
+    public Mono<VectorMetadata> vinfo(K key) {
+        return createMono(() -> vectorSetCommandBuilder.vinfo(key));
+    }
+
+    @Override
+    public Flux<V> vlinks(K key, V element) {
+        return createDissolvingFlux(() -> vectorSetCommandBuilder.vlinks(key, element));
+    }
+
+    @Override
+    public Mono<Map<V, Double>> vlinksWithScores(K key, V element) {
+        return createMono(() -> vectorSetCommandBuilder.vlinksWithScores(key, element));
+    }
+
+    @Override
+    public Mono<V> vrandmember(K key) {
+        return createMono(() -> vectorSetCommandBuilder.vrandmember(key));
+    }
+
+    @Override
+    public Flux<V> vrandmember(K key, int count) {
+        return createDissolvingFlux(() -> vectorSetCommandBuilder.vrandmember(key, count));
+    }
+
+    @Override
+    public Mono<Boolean> vrem(K key, V element) {
+        return createMono(() -> vectorSetCommandBuilder.vrem(key, element));
+    }
+
+    @Override
+    public Mono<Boolean> vsetattr(K key, V element, String json) {
+        return createMono(() -> vectorSetCommandBuilder.vsetattr(key, element, json));
+    }
+
+    @Override
+    public Mono<Boolean> vsetattr(K key, V element, JsonValue json) {
+        return createMono(() -> vectorSetCommandBuilder.vsetattr(key, element, json));
+    }
+
+    @Override
+    public Flux<V> vsim(K key, Double... vectors) {
+        return createDissolvingFlux(() -> vectorSetCommandBuilder.vsim(key, null, vectors));
+    }
+
+    @Override
+    public Flux<V> vsim(K key, V element) {
+        return createDissolvingFlux(() -> vectorSetCommandBuilder.vsim(key, null, element));
+    }
+
+    @Override
+    public Flux<V> vsim(K key, VSimArgs args, Double... vectors) {
+        return createDissolvingFlux(() -> vectorSetCommandBuilder.vsim(key, args, vectors));
+    }
+
+    @Override
+    public Flux<V> vsim(K key, VSimArgs args, V element) {
+        return createDissolvingFlux(() -> vectorSetCommandBuilder.vsim(key, args, element));
+    }
+
+    @Override
+    public Mono<Map<V, Double>> vsimWithScore(K key, Double... vectors) {
+        return createMono(() -> vectorSetCommandBuilder.vsimWithScore(key, null, vectors));
+    }
+
+    @Override
+    public Mono<Map<V, Double>> vsimWithScore(K key, V element) {
+        return createMono(() -> vectorSetCommandBuilder.vsimWithScore(key, null, element));
+    }
+
+    @Override
+    public Mono<Map<V, Double>> vsimWithScore(K key, VSimArgs args, Double... vectors) {
+        return createMono(() -> vectorSetCommandBuilder.vsimWithScore(key, args, vectors));
+    }
+
+    @Override
+    public Mono<Map<V, Double>> vsimWithScore(K key, VSimArgs args, V element) {
+        return createMono(() -> vectorSetCommandBuilder.vsimWithScore(key, args, element));
+    }
+
     @Override
     public Flux<K> keys(K pattern) {
         return createDissolvingFlux(() -> commandBuilder.keys(pattern));