Merge branch '4.x' into feature-backport-cluster-topology-refresh-4.x

.github/release-drafter-config.yml

@@ -1,5 +1,7 @@
 name-template: '$NEXT_MINOR_VERSION'
 tag-template: 'v$NEXT_MINOR_VERSION'
+filter-by-commitish: true
+commitish: 4.x
 autolabeler:
   - label: 'maintenance'
     files:
@@ -35,6 +37,8 @@ categories:
     labels:
       - 'maintenance'
       - 'dependencies'
+      - 'documentation'
+      - 'docs'
       - 'testing'
 change-template: '- $TITLE (#$NUMBER)'
 exclude-labels:
@@ -48,4 +52,3 @@ template: |
   We'd like to thank all the contributors who worked on this release!
 
   $CONTRIBUTORS
-

.github/workflows/version-and-release.yml

@@ -32,14 +32,14 @@ jobs:
 
       - name: Install gpg key
         run: |
-          cat <(echo -e "${{ secrets.OSSRH_GPG_SECRET_KEY }}") | gpg --batch --import
+          cat <(echo -e "${{ secrets.OSSH_GPG_SECRET_KEY }}") | gpg --batch --import
           gpg --list-secret-keys --keyid-format LONG
 
       - name: Publish
         run: |
           mvn --no-transfer-progress \
             --batch-mode \
-            -Dgpg.passphrase='${{ secrets.OSSRH_GPG_SECRET_KEY_PASSWORD }}' \
+            -Dgpg.passphrase='${{ secrets.OSSH_GPG_SECRET_KEY_PASSWORD }}' \
             -DskipTests deploy -P release
         env:
           MAVEN_USERNAME: ${{secrets.OSSH_USERNAME}}

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

@@ -3,10 +3,12 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
+
 import redis.clients.jedis.args.Rawable;
 import redis.clients.jedis.args.RawableFactory;
 import redis.clients.jedis.commands.ProtocolCommand;
 import redis.clients.jedis.params.IParams;
