HDEL
Syntax
HDEL key field [field ...]
- Available since:
- Redis Open Source 2.0.0
- Time complexity:
- O(N) where N is the number of fields to be removed.
- ACL categories:
-
@write,@hash,@fast, - Compatibility:
- Redis Enterprise and Redis Cloud compatibility
Removes the specified fields from the hash stored at key.
Specified fields that do not exist within this hash are ignored.
Deletes the hash if no fields remain.
If key does not exist, it is treated as an empty hash and this command returns
0.
Examples
HSET myhash field1 "foo"
(integer) 1
HDEL myhash field1
(integer) 1
HDEL myhash field2
(integer) 0import redis
r = redis.Redis(host="localhost", port=6379, db=0, decode_responses=True)
hdel1 = r.hset("myhash", "field1", "foo")
print(hdel1)
# >>> 1
hdel2 = r.hget("myhash", "field1")
print(hdel2)
# >>> 1
hdel3 = r.hget("myhash", "field2")
print(hdel3)
# >>> 0
res1 = r.hset("myhash", "field1", "Hello")
print(res1)
# >>> 1
res2 = r.hget("myhash", "field1")
print(res2)
# >>> Hello
res3 = r.hset("myhash", mapping={"field2": "Hi", "field3": "World"})
print(res3)
# >>> 2
res4 = r.hget("myhash", "field2")
print(res4)
# >>> Hi
res5 = r.hget("myhash", "field3")
print(res5)
# >>> World
res6 = r.hgetall("myhash")
print(res6)
# >>> { "field1": "Hello", "field2": "Hi", "field3": "World" }
res7 = r.hset("myhash", "field1", "foo")
print(res7)
# >>> 1
res8 = r.hget("myhash", "field1")
print(res8)
# >>> foo
res9 = r.hget("myhash", "field2")
print(res9)
# >>> None
res10 = r.hset("myhash", mapping={"field1": "Hello", "field2": "World"})
res11 = r.hgetall("myhash")
print(res11) # >>> { "field1": "Hello", "field2": "World" }
res10 = r.hset("myhash", mapping={"field1": "Hello", "field2": "World"})
res11 = r.hvals("myhash")
print(res11) # >>> [ "Hello", "World" ]
# Set up hash with fields
r.hset("myhash", mapping={"field1": "Hello", "field2": "World"})
# Set expiration on hash fields
res12 = r.hexpire("myhash", 10, "field1", "field2")
print(res12) # >>> [1, 1]
# Check TTL of the fields
res13 = r.httl("myhash", "field1", "field2")
print(res13) # >>> [10, 10] (or close to 10)
# Try to set expiration on non-existent field
res14 = r.hexpire("myhash", 10, "nonexistent")
print(res14) # >>> [-2]
import assert from 'node:assert';
import { createClient } from 'redis';
const client = createClient();
await client.connect().catch(console.error);
const hDel1 = await client.hSet('myhash', 'field1', 'Hello')
console.log(hDel1) // 1
const hDel2 = await client.hDel('myhash', 'field1')
console.log(hDel2) // 1
const hDel3 = await client.hDel('myhash', 'field2')
console.log(hDel3) // 0
const res1 = await client.hSet('myhash', 'field1', 'Hello')
console.log(res1) // 1
const res2 = await client.hGet('myhash', 'field1')
console.log(res2) // Hello
const res3 = await client.hSet(
'myhash',
{
'field2': 'Hi',
'field3': 'World'
}
)
console.log(res3) // 2
const res4 = await client.hGet('myhash', 'field2')
console.log(res4) // Hi
const res5 = await client.hGet('myhash', 'field3')
console.log(res5) // World
const res6 = await client.hGetAll('myhash')
console.log(res6)
const res7 = await client.hSet('myhash', 'field1', 'foo')
console.log(res7) // 1
const res8 = await client.hGet('myhash', 'field1')
console.log(res8) // foo
const res9 = await client.hGet('myhash', 'field2')
console.log(res9) // null
const res10 = await client.hSet(
'myhash',
{
'field1': 'Hello',
'field2': 'World'
}
)
const res11 = await client.hGetAll('myhash')
console.log(res11) // [Object: null prototype] { field1: 'Hello', field2: 'World' }
const res12 = await client.hSet(
'myhash',
{
'field1': 'Hello',
'field2': 'World'
}
)
const res13 = await client.hVals('myhash')
console.log(res13) // [ 'Hello', 'World' ]
// Set up hash with fields
await client.hSet('myhash', {
'field1': 'Hello',
'field2': 'World'
})
// Set expiration on hash fields
const res14 = await client.hExpire('myhash', ['field1', 'field2'], 10)
console.log(res14) // [1, 1]
// Check TTL of the fields
const res15 = await client.hTTL('myhash', ['field1', 'field2'])
console.log(res15) // [10, 10] (or close to 10)
// Try to set expiration on non-existent field
const res16 = await client.hExpire('myhash', ['nonexistent'], 10)
console.log(res16) // [-2]
await client.close();
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.Collections;
import java.util.Arrays;
import redis.clients.jedis.UnifiedJedis;
import static java.util.stream.Collectors.toList;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class CmdsHashExample {
public void run() {
UnifiedJedis jedis = new UnifiedJedis("redis://localhost:6379");
Map<String, String> hDelExampleParams = new HashMap<>();
hDelExampleParams.put("field1", "foo");
long hDelResult1 = jedis.hset("myhash", hDelExampleParams);
System.out.println(hDelResult1); // >>> 1
long hDelResult2 = jedis.hdel("myhash", "field1");
System.out.println(hDelResult2); // >>> 1
long hDelResult3 = jedis.hdel("myhash", "field2");
System.out.println(hDelResult3); // >>> 0
Map<String, String> hGetExampleParams = new HashMap<>();
hGetExampleParams.put("field1", "foo");
long hGetResult1 = jedis.hset("myhash", hGetExampleParams);
System.out.println(hGetResult1); // >>> 1
String hGetResult2 = jedis.hget("myhash", "field1");
System.out.println(hGetResult2); // >>> foo
String hGetResult3 = jedis.hget("myhash", "field2");
System.out.println(hGetResult3); // >>> null
Map<String, String> hGetAllExampleParams = new HashMap<>();
hGetAllExampleParams.put("field1", "Hello");
hGetAllExampleParams.put("field2", "World");
long hGetAllResult1 = jedis.hset("myhash", hGetAllExampleParams);
System.out.println(hGetAllResult1); // >>> 2
Map<String, String> hGetAllResult2 = jedis.hgetAll("myhash");
System.out.println(
hGetAllResult2.entrySet().stream()
.sorted((s1, s2)-> s1.getKey().compareTo(s2.getKey()))
.collect(toList())
.toString()
);
// >>> [field1=Hello, field2=World]
Map<String, String> hSetExampleParams = new HashMap<>();
hSetExampleParams.put("field1", "Hello");
long hSetResult1 = jedis.hset("myhash", hSetExampleParams);
System.out.println(hSetResult1); // >>> 1
String hSetResult2 = jedis.hget("myhash", "field1");
System.out.println(hSetResult2); // >>> Hello
hSetExampleParams.clear();
hSetExampleParams.put("field2", "Hi");
hSetExampleParams.put("field3", "World");
long hSetResult3 = jedis.hset("myhash",hSetExampleParams);
System.out.println(hSetResult3); // >>> 2
String hSetResult4 = jedis.hget("myhash", "field2");
System.out.println(hSetResult4); // >>> Hi
String hSetResult5 = jedis.hget("myhash", "field3");
System.out.println(hSetResult5); // >>> World
Map<String, String> hSetResult6 = jedis.hgetAll("myhash");
for (String key: hSetResult6.keySet()) {
System.out.println("Key: " + key + ", Value: " + hSetResult6.get(key));
}
// >>> Key: field3, Value: World
// >>> Key: field2, Value: Hi
// >>> Key: field1, Value: Hello
Map<String, String> hValsExampleParams = new HashMap<>();
hValsExampleParams.put("field1", "Hello");
hValsExampleParams.put("field2", "World");
long hValsResult1 = jedis.hset("myhash", hValsExampleParams);
System.out.println(hValsResult1); // >>> 2
List<String> hValsResult2 = jedis.hvals("myhash");
Collections.sort(hValsResult2);
System.out.println(hValsResult2);
// >>> [Hello, World]
// Set up hash with fields
Map<String, String> hExpireExampleParams = new HashMap<>();
hExpireExampleParams.put("field1", "Hello");
hExpireExampleParams.put("field2", "World");
jedis.hset("myhash", hExpireExampleParams);
// Set expiration on hash fields
List<Long> hExpireResult1 = jedis.hexpire("myhash", 10, "field1", "field2");
System.out.println(hExpireResult1); // >>> [1, 1]
// Check TTL of the fields
List<Long> hExpireResult2 = jedis.httl("myhash", "field1", "field2");
System.out.println(hExpireResult2.size()); // >>> 2
// Try to set expiration on non-existent field
List<Long> hExpireResult3 = jedis.hexpire("myhash", 10, "nonexistent");
System.out.println(hExpireResult3); // >>> [-2]
jedis.close();
}
}
package io.redis.examples.async;
import io.lettuce.core.*;
import io.lettuce.core.api.async.RedisAsyncCommands;
import io.lettuce.core.api.StatefulRedisConnection;
import java.util.*;
import java.util.concurrent.CompletableFuture;
public class CmdsHashExample {
public void run() {
Map<String, String> hDelExampleParams = new HashMap<>();
hDelExampleParams.put("field1", "foo");
CompletableFuture<Void> hDelExample = asyncCommands.hset("myhash", hDelExampleParams).thenCompose(res1 -> {
System.out.println(res1); // >>> 1
return asyncCommands.hdel("myhash", "field1");
}).thenCompose(res2 -> {
System.out.println(res2); // >>> 1
return asyncCommands.hdel("myhash", "field2");
}).thenAccept(res3 -> {
System.out.println(res3); // >>> 0
}).toCompletableFuture();
hDelExample.join();
CompletableFuture<Void> hSetExample = asyncCommands.hset("myhash", "field1", "Hello").thenCompose(res1 -> {
System.out.println(res1); // >>> 1
return asyncCommands.hget("myhash", "field1");
}).thenCompose(res2 -> {
System.out.println(res2); // >>> Hello
Map<String, String> hSetExampleParams = new HashMap<>();
hSetExampleParams.put("field2", "Hi");
hSetExampleParams.put("field3", "World");
return asyncCommands.hset("myhash", hSetExampleParams);
}).thenCompose(res3 -> {
System.out.println(res3); // >>> 2
return asyncCommands.hget("myhash", "field2");
}).thenCompose(res4 -> {
System.out.println(res4); // >>> Hi
return asyncCommands.hget("myhash", "field3");
}).thenCompose(res5 -> {
System.out.println(res5); // >>> World
return asyncCommands.hgetall("myhash");
}).thenAccept(res6 -> {
System.out.println(res6);
// >>> {field1=Hello, field2=Hi, field3=World}
}).toCompletableFuture();
hSetExample.join();
Map<String, String> hGetExampleParams = new HashMap<>();
hGetExampleParams.put("field1", "foo");
CompletableFuture<Void> hGetExample = asyncCommands.hset("myhash", hGetExampleParams).thenCompose(res1 -> {
System.out.println(res1); // >>> 1
return asyncCommands.hget("myhash", "field1");
}).thenCompose(res2 -> {
System.out.println(res2); // >>> foo
return asyncCommands.hget("myhash", "field2");
}).thenAccept(res3 -> {
System.out.println(res3); // >>> null
}).toCompletableFuture();
hGetExample.join();
Map<String, String> hGetAllExampleParams = new HashMap<>();
hGetAllExampleParams.put("field1", "Hello");
hGetAllExampleParams.put("field2", "World");
CompletableFuture<Void> hGetAllExample = asyncCommands.hset("myhash", hGetAllExampleParams).thenCompose(res1 -> {
return asyncCommands.hgetall("myhash");
}).thenAccept(res2 -> {
System.out.println(res2);
// >>> {field1=Hello, field2=World}
}).toCompletableFuture();
hGetAllExample.join();
Map<String, String> hValsExampleParams = new HashMap<>();
hValsExampleParams.put("field1", "Hello");
hValsExampleParams.put("field2", "World");
CompletableFuture<Void> hValsExample = asyncCommands.hset("myhash", hValsExampleParams).thenCompose(res1 -> {
return asyncCommands.hvals("myhash");
}).thenAccept(res2 -> {
List<String> sortedValues = new ArrayList<>(res2);
Collections.sort(sortedValues);
System.out.println(sortedValues);
// >>> [Hello, World]
}).toCompletableFuture();
hValsExample.join();
// Set up hash with fields
Map<String, String> hExpireExampleParams = new HashMap<>();
hExpireExampleParams.put("field1", "Hello");
hExpireExampleParams.put("field2", "World");
CompletableFuture<Void> hExpireExample = asyncCommands.hset("myhash", hExpireExampleParams).thenCompose(res1 -> {
// Set expiration on hash fields
return asyncCommands.hexpire("myhash", 10, "field1", "field2");
}).thenCompose(res2 -> {
System.out.println(res2);
// >>> [1, 1]
// Check TTL of the fields
return asyncCommands.httl("myhash", "field1", "field2");
}).thenCompose(res3 -> {
System.out.println(res3.size());
// >>> 2
// Try to set expiration on non-existent field
return asyncCommands.hexpire("myhash", 10, "nonexistent");
})
.thenAccept(System.out::println)
// >>> -2
.toCompletableFuture();
hExpireExample.join();
} finally {
redisClient.shutdown();
}
}
}
package io.redis.examples.reactive;
import io.lettuce.core.*;
import io.lettuce.core.api.reactive.RedisReactiveCommands;
import io.lettuce.core.api.StatefulRedisConnection;
import reactor.core.publisher.Mono;
import java.util.*;
public class CmdsHashExample {
public void run() {
RedisClient redisClient = RedisClient.create("redis://localhost:6379");
try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {
RedisReactiveCommands<String, String> reactiveCommands = connection.reactive();
Map<String, String> hDelExampleParams = new HashMap<>();
hDelExampleParams.put("field1", "foo");
Mono<Long> hDelExample1 = reactiveCommands.hset("myhash", hDelExampleParams).doOnNext(result -> {
System.out.println(result); // >>> 1
});
hDelExample1.block();
Mono<Long> hDelExample2 = reactiveCommands.hdel("myhash", "field1").doOnNext(result -> {
System.out.println(result); // >>> 1
});
hDelExample2.block();
Mono<Long> hDelExample3 = reactiveCommands.hdel("myhash", "field2").doOnNext(result -> {
System.out.println(result); // >>> 0
});
hDelExample3.block();
Mono<Boolean> hSetExample1 = reactiveCommands.hset("myhash", "field1", "Hello").doOnNext(result -> {
System.out.println(result); // >>> True
});
hSetExample1.block();
Mono<String> hSetExample2 = reactiveCommands.hget("myhash", "field1").doOnNext(result -> {
System.out.println(result); // >>> Hello
});
hSetExample2.block();
Map<String, String> hSetExampleParams = new HashMap<>();
hSetExampleParams.put("field2", "Hi");
hSetExampleParams.put("field3", "World");
Mono<Long> hSetExample3 = reactiveCommands.hset("myhash", hSetExampleParams).doOnNext(result -> {
System.out.println(result); // >>> 2
});
hSetExample3.block();
Mono<String> hSetExample4 = reactiveCommands.hget("myhash", "field2").doOnNext(result -> {
System.out.println(result); // >>> Hi
});
hSetExample4.block();
Mono<String> hSetExample5 = reactiveCommands.hget("myhash", "field3").doOnNext(result -> {
System.out.println(result); // >>> World
});
hSetExample5.block();
Mono<Map<String, String>> hSetExample6 = reactiveCommands.hgetall("myhash").collectMap(
KeyValue::getKey, KeyValue::getValue
).doOnNext(result -> {
System.out.println(result);
// >>> {field1=Hello, field2=Hi, field3=World}
});
hSetExample6.block();
Map<String, String> hGetExampleParams = new HashMap<>();
hGetExampleParams.put("field1", "foo");
Mono<Long> hGetExample1 = reactiveCommands.hset("myhash", hGetExampleParams).doOnNext(result -> {
System.out.println(result); // >>> 1
});
hGetExample1.block();
Mono<String> hGetExample2 = reactiveCommands.hget("myhash", "field1").doOnNext(result -> {
System.out.println(result); // >>> foo
});
hGetExample2.block();
Mono<String> hGetExample3 = reactiveCommands.hget("myhash", "field2").doOnNext(result -> {
System.out.println(result); // >>> null
});
hGetExample3.block();
Map<String, String> hGetAllExampleParams = new HashMap<>();
hGetAllExampleParams.put("field1", "Hello");
hGetAllExampleParams.put("field2", "World");
Mono<Long> hGetAllExample1 = reactiveCommands.hset("myhash", hGetAllExampleParams).doOnNext(result -> {
});
hGetAllExample1.block();
Mono<Map<String, String>> hGetAllExample2 = reactiveCommands.hgetall("myhash").collectMap(
KeyValue::getKey, KeyValue::getValue
).doOnNext(result -> {
System.out.println(result);
// >>> {field1=Hello, field2=World}
});
hGetAllExample2.block();
Map<String, String> hValsExampleParams = new HashMap<>();
hValsExampleParams.put("field1", "Hello");
hValsExampleParams.put("field2", "World");
Mono<Long> hValsExample1 = reactiveCommands.hset("myhash", hValsExampleParams).doOnNext(result -> {
});
hValsExample1.block();
Mono<List<String>> hValsExample2 = reactiveCommands.hvals("myhash").collectList().doOnNext(result -> {
List<String> sortedValues = new ArrayList<>(result);
Collections.sort(sortedValues);
System.out.println(sortedValues);
// >>> [Hello, World]
});
hValsExample2.block();
// Set up hash with fields
Map<String, String> hExpireExampleParams = new HashMap<>();
hExpireExampleParams.put("field1", "Hello");
hExpireExampleParams.put("field2", "World");
Mono<Long> hExpireExample1 = reactiveCommands.hset("myhash", hExpireExampleParams).doOnNext(result -> {
});
hExpireExample1.block();
// Set expiration on hash fields
Mono<List<Long>> hExpireExample2 = reactiveCommands.hexpire("myhash", 10, "field1", "field2").collectList().doOnNext(result -> {
System.out.println(result);
// >>> [1, 1]
});
hExpireExample2.block();
// Check TTL of the fields
Mono<List<Long>> hExpireExample3 = reactiveCommands.httl("myhash", "field1", "field2").collectList().doOnNext(result -> {
System.out.println(result.size());
// >>> 2
});
hExpireExample3.block();
// Try to set expiration on non-existent field
Mono<List<Long>> hExpireExample4 = reactiveCommands.hexpire("myhash", 10, "nonexistent").collectList().doOnNext(result -> {
System.out.println(result);
// >>> [-2]
});
hExpireExample4.block();
} finally {
redisClient.shutdown();
}
}
}
package example_commands_test
import (
"context"
"fmt"
"sort"
"time"
"github.com/redis/go-redis/v9"
)
func ExampleClient_hset() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
res1, err := rdb.HSet(ctx, "myhash", "field1", "Hello").Result()
if err != nil {
panic(err)
}
fmt.Println(res1) // >>> 1
res2, err := rdb.HGet(ctx, "myhash", "field1").Result()
if err != nil {
panic(err)
}
fmt.Println(res2) // >>> Hello
res3, err := rdb.HSet(ctx, "myhash",
"field2", "Hi",
"field3", "World",
).Result()
if err != nil {
panic(err)
}
fmt.Println(res3) // >>> 2
res4, err := rdb.HGet(ctx, "myhash", "field2").Result()
if err != nil {
panic(err)
}
fmt.Println(res4) // >>> Hi
res5, err := rdb.HGet(ctx, "myhash", "field3").Result()
if err != nil {
panic(err)
}
fmt.Println(res5) // >>> World
res6, err := rdb.HGetAll(ctx, "myhash").Result()
if err != nil {
panic(err)
}
keys := make([]string, 0, len(res6))
for key, _ := range res6 {
keys = append(keys, key)
}
sort.Strings(keys)
for _, key := range keys {
fmt.Printf("Key: %v, value: %v\n", key, res6[key])
}
// >>> Key: field1, value: Hello
// >>> Key: field2, value: Hi
// >>> Key: field3, value: World
}
func ExampleClient_hget() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
res7, err := rdb.HSet(ctx, "myhash", "field1", "foo").Result()
if err != nil {
panic(err)
}
fmt.Println(res7) // >>> 1
res8, err := rdb.HGet(ctx, "myhash", "field1").Result()
if err != nil {
panic(err)
}
fmt.Println(res8) // >>> foo
res9, err := rdb.HGet(ctx, "myhash", "field2").Result()
if err != nil {
fmt.Println(err)
}
fmt.Println(res9) // >>> <empty string>
}
func ExampleClient_hgetall() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password
DB: 0, // use default DB
})
hGetAllResult1, err := rdb.HSet(ctx, "myhash",
"field1", "Hello",
"field2", "World",
).Result()
if err != nil {
panic(err)
}
fmt.Println(hGetAllResult1) // >>> 2
hGetAllResult2, err := rdb.HGetAll(ctx, "myhash").Result()
if err != nil {
panic(err)
}
keys := make([]string, 0, len(hGetAllResult2))
for key, _ := range hGetAllResult2 {
keys = append(keys, key)
}
sort.Strings(keys)
for _, key := range keys {
fmt.Printf("Key: %v, value: %v\n", key, hGetAllResult2[key])
}
// >>> Key: field1, value: Hello
// >>> Key: field2, value: World
}
func ExampleClient_hvals() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
hValsResult1, err := rdb.HSet(ctx, "myhash",
"field1", "Hello",
"field2", "World",
).Result()
if err != nil {
panic(err)
}
fmt.Println(hValsResult1) // >>> 2
hValsResult2, err := rdb.HVals(ctx, "myhash").Result()
if err != nil {
panic(err)
}
sort.Strings(hValsResult2)
fmt.Println(hValsResult2) // >>> [Hello World]
}
func ExampleClient_hdel() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
hdel1, err := rdb.HSet(ctx, "myhash", "field1", "foo").Result()
if err != nil {
panic(err)
}
fmt.Println(hdel1) // >>> 1
hdel2, err := rdb.HDel(ctx, "myhash", "field1").Result()
if err != nil {
panic(err)
}
fmt.Println(hdel2) // >>> 1
hdel3, err := rdb.HDel(ctx, "myhash", "field2").Result()
if err != nil {
fmt.Println(err)
}
fmt.Println(hdel3) // >>> 0
}
func ExampleClient_hexpire() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password
DB: 0, // use default DB
})
// Set up hash with fields
rdb.HSet(ctx, "myhash", "field1", "Hello", "field2", "World")
// Set expiration on hash fields
res1, err := rdb.HExpire(ctx, "myhash", 10*time.Second, "field1", "field2").Result()
if err != nil {
fmt.Println(err)
}
fmt.Println(res1) // >>> [1 1]
// Check TTL of the fields
res2, err := rdb.HTTL(ctx, "myhash", "field1", "field2").Result()
if err != nil {
fmt.Println(err)
}
fmt.Println(len(res2)) // >>> 2
// Try to set expiration on non-existent field
res3, err := rdb.HExpire(ctx, "myhash", 10*time.Second, "nonexistent").Result()
if err != nil {
fmt.Println(err)
}
fmt.Println(res3) // >>> [-2]
// Clean up
rdb.Del(ctx, "myhash")
}using StackExchange.Redis;
using Xunit;
using System.Linq;
namespace Doc;
public class CmdsHashExample
{
public void Run()
{
var muxer = ConnectionMultiplexer.Connect("localhost:6379");
var db = muxer.GetDatabase();
// Clear any keys here before using them in tests.
db.KeyDelete("myhash");
bool hdelRes1 = db.HashSet("myhash", "field1", "foo");
RedisValue hdelRes2 = db.HashDelete("myhash", "field1");
Console.WriteLine(hdelRes2); // >>> 1
RedisValue hdelRes3 = db.HashDelete("myhash", "field1");
Console.WriteLine(hdelRes3); // >>> 0
bool hgetRes1 = db.HashSet("myhash", "field1", "foo");
RedisValue hgetRes2 = db.HashGet("myhash", "field1");
Console.WriteLine(hgetRes2); // >>> foo
RedisValue hgetRes3 = db.HashGet("myhash", "field2");
Console.WriteLine(hgetRes3); // >>> Null
bool hsetRes1 = db.HashSet("myhash", "field1", "Hello");
RedisValue hsetRes2 = db.HashGet("myhash", "field1");
Console.WriteLine(hsetRes2); // >>> Hello
db.HashSet(
"myhash",
[
new("field2", "Hi"),
new("field3", "World")
]
);
RedisValue hsetRes3 = db.HashGet("myhash", "field2");
Console.WriteLine(hsetRes3); // >>> Hi
RedisValue hsetRes4 = db.HashGet("myhash", "field3");
Console.WriteLine(hsetRes4); // >>> World
HashEntry[] hsetRes5 = db.HashGetAll("myhash");
Console.WriteLine($"{string.Join(", ", hsetRes5.Select(h => $"{h.Name}: {h.Value}"))}");
// >>> field1: Hello, field2: Hi, field3: World
db.HashSet("myhash",
[
new("field1", "Hello"),
new("field2", "World")
]
);
HashEntry[] hGetAllResult = db.HashGetAll("myhash");
Array.Sort(hGetAllResult, (a1, a2) => a1.Name.CompareTo(a2.Name));
Console.WriteLine(
string.Join(", ", hGetAllResult.Select(e => $"{e.Name}: {e.Value}"))
);
// >>> field1: Hello, field2: World
db.HashSet("myhash",
[
new("field1", "Hello"),
new("field2", "World")
]
);
RedisValue[] hValsResult = db.HashValues("myhash");
Array.Sort(hValsResult);
Console.WriteLine(string.Join(", ", hValsResult));
// >>> Hello, World
// Set up hash with fields
db.HashSet("myhash",
[
new("field1", "Hello"),
new("field2", "World")
]
);
ExpireResult[] hexpireRes1 = db.HashFieldExpire(
"myhash",
new RedisValue[] { "field1", "field2" },
TimeSpan.FromSeconds(10)
);
Console.WriteLine(string.Join(", ", hexpireRes1));
// >>> Success, Success
long[] hexpireRes2 = db.HashFieldGetTimeToLive(
"myhash",
new RedisValue[] { "field1", "field2" }
);
Console.WriteLine(string.Join(", ", hexpireRes2));
// >>> 10, 10 (approximately)
// Try to set expiration on non-existent field
ExpireResult[] hexpireRes3 = db.HashFieldExpire(
"myhash",
new RedisValue[] { "nonexistent" },
TimeSpan.FromSeconds(10)
);
Console.WriteLine(string.Join(", ", hexpireRes3));
// >>> NoSuchField
}
}
<?php
require_once __DIR__ . '/../vendor/autoload.php';
use PHPUnit\Framework\TestCase;
use Predis\Client as PredisClient;
class CmdsHashTest extends TestCase
{
private PredisClient $redis;
protected function setUp(): void
{
$this->redis = new PredisClient([
'scheme' => 'tcp',
'host' => '127.0.0.1',
'port' => 6379,
'password' => '',
'database' => 0,
]);
// Clean up before each test
$this->redis->flushall();
}
public function testCmdsHash(): void
{
$hDelResult1 = $this->redis->hset('myhash', 'field1', 'foo');
echo "HSET myhash field1 foo: " . $hDelResult1 . "\n"; // >>> 1
$hDelResult2 = $this->redis->hdel('myhash', 'field1');
echo "HDEL myhash field1: " . $hDelResult2 . "\n"; // >>> 1
$hDelResult3 = $this->redis->hdel('myhash', 'field2');
echo "HDEL myhash field2: " . $hDelResult3 . "\n"; // >>> 0
$hGetResult1 = $this->redis->hset('myhash', 'field1', 'foo');
echo "HSET myhash field1 foo: " . $hGetResult1 . "\n"; // >>> 1
$hGetResult2 = $this->redis->hget('myhash', 'field1');
echo "HGET myhash field1: " . ($hGetResult2 ?? 'null') . "\n"; // >>> foo
$hGetResult3 = $this->redis->hget('myhash', 'field2');
echo "HGET myhash field2: " . ($hGetResult3 ?? 'null') . "\n"; // >>> null
$hGetAllResult1 = $this->redis->hmset('myhash', ['field1' => 'Hello', 'field2' => 'World']);
echo "HMSET myhash field1 Hello field2 World: " . ($hGetAllResult1 ? 'OK' : 'FAIL') . "\n"; // >>> OK
$hGetAllResult2 = $this->redis->hgetall('myhash');
echo "HGETALL myhash: " . json_encode($hGetAllResult2) . "\n"; // >>> {"field1":"Hello","field2":"World"}
$hSetResult1 = $this->redis->hset('myhash', 'field1', 'Hello');
echo "HSET myhash field1 Hello: " . $hSetResult1 . "\n"; // >>> 1
$hSetResult2 = $this->redis->hget('myhash', 'field1');
echo "HGET myhash field1: " . $hSetResult2 . "\n"; // >>> Hello
$hSetResult3 = $this->redis->hmset('myhash', ['field2' => 'Hi', 'field3' => 'World']);
echo "HMSET myhash field2 Hi field3 World: " . ($hSetResult3 ? 'OK' : 'FAIL') . "\n"; // >>> OK
$hSetResult4 = $this->redis->hget('myhash', 'field2');
echo "HGET myhash field2: " . $hSetResult4 . "\n"; // >>> Hi
$hSetResult5 = $this->redis->hget('myhash', 'field3');
echo "HGET myhash field3: " . $hSetResult5 . "\n"; // >>> World
$hSetResult6 = $this->redis->hgetall('myhash');
echo "HGETALL myhash: ";
foreach ($hSetResult6 as $key => $value) {
echo "Key: $key, Value: $value; ";
}
echo "\n";
$hValsResult1 = $this->redis->hmset('myhash', ['field1' => 'Hello', 'field2' => 'World']);
echo "HMSET myhash field1 Hello field2 World: " . ($hValsResult1 ? 'OK' : 'FAIL') . "\n"; // >>> OK
$hValsResult2 = $this->redis->hvals('myhash');
echo "HVALS myhash: " . json_encode($hValsResult2) . "\n"; // >>> ["Hello","World"]
// Set up hash with fields
$hExpireResult1 = $this->redis->hmset('myhash', ['field1' => 'Hello', 'field2' => 'World']);
echo "HMSET myhash field1 Hello field2 World: " . ($hExpireResult1 ? 'OK' : 'FAIL') . "\n"; // >>> OK
// Set expiration on hash fields
$hExpireResult2 = $this->redis->hexpire('myhash', 10, ['field1', 'field2']);
echo "HEXPIRE myhash 10 FIELDS field1 field2: " . json_encode($hExpireResult2) . "\n"; // >>> [1,1]
// Check TTL of the fields
$hExpireResult3 = $this->redis->httl('myhash', ['field1', 'field2']);
echo "HTTL myhash FIELDS field1 field2 count: " . count($hExpireResult3) . "\n"; // >>> 2
// Try to set expiration on non-existent field
$hExpireResult4 = $this->redis->hexpire('myhash', 10, ['nonexistent']);
echo "HEXPIRE myhash 10 FIELDS nonexistent: " . json_encode($hExpireResult4) . "\n"; // >>> [-2]
}
protected function tearDown(): void
{
// Clean up after each test
$this->redis->flushall();
$this->redis->disconnect();
}
}
mod cmds_hash_tests {
use redis::Commands;
use std::collections::HashMap;
fn run() {
let mut r = match redis::Client::open("redis://127.0.0.1") {
Ok(client) => {
match client.get_connection() {
Ok(conn) => conn,
Err(e) => {
println!("Failed to connect to Redis: {e}");
return;
}
}
},
Err(e) => {
println!("Failed to create Redis client: {e}");
return;
}
};
// Clean up any existing data
let _: Result<i32, _> = r.del("myhash");
match r.hset("myhash", "field1", "foo") {
Ok(hdel1) => {
let hdel1: i32 = hdel1;
println!("{hdel1}"); // >>> 1
},
Err(e) => {
println!("Error setting hash field: {e}");
return;
}
}
match r.hget("myhash", "field1") {
Ok(hdel2) => {
let hdel2: Option<String> = hdel2;
match hdel2 {
Some(value) => {
println!("{value}"); // >>> foo
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
match r.hget("myhash", "field2") {
Ok(hdel3) => {
let hdel3: Option<String> = hdel3;
match hdel3 {
Some(_) => {
println!("Some value");
},
None => {
println!("None"); // >>> None
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
match r.hset("myhash", "field1", "Hello") {
Ok(res1) => {
let res1: i32 = res1;
println!("{res1}"); // >>> 1
},
Err(e) => {
println!("Error setting hash field: {e}");
return;
}
}
match r.hget("myhash", "field1") {
Ok(res2) => {
let res2: Option<String> = res2;
match res2 {
Some(value) => {
println!("{value}"); // >>> Hello
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
// Set multiple fields using hset_multiple
let hash_fields = [
("field2", "Hi"),
("field3", "World"),
];
if let Ok(res) = r.hset_multiple("myhash", &hash_fields) {
let res: String = res;
println!("{res}"); // >>> OK
}
match r.hget("myhash", "field2") {
Ok(res4) => {
let res4: Option<String> = res4;
match res4 {
Some(value) => {
println!("{value}"); // >>> Hi
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
match r.hget("myhash", "field3") {
Ok(res5) => {
let res5: Option<String> = res5;
match res5 {
Some(value) => {
println!("{value}"); // >>> World
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
match r.hgetall("myhash") {
Ok(res6) => {
let res6: HashMap<String, String> = res6;
println!("{res6:?}"); // >>> {"field1": "Hello", "field2": "Hi", "field3": "World"}
},
Err(e) => {
println!("Error getting all hash fields: {e}");
return;
}
}
match r.hset("myhash", "field1", "foo") {
Ok(res7) => {
let res7: i32 = res7;
println!("{res7}"); // >>> 1
},
Err(e) => {
println!("Error setting hash field: {e}");
return;
}
}
match r.hget("myhash", "field1") {
Ok(res8) => {
let res8: Option<String> = res8;
match res8 {
Some(value) => {
println!("{value}"); // >>> foo
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
match r.hget("myhash", "field2") {
Ok(res9) => {
let res9: Option<String> = res9;
match res9 {
Some(_) => {
println!("Some value");
},
None => {
println!("None"); // >>> None
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
let hash_fields = [
("field1", "Hello"),
("field2", "World"),
];
if let Ok(_) = r.hset_multiple::<&str, &str, &str, String>("myhash", &hash_fields) {
// Fields set successfully
}
match r.hgetall("myhash") {
Ok(res11) => {
let res11: HashMap<String, String> = res11;
println!("{res11:?}"); // >>> {"field1": "Hello", "field2": "World"}
},
Err(e) => {
println!("Error getting all hash fields: {e}");
return;
}
}
let hash_fields = [
("field1", "Hello"),
("field2", "World"),
];
if let Ok(_) = r.hset_multiple::<&str, &str, &str, String>("myhash", &hash_fields) {
// Fields set successfully
}
match r.hvals("myhash") {
Ok(res11) => {
let res11: Vec<String> = res11;
println!("{res11:?}"); // >>> ["Hello", "World"]
},
Err(e) => {
println!("Error getting hash values: {e}");
return;
}
}
// Set up hash with fields
let hash_fields = vec![("field1", "Hello"), ("field2", "World")];
if let Ok(res) = r.hset_multiple("myhash", &hash_fields) {
let res: String = res;
println!("{res}"); // >>> OK
}
// Set expiration on hash fields
match r.hexpire("myhash", 10, redis::ExpireOption::NONE, &["field1", "field2"]) {
Ok(res1) => {
let res1: Vec<i32> = res1;
println!("{:?}", res1); // >>> [1, 1]
},
Err(e) => {
println!("Error setting expiration: {e}");
return;
}
}
// Check TTL of the fields
match r.httl("myhash", &["field1", "field2"]) {
Ok(res2) => {
let res2: Vec<i32> = res2;
println!("{}", res2.len()); // >>> 2
},
Err(e) => {
println!("Error getting TTL: {e}");
return;
}
}
// Try to set expiration on non-existent field
match r.hexpire("myhash", 10, redis::ExpireOption::NONE, &["nonexistent"]) {
Ok(res3) => {
let res3: Vec<i32> = res3;
println!("{:?}", res3); // >>> [-2]
},
Err(e) => {
println!("Error setting expiration on non-existent field: {e}");
return;
}
}
}
}
mod cmds_hash_tests {
use redis::AsyncCommands;
use std::collections::HashMap;
async fn run() {
let mut r = match redis::Client::open("redis://127.0.0.1") {
Ok(client) => {
match client.get_multiplexed_async_connection().await {
Ok(conn) => conn,
Err(e) => {
println!("Failed to connect to Redis: {e}");
return;
}
}
},
Err(e) => {
println!("Failed to create Redis client: {e}");
return;
}
};
// Clean up any existing data
let _: Result<i32, _> = r.del("myhash").await;
match r.hset("myhash", "field1", "foo").await {
Ok(hdel1) => {
let hdel1: i32 = hdel1;
println!("{hdel1}"); // >>> 1
},
Err(e) => {
println!("Error setting hash field: {e}");
return;
}
}
match r.hget("myhash", "field1").await {
Ok(hdel2) => {
let hdel2: Option<String> = hdel2;
match hdel2 {
Some(value) => {
println!("{value}"); // >>> foo
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
match r.hget("myhash", "field2").await {
Ok(hdel3) => {
let hdel3: Option<String> = hdel3;
match hdel3 {
Some(_) => {
println!("Some value");
},
None => {
println!("None"); // >>> None
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
match r.hset("myhash", "field1", "Hello").await {
Ok(res1) => {
let res1: i32 = res1;
println!("{res1}"); // >>> 1
},
Err(e) => {
println!("Error setting hash field: {e}");
return;
}
}
match r.hget("myhash", "field1").await {
Ok(res2) => {
let res2: Option<String> = res2;
match res2 {
Some(value) => {
println!("{value}"); // >>> Hello
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
// Set multiple fields using hset_multiple
let hash_fields = [
("field2", "Hi"),
("field3", "World"),
];
if let Ok(res) = r.hset_multiple("myhash", &hash_fields).await {
let res: String = res;
println!("{res}"); // >>> OK
}
match r.hget("myhash", "field2").await {
Ok(res4) => {
let res4: Option<String> = res4;
match res4 {
Some(value) => {
println!("{value}"); // >>> Hi
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
match r.hget("myhash", "field3").await {
Ok(res5) => {
let res5: Option<String> = res5;
match res5 {
Some(value) => {
println!("{value}"); // >>> World
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
match r.hgetall("myhash").await {
Ok(res6) => {
let res6: HashMap<String, String> = res6;
println!("{res6:?}"); // >>> {"field1": "Hello", "field2": "Hi", "field3": "World"}
},
Err(e) => {
println!("Error getting all hash fields: {e}");
return;
}
}
match r.hset("myhash", "field1", "foo").await {
Ok(res7) => {
let res7: i32 = res7;
println!("{res7}"); // >>> 1
},
Err(e) => {
println!("Error setting hash field: {e}");
return;
}
}
match r.hget("myhash", "field1").await {
Ok(res8) => {
let res8: Option<String> = res8;
match res8 {
Some(value) => {
println!("{value}"); // >>> foo
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
match r.hget("myhash", "field2").await {
Ok(res9) => {
let res9: Option<String> = res9;
match res9 {
Some(_) => {
println!("Some value");
},
None => {
println!("None"); // >>> None
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
let hash_fields = [
("field1", "Hello"),
("field2", "World"),
];
if let Ok(_) = r.hset_multiple::<&str, &str, &str, String>("myhash", &hash_fields).await {
// Fields set successfully
}
match r.hgetall("myhash").await {
Ok(res11) => {
let res11: HashMap<String, String> = res11;
println!("{res11:?}"); // >>> {"field1": "Hello", "field2": "World"}
},
Err(e) => {
println!("Error getting all hash fields: {e}");
return;
}
}
let hash_fields = [
("field1", "Hello"),
("field2", "World"),
];
if let Ok(_) = r.hset_multiple::<&str, &str, &str, String>("myhash", &hash_fields).await {
// Fields set successfully
}
match r.hvals("myhash").await {
Ok(res11) => {
let res11: Vec<String> = res11;
println!("{res11:?}"); // >>> ["Hello", "World"]
},
Err(e) => {
println!("Error getting hash values: {e}");
return;
}
}
// Set up hash with fields
let hash_fields = vec![("field1", "Hello"), ("field2", "World")];
if let Ok(res) = r.hset_multiple("myhash", &hash_fields).await {
let res: String = res;
println!("{res}"); // >>> OK
}
// Set expiration on hash fields
match r.hexpire("myhash", 10, redis::ExpireOption::NONE, &["field1", "field2"]).await {
Ok(res1) => {
let res1: Vec<i32> = res1;
println!("{:?}", res1); // >>> [1, 1]
},
Err(e) => {
println!("Error setting expiration: {e}");
return;
}
}
// Check TTL of the fields
match r.httl("myhash", &["field1", "field2"]).await {
Ok(res2) => {
let res2: Vec<i32> = res2;
println!("{}", res2.len()); // >>> 2
},
Err(e) => {
println!("Error getting TTL: {e}");
return;
}
}
// Try to set expiration on non-existent field
match r.hexpire("myhash", 10, redis::ExpireOption::NONE, &["nonexistent"]).await {
Ok(res3) => {
let res3: Vec<i32> = res3;
println!("{:?}", res3); // >>> [-2]
},
Err(e) => {
println!("Error setting expiration on non-existent field: {e}");
return;
}
}
}
}
Give these commands a try in the interactive console:
Redis Enterprise and Redis Cloud compatibility
| Redis Enterprise |
Redis Cloud |
Notes |
|---|---|---|
| ✅ Standard |
✅ Standard |
Return information
Integer reply: the number of fields that were removed from the hash, excluding any specified but non-existing fields.
History
- Starting with Redis version 2.4.0: Accepts multiple
fieldarguments.