Introduce HSETEX command to the Spring Data Redis framework

Signed-off-by: viktoriya.kutsarova <viktoriya.kutsarova@redis.com>

Author: viktoriya-kutsarova

src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java

@@ -24,6 +24,7 @@
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.jetbrains.annotations.NotNull;
+import org.jspecify.annotations.NonNull;
 import org.jspecify.annotations.NullUnmarked;
 import org.jspecify.annotations.Nullable;
 import org.springframework.core.convert.converter.Converter;
@@ -1620,6 +1621,11 @@ public List<String> hGetEx(String key, Expiration expiration, String... fields)
  return convertAndReturn(delegate.hGetEx(serialize(key), expiration, serializeMulti(fields)), byteListToStringList);
  }
 
+ @Override
+ public Boolean hSetEx(@NonNull String key, @NonNull Map<@NonNull String, String> hashes, HashFieldSetOption condition, Expiration expiration) {
+ return convertAndReturn(delegate.hSetEx(serialize(key), serialize(hashes), condition, expiration), Converters.identityConverter());
+ }
+
 @Override
 public Long incr(String key) {
 return incr(serialize(key));
@@ -2603,6 +2609,11 @@ public List<byte[]> hGetEx(@NotNull byte[] key, Expiration expiration, @NotNull
  return convertAndReturn(delegate.hGetEx(key, expiration, fields), Converters.identityConverter());
  }
 
+ @Override
+ public Boolean hSetEx(@NotNull byte[] key, @NonNull Map<byte[], byte[]> hashes, HashFieldSetOption condition, Expiration expiration) {
+ return convertAndReturn(delegate.hSetEx(key, hashes, condition, expiration), Converters.identityConverter());
+ }
+
 public @Nullable List<Long> applyExpiration(String key,
 org.springframework.data.redis.core.types.Expiration expiration,
 ExpirationOptions options, String... fields) {

src/main/java/org/springframework/data/redis/connection/DefaultedRedisConnection.java

@@ -1608,6 +1608,13 @@ default List<byte[]> hGetEx(byte[] key, Expiration expiration, byte[]... fields)
  return hashCommands().hGetEx(key, expiration, fields);
  }
 
+ /** @deprecated in favor of {@link RedisConnection#hashCommands()}}. */
+ @Override
+ @Deprecated
+ default Boolean hSetEx(byte[] key, Map<byte[], byte[]> hashes, HashFieldSetOption condition, Expiration expiration) {
+ return hashCommands().hSetEx(key, hashes, condition, expiration);
+ }
+
 /** @deprecated in favor of {@link RedisConnection#hashCommands()}}. */
 @Override
 @Deprecated

src/main/java/org/springframework/data/redis/connection/ReactiveHashCommands.java

@@ -1410,4 +1410,101 @@ default Mono<List<ByteBuffer>> hGetEx(ByteBuffer key, Expiration expiration, Lis
  * @see <a href="https://redis.io/commands/hgetex">Redis Documentation: HGETEX</a>
  */
  Flux<MultiValueResponse<HGetExCommand, ByteBuffer>> hGetEx(Publisher<HGetExCommand> commands);
+
+ /**
+ * {@literal HSETEX} {@link Command}.
+ *
+ * @author Viktoriya Kutsarova
+ * @see <a href="https://redis.io/commands/hsetex">Redis Documentation: HSETEX</a>
+ */
+ class HSetExCommand extends KeyCommand {
+
+ private final Map<ByteBuffer, ByteBuffer> fieldValueMap;
+ private final RedisHashCommands.HashFieldSetOption condition;
+ private final Expiration expiration;
+
+ private HSetExCommand(@Nullable ByteBuffer key, Map<ByteBuffer, ByteBuffer> fieldValueMap,
+ RedisHashCommands.HashFieldSetOption condition, Expiration expiration) {
+ super(key);
+ this.fieldValueMap = fieldValueMap;
+ this.condition = condition;
+ this.expiration = expiration;
+ }
+
+ /**
+ * Creates a new {@link HSetExCommand} for setting field-value pairs with condition and expiration.
+ *
+ * @param fieldValueMap the field-value pairs to set; must not be {@literal null}.
+ * @param condition the condition for setting fields; must not be {@literal null}.
+ * @param expiration the expiration to apply; must not be {@literal null}.
+ * @return new instance of {@link HSetExCommand}.
+ */
+ public static HSetExCommand setWithConditionAndExpiration(Map<ByteBuffer, ByteBuffer> fieldValueMap,
+ RedisHashCommands.HashFieldSetOption condition, Expiration expiration) {
+ return new HSetExCommand(null, fieldValueMap, condition, expiration);
+ }
+
+ /**
+ * Applies the hash {@literal key}. Constructs a new command instance with all previously configured properties.
+ *
+ * @param key must not be {@literal null}.
+ * @return a new {@link HSetExCommand} with {@literal key} applied.
+ */
+ public HSetExCommand from(ByteBuffer key) {
+ Assert.notNull(key, "Key must not be null");
+ return new HSetExCommand(key, fieldValueMap, condition, expiration);
+ }
+
+ /**
+ * @return the field-value map.
+ */
+ public Map<ByteBuffer, ByteBuffer> getFieldValueMap() {
+ return fieldValueMap;
+ }
+
+ /**
+ * @return the condition for setting fields.
+ */
+ public RedisHashCommands.HashFieldSetOption getCondition() {
+ return condition;
+ }
+
+ /**
+ * @return the expiration to apply.
+ */
+ public Expiration getExpiration() {
+ return expiration;
+ }
+ }
+
+ /**
+ * Set field-value pairs in hash at {@literal key} with condition and expiration.
+ *
+ * @param key must not be {@literal null}.
+ * @param fieldValueMap the field-value pairs to set; must not be {@literal null}.
+ * @param condition the condition for setting fields; must not be {@literal null}.
+ * @param expiration the expiration to apply; must not be {@literal null}.
+ * @return never {@literal null}.
+ * @see <a href="https://redis.io/commands/hsetex">Redis Documentation: HSETEX</a>
+ */
+ default Mono<Boolean> hSetEx(ByteBuffer key, Map<ByteBuffer, ByteBuffer> fieldValueMap,
+ RedisHashCommands.HashFieldSetOption condition, Expiration expiration) {
+
+ Assert.notNull(key, "Key must not be null");
+ Assert.notNull(fieldValueMap, "Field-value map must not be null");
+ Assert.notNull(condition, "Condition must not be null");
+ Assert.notNull(expiration, "Expiration must not be null");
+
+ return hSetEx(Mono.just(HSetExCommand.setWithConditionAndExpiration(fieldValueMap, condition, expiration).from(key)))
+ .next().map(CommandResponse::getOutput);
+ }
+
+ /**
+ * Set field-value pairs in hash at {@literal key} with condition and expiration.
+ *
+ * @param commands must not be {@literal null}.
+ * @return never {@literal null}.
+ * @see <a href="https://redis.io/commands/hsetex">Redis Documentation: HSETEX</a>
+ */
+ Flux<BooleanResponse<HSetExCommand>> hSetEx(Publisher<HSetExCommand> commands);
 }

src/main/java/org/springframework/data/redis/connection/RedisHashCommands.java

@@ -568,4 +568,60 @@ default List<Long> hExpireAt(byte @NonNull [] key, long unixTime, byte @NonNull
  List<byte[]> hGetEx(byte @NonNull [] key, Expiration expiration,
  byte @NonNull [] @NonNull... fields);
 
+ /**
+ * Set field-value pairs in hash at {@literal key} with optional condition and expiration.
+ *
+ * @param key must not be {@literal null}.
+ * @param hashes the field-value pairs to set; must not be {@literal null}.
+ * @param hashFieldSetOption the optional condition for setting fields.
+ * @param expiration the optional expiration to apply.
+ * @return never {@literal null}.
+ * @see <a href="https://redis.io/commands/hsetex">Redis Documentation: HSETEX</a>
+ */
+ Boolean hSetEx(byte @NonNull [] key, @NonNull Map<byte[], byte[]> hashes, HashFieldSetOption hashFieldSetOption,
+ Expiration expiration);
+
+ /**
+ * {@code HSETEX} command arguments for {@code FNX}, {@code FXX}.
+ *
+ * @author Viktoriya Kutsarova
+ */
+ enum HashFieldSetOption {
+
+ /**
+ * Do not set any additional command argument.
+ */
+ UPSERT,
+
+ /**
+ * {@code FNX}
+ */
+ IF_NONE_EXIST,
+
+ /**
+ * {@code FXX}
+ */
+ IF_ALL_EXIST;
+
+ /**
+ * Do not set any additional command argument.
+ */
+ public static HashFieldSetOption upsert() {
+ return UPSERT;
+ }
+
+ /**
+ * {@code FNX}
+ */
+ public static HashFieldSetOption ifNoneExist() {
+ return IF_NONE_EXIST;
+ }
+
+ /**
+ * {@code FXX}
+ */
+ public static HashFieldSetOption ifAllExist() {
+ return IF_ALL_EXIST;
+ }
+ }
 }

src/main/java/org/springframework/data/redis/connection/StringRedisConnection.java

@@ -2576,6 +2576,20 @@ List<Long> hpExpireAt(@NonNull String key, long unixTimeInMillis, ExpirationOpti
  */
  List<String> hGetEx(@NonNull String key, Expiration expiration, @NonNull String @NonNull... fields);
 
+ /**
+ * Set field-value pairs in hash at {@literal key} with optional condition and expiration.
+ *
+ * @param key must not be {@literal null}.
+ * @param hashes the field-value pairs to set; must not be {@literal null}.
+ * @param condition the optional condition for setting fields.
+ * @param expiration the optional expiration to apply.
+ * @return never {@literal null}.
+ * @see <a href="https://redis.io/commands/hsetex">Redis Documentation: HSETEX</a>
+ * @see RedisHashCommands#hSetEx(byte[], Map, HashFieldSetOption, Expiration)
+ */
+ Boolean hSetEx(@NonNull String key, @NonNull Map<@NonNull String, String> hashes, HashFieldSetOption condition,
+ Expiration expiration);
+
 // -------------------------------------------------------------------------
 // Methods dealing with HyperLogLog
 // -------------------------------------------------------------------------

src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterHashCommands.java

@@ -441,6 +441,19 @@ public List<byte[]> hGetEx(byte[] key, Expiration expiration, byte[]... fields)
  }
  }
 