+import redis.clients.jedis.search.RediSearchUtil;
 
 public class CommandArguments implements Iterable<Rawable> {
 
@@ -34,10 +36,19 @@ public CommandArguments add(Object arg) {
       args.add((Rawable) arg);
     } else if (arg instanceof byte[]) {
       args.add(RawableFactory.from((byte[]) arg));
+    } else if (arg instanceof Integer) {
+      args.add(RawableFactory.from((Integer) arg));
+    } else if (arg instanceof Double) {
+      args.add(RawableFactory.from((Double) arg));
+    } else if (arg instanceof Boolean) {
+      args.add(RawableFactory.from((Boolean) arg ? 1 : 0));
+    } else if (arg instanceof float[]) {
+      args.add(RawableFactory.from(RediSearchUtil.toByteArray((float[]) arg)));
     } else if (arg instanceof String) {
       args.add(RawableFactory.from((String) arg));
-    } else if (arg instanceof Boolean) {
-      args.add(RawableFactory.from(Integer.toString((Boolean) arg ? 1 : 0)));
+    } else if (arg instanceof GeoCoordinate) {
+      GeoCoordinate geo = (GeoCoordinate) arg;
+      args.add(RawableFactory.from(geo.getLongitude() + "," + geo.getLatitude()));
     } else {
       args.add(RawableFactory.from(String.valueOf(arg)));
     }

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

@@ -3154,6 +3154,14 @@ public final CommandObject<Long> publish(byte[] channel, byte[] message) {
   // Miscellaneous commands
 
   // RediSearch commands
+  public final CommandObject<Long> hsetObject(String key, String field, Object value) {
+    return new CommandObject<>(commandArguments(HSET).key(key).add(field).add(value), BuilderFactory.LONG);
+  }
+
+  public final CommandObject<Long> hsetObject(String key, Map<String, Object> hash) {
+    return new CommandObject<>(addFlatMapArgs(commandArguments(HSET).key(key), hash), BuilderFactory.LONG);
+  }
+
   private boolean isRoundRobinSearchCommand() {
     if (broadcastAndRoundRobinConfig == null) {
       return true;
@@ -3163,8 +3171,24 @@ private boolean isRoundRobinSearchCommand() {
     return true;
   }
 
-  private CommandArguments checkAndRoundRobinSearchCommand(CommandArguments commandArguments, String indexName) {
-    return isRoundRobinSearchCommand() ? commandArguments.add(indexName) : commandArguments.key(indexName);
+  private CommandArguments checkAndRoundRobinSearchCommand(SearchCommand sc, String idx) {
+    CommandArguments ca = commandArguments(sc);
+    if (isRoundRobinSearchCommand()) {
+      ca.add(idx);
+    } else {
+      ca.key(idx);
+    }
+    return ca;
+  }
+
+  private CommandArguments checkAndRoundRobinSearchCommand(SearchCommand sc, String idx1, String idx2) {
+    CommandArguments ca = commandArguments(sc);
+    if (isRoundRobinSearchCommand()) {
+      ca.add(idx1).add(idx2);
+    } else {
+      ca.key(idx1).key(idx2);
+    }
+    return ca;
   }
 
   private CommandArguments checkAndRoundRobinSearchCommand(CommandArguments commandArguments, byte[] indexName) {
@@ -3177,46 +3201,46 @@ private <T> CommandObject<T> directSearchCommand(CommandObject<T> object, String
   }
 
   public final CommandObject<String> ftCreate(String indexName, IndexOptions indexOptions, Schema schema) {
-    CommandArguments args = commandArguments(SearchCommand.CREATE).add(indexName)
+    CommandArguments args = checkAndRoundRobinSearchCommand(SearchCommand.CREATE, indexName)
         .addParams(indexOptions).add(SearchKeyword.SCHEMA);
     schema.fields.forEach(field -> args.addParams(field));
     return new CommandObject<>(args, BuilderFactory.STRING);
   }
 
   public final CommandObject<String> ftCreate(String indexName, FTCreateParams createParams,
       Iterable<SchemaField> schemaFields) {
-    CommandArguments args = commandArguments(SearchCommand.CREATE).add(indexName)
+    CommandArguments args = checkAndRoundRobinSearchCommand(SearchCommand.CREATE, indexName)
         .addParams(createParams).add(SearchKeyword.SCHEMA);
     schemaFields.forEach(field -> args.addParams(field));
     return new CommandObject<>(args, BuilderFactory.STRING);
   }
 
   public final CommandObject<String> ftAlter(String indexName, Schema schema) {
-    CommandArguments args = commandArguments(SearchCommand.ALTER).add(indexName)
+    CommandArguments args = checkAndRoundRobinSearchCommand(SearchCommand.ALTER, indexName)
         .add(SearchKeyword.SCHEMA).add(SearchKeyword.ADD);
     schema.fields.forEach(field -> args.addParams(field));
     return new CommandObject<>(args, BuilderFactory.STRING);
   }
 
   public final CommandObject<String> ftAlter(String indexName, Iterable<SchemaField> schemaFields) {
-    CommandArguments args = commandArguments(SearchCommand.ALTER).add(indexName)
+    CommandArguments args = checkAndRoundRobinSearchCommand(SearchCommand.ALTER, indexName)
         .add(SearchKeyword.SCHEMA).add(SearchKeyword.ADD);
     schemaFields.forEach(field -> args.addParams(field));
     return new CommandObject<>(args, BuilderFactory.STRING);
   }
 
   public final CommandObject<SearchResult> ftSearch(String indexName, String query) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.SEARCH), indexName).add(query),
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.SEARCH, indexName).add(query),
         new SearchResultBuilder(true, false, false, true));
   }
 
   public final CommandObject<SearchResult> ftSearch(String indexName, String query, FTSearchParams params) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.SEARCH), indexName)
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.SEARCH, indexName)
         .add(query).addParams(params), new SearchResultBuilder(!params.getNoContent(), params.getWithScores(), false, true));
   }
 
   public final CommandObject<SearchResult> ftSearch(String indexName, Query query) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.SEARCH), indexName).addParams(query),
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.SEARCH, indexName).addParams(query),
         new SearchResultBuilder(!query.getNoContent(), query.getWithScores(), query.getWithPayloads(), true));
   }
 
