Support Redis 8 vector sets #4169

src/main/java/redis/clients/jedis/BuilderFactory.java

@@ -190,7 +190,6 @@ public String toString() {
 
   public static final Builder<Set<byte[]>> BINARY_SET = new Builder<Set<byte[]>>() {
     @Override
-    @SuppressWarnings("unchecked")
     public Set<byte[]> build(Object data) {
       if (null == data) {
         return null;
@@ -477,6 +476,66 @@ public String toString() {
     }
   };
 
+  public static final Builder<Map<String, Double>> STRING_DOUBLE_MAP = new Builder<Map<String, Double>>() {
+    @Override
+    @SuppressWarnings("unchecked")
+    public Map<String, Double> build(Object data) {
+      final List<Object> list = (List<Object>) data;
+      if (list.isEmpty()) return Collections.emptyMap();
+
+      if (list.get(0) instanceof KeyValue) {
+        final Map<String, Double> map = new LinkedHashMap<>(list.size(), 1f);
+        for (Object o : list) {
+          KeyValue<?, ?> kv = (KeyValue<?, ?>) o;
+          map.put(STRING.build(kv.getKey()), DOUBLE.build(kv.getValue()));
+        }
+        return map;
+      } else {
+        final Map<String, Double> map = new LinkedHashMap<>(list.size() / 2, 1f);
+        final Iterator iterator = list.iterator();
+        while (iterator.hasNext()) {
+          map.put(STRING.build(iterator.next()), DOUBLE.build(iterator.next()));
+        }
+        return map;
+      }
+    }
+
+    @Override
+    public String toString() {
+      return "Map<String, Double>";
+    }
+  };
+
+
+  public static final Builder<Map<byte[], Double>> BINARY_DOUBLE_MAP = new Builder<Map<byte[], Double>>() {
+    @Override
+    @SuppressWarnings("unchecked")
+    public Map<byte[], Double> build(Object data) {
+      final List<Object> list = (List<Object>) data;
+      if (list.isEmpty()) return Collections.emptyMap();
+
+      if (list.get(0) instanceof KeyValue) {
+        final Map<byte[], Double> map = new LinkedHashMap<>(list.size(), 1f);
+        for (Object o : list) {
+          KeyValue<?, ?> kv = (KeyValue<?, ?>) o;
+          map.put(BINARY.build(kv.getKey()), DOUBLE.build(kv.getValue()));
+        }
+        return map;
+      } else {
+        final Map<byte[], Double> map = new LinkedHashMap<>(list.size() / 2, 1f);
+        final Iterator iterator = list.iterator();
+        while (iterator.hasNext()) {
+          map.put(BINARY.build(iterator.next()), DOUBLE.build(iterator.next()));
+        }
+        return map;
+      }
+    }
+
+    @Override
+    public String toString() {
+      return "Map<String, Double>";
+    }
+  };
   public static final Builder<KeyValue<String, String>> KEYED_ELEMENT = new Builder<KeyValue<String, String>>() {
     @Override
     @SuppressWarnings("unchecked")
@@ -1781,6 +1840,43 @@ public String toString() {
   @Deprecated
   public static final Builder<StreamFullInfo> STREAM_INFO_FULL = STREAM_FULL_INFO;
 
+  public static final Builder<VectorInfo> VECTOR_INFO = new Builder<VectorInfo>() {
+
+    final Map<String, Builder> mappingFunctions = createDecoderMap();
+
+    private Map<String, Builder> createDecoderMap() {
+      Map<String, Builder> tempMappingFunctions = new HashMap<>();
+      tempMappingFunctions.put(VectorInfo.VECTOR_DIM, LONG);
+      tempMappingFunctions.put(VectorInfo.TYPE, STRING);
+      tempMappingFunctions.put(VectorInfo.SIZE, LONG);
+      tempMappingFunctions.put(VectorInfo.MAX_NODE_UID, LONG);
+      tempMappingFunctions.put(VectorInfo.VSET_UID, LONG);
+      tempMappingFunctions.put(VectorInfo.MAX_NODES, LONG);
+      tempMappingFunctions.put(VectorInfo.PROJECTION_INPUT_DIM, LONG);
+      tempMappingFunctions.put(VectorInfo.ATTRIBUTES_COUNT, LONG);
+      tempMappingFunctions.put(VectorInfo.MAX_LEVEL, LONG);
+      return tempMappingFunctions;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public VectorInfo build(Object data) {
+      if (null == data) {
+        return null;
+      }
+
+      List<Object> vectorEntries = (List<Object>) data;
+      Iterator<Object> iterator = vectorEntries.iterator();
+
+      return new VectorInfo(createMapFromDecodingFunctions(iterator, mappingFunctions));
+    }
+
+    @Override
+    public String toString() {
+      return "VectorInfo";
+    }
+  };
+
   public static final Builder<StreamPendingSummary> STREAM_PENDING_SUMMARY = new Builder<StreamPendingSummary>() {
     @Override
     @SuppressWarnings("unchecked")
@@ -2116,6 +2212,107 @@ public String toString() {
     }
   };
 
+  // Vector Set builders
+
+  // VEMB builders
+  public static final Builder<List<Double>> VEMB_RESULT = new Builder<List<Double>>() {
+    @Override
+    @SuppressWarnings("unchecked")
+    public List<Double> build(Object data) {
+      if (data == null) return null;
+      List<Object> list = (List<Object>) data;
+      return list.stream().map(DOUBLE::build).collect(Collectors.toList());
+    }
+
+    @Override
+    public String toString() {
+      return "List<Double>";
+    }
+  };
+
+  public static final Builder<RawVector> VEMB_RAW_RESULT = new Builder<RawVector>() {
+    @Override
+    @SuppressWarnings("unchecked")
+    public RawVector build(Object data) {
+      if (data == null) return null;
+      List<Object> list = (List<Object>) data;
+
+      String quantizationType = STRING.build(list.get(0));
+      byte[] rawData = (byte[]) list.get(1);
+      Double norm = DOUBLE.build(list.get(2));
+      Double quantizationRange = list.size() > 3 ? DOUBLE.build(list.get(3)) : null;
+
+      return new RawVector(quantizationType, rawData, norm, quantizationRange);
+    }
+
+    @Override
+    public String toString() {
+      return "RawVector";
+    }
+  };
+
+  // VLINKS builders
+  public static final Builder<List<Map<String, Double>>> VLINKS_WITH_SCORES_RESULT = new Builder<List<Map<String, Double>>>() {
+    @Override
+    @SuppressWarnings("unchecked")
+    public List<Map<String, Double>> build(Object data) {
+      if (data == null) return null;
+      List<Object> list = (List<Object>) data;
+
+      List<Map<String, Double>> result = new ArrayList<>();
+      for (Object scoresRaw : list) {
+        if (scoresRaw == null) continue;
+        Map<String, Double> scores  = STRING_DOUBLE_MAP.build(scoresRaw);
+        result.add(scores);
+      }
+
+      return result;
+    }
+
+    @Override
+    public String toString() {
+      return "List<Map<String, Double>>";
+    }
+  };
+
+  public static final Builder<List<List<byte[]>>> BINARY_LIST_LIST = new Builder<List<List<byte[]>>>() {
+    @Override
+    @SuppressWarnings("unchecked")
+    public List<List<byte[]>> build(Object data) {
+      if (null == data) return null;
+      return ((List<Object>) data).stream().map(BINARY_LIST::build).collect(Collectors.toList());
+    }
+
+    @Override
+    public String toString() {
+      return "List<List<String>>";
+    }
+  };
+
+
+  public static final Builder<List<Map<byte[], Double>>> VLINKS_WITH_SCORES_RESULT_BINARY = new Builder<List<Map<byte[], Double>>>() {
+    @Override
+    @SuppressWarnings("unchecked")
+    public List<Map<byte[], Double>> build(Object data) {
+      if (data == null) return null;
+      List<Object> list = (List<Object>) data;
+
+      List<Map<byte[], Double>> result = new ArrayList<>();
+      for (Object scoresRaw : list) {
+        if (scoresRaw == null) continue;
+        Map<byte[], Double> scores  = BINARY_DOUBLE_MAP.build(scoresRaw);
+        result.add(scores);
+      }
+
+      return result;
+    }
+
+    @Override
+    public String toString() {
+      return "List<Map<byte[], Double>>";
+    }
+  };
+
   /**
    * A decorator to implement Set from List. Assume that given List do not contains duplicated
    * values. The resulting set displays the same ordering, concurrency, and performance