+ @Override
+ public Boolean hSetEx(byte[] key, Map<byte[], byte[]> hashes, HashFieldSetOption condition, Expiration expiration) {
+
+ Assert.notNull(key, "Key must not be null");
+ Assert.notNull(hashes, "Fields must not be null");
+
+ try {
+ return JedisConverters.toBoolean(connection.getCluster().hsetex(key, JedisConverters.toHSetExParams(condition, expiration), hashes));
+ } catch (Exception ex) {
+ throw convertJedisAccessException(ex);
+ }
+ }
+
 @Nullable
 @Override
 public Long hStrLen(byte[] key, byte[] field) {

src/main/java/org/springframework/data/redis/connection/jedis/JedisConverters.java

@@ -15,6 +15,7 @@
  */
 package org.springframework.data.redis.connection.jedis;
 
+import org.springframework.data.redis.connection.*;
 import redis.clients.jedis.GeoCoordinate;
 import redis.clients.jedis.HostAndPort;
 import redis.clients.jedis.Protocol;
@@ -47,26 +48,19 @@
 import org.springframework.data.geo.Metric;
 import org.springframework.data.geo.Metrics;
 import org.springframework.data.geo.Point;
-import org.springframework.data.redis.connection.BitFieldSubCommands;
 import org.springframework.data.redis.connection.BitFieldSubCommands.BitFieldIncrBy;
 import org.springframework.data.redis.connection.BitFieldSubCommands.BitFieldSet;
 import org.springframework.data.redis.connection.BitFieldSubCommands.BitFieldSubCommand;
-import org.springframework.data.redis.connection.RedisGeoCommands;
 import org.springframework.data.redis.connection.RedisGeoCommands.DistanceUnit;
 import org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation;
 import org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs;
 import org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs.Flag;
 import org.springframework.data.redis.connection.RedisListCommands.Position;
-import org.springframework.data.redis.connection.RedisNode;
-import org.springframework.data.redis.connection.RedisServer;
-import org.springframework.data.redis.connection.RedisServerCommands;
 import org.springframework.data.redis.connection.RedisStringCommands.BitOperation;
 import org.springframework.data.redis.connection.RedisStringCommands.SetOption;
 import org.springframework.data.redis.connection.RedisZSetCommands.ZAddArgs;
-import org.springframework.data.redis.connection.SortParameters;
 import org.springframework.data.redis.connection.SortParameters.Order;
 import org.springframework.data.redis.connection.SortParameters.Range;
-import org.springframework.data.redis.connection.ValueEncoding;
 import org.springframework.data.redis.connection.convert.Converters;
 import org.springframework.data.redis.connection.convert.ListConverter;
 import org.springframework.data.redis.connection.convert.StringToRedisClientInfoConverter;
@@ -392,6 +386,67 @@ static GetExParams toGetExParams(Expiration expiration, GetExParams params) {
 : params.ex(expiration.getConverted(TimeUnit.SECONDS));
 }
 
+/**
+ * Converts a given {@link RedisHashCommands.HashFieldSetOption} and {@link Expiration} to the according
+ * {@code HSETEX} command argument.
+ * <dl>
+ * <dt>{@link RedisHashCommands.HashFieldSetOption#ifNoneExist()}</dt>
+ * <dd>{@code FNX}</dd>
+ * <dt>{@link RedisHashCommands.HashFieldSetOption#ifAllExist()}</dt>
+ * <dd>{@code FXX}</dd>
+ * <dt>{@link RedisHashCommands.HashFieldSetOption#upsert()}</dt>
+ * <dd>no condition flag</dd>
+ * </dl>
+ * <dl>
+ * <dt>{@link TimeUnit#MILLISECONDS}</dt>
+ * <dd>{@code PX|PXAT}</dd>
+ * <dt>{@link TimeUnit#SECONDS}</dt>
+ * <dd>{@code EX|EXAT}</dd>
+ * </dl>
+ *
+ * @param condition can be {@literal null}.
+ * @param expiration can be {@literal null}.
+ * @since 4.0
+ */
+static HSetExParams toHSetExParams(RedisHashCommands.@Nullable HashFieldSetOption condition, @Nullable Expiration expiration) {
+return toHSetExParams(condition, expiration, new HSetExParams());
+}
+
+static HSetExParams toHSetExParams(RedisHashCommands.@Nullable HashFieldSetOption condition, @Nullable Expiration expiration, HSetExParams params) {
+
+if (condition == null && expiration == null) {
+return params;
+}
+
+if (condition != null) {
+if (condition.equals(RedisHashCommands.HashFieldSetOption.ifNoneExist())) {
+params.fnx();
+} else if (condition.equals(RedisHashCommands.HashFieldSetOption.ifAllExist())) {
+params.fxx();
+}
+}
+
+if (expiration == null) {
+return params;
+}
+
+if (expiration.isKeepTtl()) {
+return params.keepTtl();
+}
+
+if (expiration.isPersistent()) {
+return params;
+}
+
+if (expiration.getTimeUnit() == TimeUnit.MILLISECONDS) {
+return expiration.isUnixTimestamp() ? params.pxAt(expiration.getExpirationTime())
+: params.px(expiration.getExpirationTime());
+}
+
+return expiration.isUnixTimestamp() ? params.exAt(expiration.getConverted(TimeUnit.SECONDS))
+: params.ex(expiration.getConverted(TimeUnit.SECONDS));
+}
+
  /**
  * Converts a given {@link Expiration} to the according {@code HGETEX} command argument depending on
  * {@link Expiration#isUnixTimestamp()}.
@@ -411,6 +466,10 @@ static HGetExParams toHGetExParams(Expiration expiration) {
 
  static HGetExParams toHGetExParams(Expiration expiration, HGetExParams params) {
 
+ if (expiration == null) {
+ return params;
+ }
+
  if (expiration.isPersistent()) {
  return params.persist();
  }

src/main/java/org/springframework/data/redis/connection/jedis/JedisHashCommands.java

@@ -351,6 +351,18 @@ public List<byte[]> hGetEx(byte @NonNull [] key, Expiration expiration, byte @No
  return connection.invoke().just(Jedis::hgetex, PipelineBinaryCommands::hgetex, key, JedisConverters.toHGetExParams(expiration), fields);
  }
 
+ @Override
+ public Boolean hSetEx(byte @NonNull [] key, @NonNull Map<byte[], byte[]> hashes, HashFieldSetOption condition,
+ Expiration expiration) {
+
+ Assert.notNull(key, "Key must not be null");
+ Assert.notNull(hashes, "Hashes must not be null");
+
+ return connection.invoke().from(Jedis::hsetex, PipelineBinaryCommands::hsetex, key,
+ JedisConverters.toHSetExParams(condition, expiration), hashes)
+ .get(Converters::toBoolean);
+ }
+
 @Nullable
 @Override
 public Long hStrLen(byte[] key, byte[] field) {