@@ -3226,35 +3250,35 @@ public final CommandObject<SearchResult> ftSearch(byte[] indexName, Query query)
   }
 
   public final CommandObject<String> ftExplain(String indexName, Query query) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.EXPLAIN), indexName)
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.EXPLAIN, indexName)
         .addParams(query), BuilderFactory.STRING);
   }
 
   public final CommandObject<List<String>> ftExplainCLI(String indexName, Query query) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.EXPLAINCLI), indexName)
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.EXPLAINCLI, indexName)
         .addParams(query), BuilderFactory.STRING_LIST);
   }
 
   public final CommandObject<AggregationResult> ftAggregate(String indexName, AggregationBuilder aggr) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.AGGREGATE), indexName)
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.AGGREGATE, indexName)
         .addObjects(aggr.getArgs()), !aggr.isWithCursor() ? SearchBuilderFactory.SEARCH_AGGREGATION_RESULT
         : SearchBuilderFactory.SEARCH_AGGREGATION_RESULT_WITH_CURSOR);
   }
 
   public final CommandObject<AggregationResult> ftCursorRead(String indexName, long cursorId, int count) {
     return new CommandObject<>(commandArguments(SearchCommand.CURSOR).add(SearchKeyword.READ)
-        .add(indexName).add(cursorId).add(SearchKeyword.COUNT).add(count),
+        .key(indexName).add(cursorId).add(SearchKeyword.COUNT).add(count),
         SearchBuilderFactory.SEARCH_AGGREGATION_RESULT_WITH_CURSOR);
   }
 
   public final CommandObject<String> ftCursorDel(String indexName, long cursorId) {
     return new CommandObject<>(commandArguments(SearchCommand.CURSOR).add(SearchKeyword.DEL)
-        .add(indexName).add(cursorId), BuilderFactory.STRING);
+        .key(indexName).add(cursorId), BuilderFactory.STRING);
   }
 
   public final CommandObject<Map.Entry<AggregationResult, Map<String, Object>>> ftProfileAggregate(
       String indexName, FTProfileParams profileParams, AggregationBuilder aggr) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.PROFILE), indexName)
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.PROFILE, indexName)
         .add(SearchKeyword.AGGREGATE).addParams(profileParams).add(SearchKeyword.QUERY)
         .addObjects(aggr.getArgs()), new SearchProfileResponseBuilder<>(!aggr.isWithCursor()
             ? SearchBuilderFactory.SEARCH_AGGREGATION_RESULT
@@ -3263,36 +3287,36 @@ public final CommandObject<Map.Entry<AggregationResult, Map<String, Object>>> ft
 
   public final CommandObject<Map.Entry<SearchResult, Map<String, Object>>> ftProfileSearch(
       String indexName, FTProfileParams profileParams, Query query) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.PROFILE), indexName)
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.PROFILE, indexName)
         .add(SearchKeyword.SEARCH).addParams(profileParams).add(SearchKeyword.QUERY)
         .addParams(query), new SearchProfileResponseBuilder<>(new SearchResultBuilder(
             !query.getNoContent(), query.getWithScores(), query.getWithPayloads(), true)));
   }
 
   public final CommandObject<Map.Entry<SearchResult, Map<String, Object>>> ftProfileSearch(
       String indexName, FTProfileParams profileParams, String query, FTSearchParams searchParams) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.PROFILE), indexName)
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.PROFILE, indexName)
         .add(SearchKeyword.SEARCH).addParams(profileParams).add(SearchKeyword.QUERY).add(query)
         .addParams(searchParams), new SearchProfileResponseBuilder<>(new SearchResultBuilder(
             !searchParams.getNoContent(), searchParams.getWithScores(), false, true)));
   }
 
   public final CommandObject<String> ftDropIndex(String indexName) {
-    return new CommandObject<>(commandArguments(SearchCommand.DROPINDEX).add(indexName), BuilderFactory.STRING);
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.DROPINDEX, indexName), BuilderFactory.STRING);
   }
 
   public final CommandObject<String> ftDropIndexDD(String indexName) {
-    return new CommandObject<>(commandArguments(SearchCommand.DROPINDEX).add(indexName).add(SearchKeyword.DD),
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.DROPINDEX, indexName).add(SearchKeyword.DD),
         BuilderFactory.STRING);
   }
 
   public final CommandObject<String> ftSynUpdate(String indexName, String synonymGroupId, String... terms) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.SYNUPDATE), indexName)
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.SYNUPDATE, indexName)
         .add(synonymGroupId).addObjects((Object[]) terms), BuilderFactory.STRING);
   }
 
   public final CommandObject<Map<String, List<String>>> ftSynDump(String indexName) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.SYNDUMP), indexName),
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.SYNDUMP, indexName),
         SearchBuilderFactory.SEARCH_SYNONYM_GROUPS);
   }
 
