HDEL
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 Software 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.
Required arguments
key
The name of the key that holds the hash.
field [field ...]
One or more fields to delete from the hash.
Examples
Foundational: Delete one or more fields from a hash using HDEL (returns count of deleted fields, ignores non-existent fields)
HSET myhash field1 "foo"
(integer) 1
HDEL myhash field1
(integer) 1
HDEL myhash field2
(integer) 0hdel1 = r.hset("myhash", "field1", "foo")
print(hdel1)
# >>> 1
hdel2 = r.hdel("myhash", "field1")
print(hdel2)
# >>> 1
hdel3 = r.hdel("myhash", "field2")
print(hdel3)
# >>> 0
import redis
r = redis.Redis(host="localhost", port=6379, db=0, decode_responses=True)
hdel1 = r.hset("myhash", "field1", "foo")
print(hdel1)
# >>> 1
hdel2 = r.hdel("myhash", "field1")
print(hdel2)
# >>> 1
hdel3 = r.hdel("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
r.hset("myhash", mapping={"field1": "Hello", "field2": "World"})
hmget_result = r.hmget("myhash", ["field1", "field2", "nofield"])
print(hmget_result) # >>> ['Hello', 'World', 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]
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
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
await client.hSet('myhash', { field1: 'Hello', field2: 'World' });
const hmgetResult = await client.hmGet('myhash', ['field1', 'field2', 'nofield']);
console.log(hmgetResult); // ['Hello', 'World', 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 assert from 'node:assert';
import { Redis } from 'ioredis';
const redis = new Redis();
await redis.hset('myhash', { field1: 'Hello', field2: 'World' });
const hmgetResult = await redis.hmget('myhash', 'field1', 'field2', 'nofield');
console.log(hmgetResult); // >>> ['Hello', 'World', null]
redis.disconnect();
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
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.Collections;
import java.util.Arrays;
import redis.clients.jedis.RedisClient;
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() {
RedisClient jedis = RedisClient.create("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> hmgetExampleParams = new HashMap<>();
hmgetExampleParams.put("field1", "Hello");
hmgetExampleParams.put("field2", "World");
jedis.hset("myhash", hmgetExampleParams);
List<String> hmgetResult = jedis.hmget("myhash", "field1", "field2", "nofield");
System.out.println(hmgetResult); // >>> [Hello, World, 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();
}
}
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();
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> hmgetExampleParams = new HashMap<>();
hmgetExampleParams.put("field1", "Hello");
hmgetExampleParams.put("field2", "World");
CompletableFuture<Void> hmgetExample = asyncCommands.hset("myhash", hmgetExampleParams).thenCompose(res1 -> {
return asyncCommands.hmget("myhash", "field1", "field2", "nofield");
}).thenAccept(res2 -> {
System.out.println(res2); // >>> [KeyValue[field1, Hello], KeyValue[field2, World], KeyValue[nofield, null]]
}).toCompletableFuture();
hmgetExample.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();
}
}
}
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
});
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.Flux;
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> hmgetExampleParams = new HashMap<>();
hmgetExampleParams.put("field1", "Hello");
hmgetExampleParams.put("field2", "World");
Mono<Long> hmgetExample1 = reactiveCommands.hset("myhash", hmgetExampleParams);
hmgetExample1.block();
Flux<KeyValue<String, String>> hmgetExample2 = reactiveCommands.hmget("myhash", "field1", "field2", "nofield")
.doOnNext(result -> {
System.out.println(result);
// >>> KeyValue[field1, Hello]
// >>> KeyValue[field2, World]
// >>> KeyValue[nofield, null]
});
hmgetExample2.collectList().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();
}
}
}
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
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_hmget() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password
DB: 0, // use default DB
})
rdb.HSet(ctx, "myhash", "field1", "Hello", "field2", "World")
hmgetResult, err := rdb.HMGet(ctx, "myhash", "field1", "field2", "nofield").Result()
if err != nil {
panic(err)
}
fmt.Println(hmgetResult) // >>> [Hello World <nil>]
}
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")
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <hiredis/hiredis.h>
int main(int argc, char **argv) {
redisContext *c = redisConnect("127.0.0.1", 6379);
if (c == NULL || c->err) {
if (c) {
printf("Connection error: %s\n", c->errstr);
redisFree(c);
} else {
printf("Connection error: can't allocate redis context\n");
}
return 1;
}
redisReply *reply;
// Set up hash with fields
reply = redisCommand(c, "HSET %s %s %s %s %s",
"myhash", "field1", "Hello", "field2", "World");
freeReplyObject(reply);
// Get multiple fields at once
reply = redisCommand(c, "HMGET %s %s %s %s",
"myhash", "field1", "field2", "nofield");
printf("HMGET myhash field1 field2 nofield:\n");
for (size_t i = 0; i < reply->elements; i++) {
if (reply->element[i]->type == REDIS_REPLY_NIL) {
printf(" [%zu]: null\n", i);
} else {
printf(" [%zu]: %s\n", i, reply->element[i]->str);
}
}
// >>> [0]: Hello
// >>> [1]: World
// >>> [2]: null
freeReplyObject(reply);
redisFree(c);
return 0;
}
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
using StackExchange.Redis;
using NRedisStack.Tests;
public class CmdsHashExample
{
public void Run()
{
var muxer = ConnectionMultiplexer.Connect("localhost:6379");
var db = muxer.GetDatabase();
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
db.HashSet("myhash",
[
new("field1", "Hello"),
new("field2", "World")
]
);
RedisValue[] hmgetResult = db.HashGet("myhash", new RedisValue[] { "field1", "field2", "nofield" });
Console.WriteLine(string.Join(", ", hmgetResult.Select(v => v.IsNull ? "null" : v.ToString())));
// >>> Hello, World, 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
}
}
$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
<?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
$this->redis->hmset('myhash', ['field1' => 'Hello', 'field2' => 'World']);
$hmgetResult = $this->redis->hmget('myhash', ['field1', 'field2', 'nofield']);
echo "HMGET myhash field1 field2 nofield: ";
print_r($hmgetResult);
// >>> Array ( [0] => Hello [1] => World [2] => )
$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();
}
}
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.hdel("myhash", "field1") {
Ok(hdel2) => {
let hdel2: Option<i32> = hdel2;
match hdel2 {
Some(value) => {
println!("{value}"); // >>> 1
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
match r.hdel("myhash", "field2") {
Ok(hdel3) => {
let hdel3: Option<i32> = hdel3;
match hdel3 {
Some(value) => {
println!("{value}"); // >>> 0
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
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.hdel("myhash", "field1") {
Ok(hdel2) => {
let hdel2: Option<i32> = hdel2;
match hdel2 {
Some(value) => {
println!("{value}"); // >>> 1
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
match r.hdel("myhash", "field2") {
Ok(hdel3) => {
let hdel3: Option<i32> = hdel3;
match hdel3 {
Some(value) => {
println!("{value}"); // >>> 0
},
None => {
println!("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.hmget::<&str, &[&str], Vec<Option<String>>>("myhash", &["field1", "field2", "nofield"]) {
Ok(hmget_result) => {
println!("{:?}", hmget_result); // >>> [Some("Hello"), Some("World"), None]
},
Err(e) => {
println!("Error getting 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.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;
}
}
}
}
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.hdel("myhash", "field1").await {
Ok(hdel2) => {
let hdel2: Option<i32> = hdel2;
match hdel2 {
Some(value) => {
println!("{value}"); // >>> 1
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
match r.hdel("myhash", "field2").await {
Ok(hdel3) => {
let hdel3: Option<i32> = hdel3;
match hdel3 {
Some(value) => {
println!("{value}"); // >>> 0
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash 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.hdel("myhash", "field1").await {
Ok(hdel2) => {
let hdel2: Option<i32> = hdel2;
match hdel2 {
Some(value) => {
println!("{value}"); // >>> 1
},
None => {
println!("None");
}
}
},
Err(e) => {
println!("Error getting hash field: {e}");
return;
}
}
match r.hdel("myhash", "field2").await {
Ok(hdel3) => {
let hdel3: Option<i32> = hdel3;
match hdel3 {
Some(value) => {
println!("{value}"); // >>> 0
},
None => {
println!("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.hmget::<&str, &[&str], Vec<Option<String>>>("myhash", &["field1", "field2", "nofield"]).await {
Ok(hmget_result) => {
println!("{:?}", hmget_result); // >>> [Some("Hello"), Some("World"), None]
},
Err(e) => {
println!("Error getting 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.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 Software and Redis Cloud compatibility
| Redis Software |
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.