@@ -3323,36 +3347,36 @@ public final CommandObject<Set<String>> ftDictDumpBySampleKey(String indexName,
   }
 
   public final CommandObject<Map<String, Map<String, Double>>> ftSpellCheck(String index, String query) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.SPELLCHECK), index).add(query),
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.SPELLCHECK, index).add(query),
         SearchBuilderFactory.SEARCH_SPELLCHECK_RESPONSE);
   }
 
   public final CommandObject<Map<String, Map<String, Double>>> ftSpellCheck(String index, String query,
       FTSpellCheckParams spellCheckParams) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.SPELLCHECK), index).add(query)
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.SPELLCHECK, index).add(query)
         .addParams(spellCheckParams), SearchBuilderFactory.SEARCH_SPELLCHECK_RESPONSE);
   }
 
   public final CommandObject<Map<String, Object>> ftInfo(String indexName) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.INFO), indexName),
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.INFO, indexName),
         BuilderFactory.ENCODED_OBJECT_MAP);
   }
 
   public final CommandObject<Set<String>> ftTagVals(String indexName, String fieldName) {
-    return new CommandObject<>(checkAndRoundRobinSearchCommand(commandArguments(SearchCommand.TAGVALS), indexName)
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.TAGVALS, indexName)
         .add(fieldName), BuilderFactory.STRING_SET);
   }
 
   public final CommandObject<String> ftAliasAdd(String aliasName, String indexName) {
-    return new CommandObject<>(commandArguments(SearchCommand.ALIASADD).add(aliasName).add(indexName), BuilderFactory.STRING);
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.ALIASADD, aliasName, indexName), BuilderFactory.STRING);
   }
 
   public final CommandObject<String> ftAliasUpdate(String aliasName, String indexName) {
-    return new CommandObject<>(commandArguments(SearchCommand.ALIASUPDATE).add(aliasName).add(indexName), BuilderFactory.STRING);
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.ALIASUPDATE, aliasName, indexName), BuilderFactory.STRING);
   }
 
    public final CommandObject<String> ftAliasDel(String aliasName) {
-    return new CommandObject<>(commandArguments(SearchCommand.ALIASDEL).add(aliasName), BuilderFactory.STRING);
+    return new CommandObject<>(checkAndRoundRobinSearchCommand(SearchCommand.ALIASDEL, aliasName), BuilderFactory.STRING);
   }
 
   public final CommandObject<Map<String, String>> ftConfigGet(String option) {

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

@@ -86,16 +86,16 @@ protected final <T> Response<T> appendCommand(CommandObject<T> commandObject) {
       queue = pipelinedResponses.get(nodeKey);
       connection = connections.get(nodeKey);
     } else {
-      pipelinedResponses.putIfAbsent(nodeKey, new LinkedList<>());
-      queue = pipelinedResponses.get(nodeKey);
-
       Connection newOne = getConnection(nodeKey);
       connections.putIfAbsent(nodeKey, newOne);
       connection = connections.get(nodeKey);
       if (connection != newOne) {
         log.debug("Duplicate connection to {}, closing it.", nodeKey);
         IOUtils.closeQuietly(newOne);
       }
+
+      pipelinedResponses.putIfAbsent(nodeKey, new LinkedList<>());
+      queue = pipelinedResponses.get(nodeKey);
     }
 
     connection.sendCommand(commandObject.getArguments());

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

@@ -3568,6 +3568,14 @@ public LCSMatchResult strAlgoLCSStrings(byte[] strA, byte[] strB, StrAlgoLCSPara
   // Random node commands
 
   // RediSearch commands
+  public long hsetObject(String key, String field, Object value) {
+    return executeCommand(commandObjects.hsetObject(key, field, value));
+  }
+
+  public long hsetObject(String key, Map<String, Object> hash) {
+    return executeCommand(commandObjects.hsetObject(key, hash));
+  }
+
   @Override
   public String ftCreate(String indexName, IndexOptions indexOptions, Schema schema) {
     return checkAndBroadcastCommand(commandObjects.ftCreate(indexName, indexOptions, schema));

src/main/java/redis/clients/jedis/search/RediSearchUtil.java

@@ -63,12 +63,20 @@ public static Map<String, String> toStringMap(Map<String, Object> input, boolean
    * @param input float array
    * @return byte array
    */
-  public static byte[] ToByteArray(float[] input) {
+  public static byte[] toByteArray(float[] input) {
     byte[] bytes = new byte[Float.BYTES * input.length];
     ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN).asFloatBuffer().put(input);
     return bytes;
   }
 
+  /**
+   * @deprecated Use {@link RediSearchUtil#toByteArray(float[])}.
+   */
+  @Deprecated
+  public static byte[] ToByteArray(float[] input) {
+    return toByteArray(input);
+  }
+
   private static final Set<Character> ESCAPE_CHARS = new HashSet<>(Arrays.asList(//
       ',', '.', '<', '>', '{', '}', '[', //
       ']', '"', '\'', ':', ';', '!', '@', //