HVALS
HVALS key
- Available since:
- Redis Open Source 2.0.0
- Time complexity:
- O(N) where N is the size of the hash.
- ACL categories:
-
@read,@hash,@slow, - Compatibility:
- Redis Software and Redis Cloud compatibility
Returns all values in the hash stored at key.
Required arguments
key
The name of the key that holds the hash.
Examples
Foundational: Retrieve all values from a hash using HVALS (returns only values without field names, useful when you only need the data)
res10 = r.hset("myhash", mapping={"field1": "Hello", "field2": "World"})
res11 = r.hvals("myhash")
print(res11) # >>> [ "Hello", "World" ]
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]
res15 = r.hset("myhash", "field1", "Hello")
print(res15)
# >>> 1
res16 = r.hset("myhash", "field2", "World")
print(res16)
# >>> 1
res17 = r.hlen("myhash")
print(res17)
# >>> 2
const res12 = await client.hSet(
'myhash',
{
'field1': 'Hello',
'field2': 'World'
}
)
const res13 = await client.hVals('myhash')
console.log(res13) // [ 'Hello', 'World' ]
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]
const res17 = await client.hSet('myhash', 'field1', 'Hello')
console.log(res17) // 1
const res18 = await client.hSet('myhash', 'field2', 'World')
console.log(res18) // 1
const res19 = await client.hLen('myhash')
console.log(res19) // 2
await client.close();
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]
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]
// `hset` returns 1 because `field1` is a new field.
long hLenResult1 = jedis.hset("myhash", "field1", "Hello");
System.out.println(hLenResult1); // >>> 1
// `hset` returns 1 because `field2` is also a new field.
long hLenResult2 = jedis.hset("myhash", "field2", "World");
System.out.println(hLenResult2); // >>> 1
long hLenResult3 = jedis.hlen("myhash");
System.out.println(hLenResult3); // >>> 2
jedis.close();
}
}
Map<String, String> hValsFields = new HashMap<>();
hValsFields.put("field1", "Hello");
hValsFields.put("field2", "World");
syncCommands.hset("myhash", hValsFields);
// The order of the values isn't guaranteed, so sort them before
// printing.
List<String> res15 = syncCommands.hvals("myhash");
List<String> sortedValues = new ArrayList<>(res15);
Collections.sort(sortedValues);
System.out.println(sortedValues); // >>> [Hello, World]
package io.redis.examples.sync;
import io.lettuce.core.*;
import io.lettuce.core.api.sync.RedisCommands;
import io.lettuce.core.api.StatefulRedisConnection;
import java.util.*;
public class CmdsHashExample {
public void run() {
RedisClient redisClient = RedisClient.create("redis://localhost:6379");
try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {
RedisCommands<String, String> syncCommands = connection.sync();
// `hset` returns true because `field1` is a new field.
boolean res1 = syncCommands.hset("myhash", "field1", "foo");
System.out.println(res1); // >>> true
Long res2 = syncCommands.hdel("myhash", "field1");
System.out.println(res2); // >>> 1
// `hdel` returns 0 because `field2` doesn't exist.
Long res3 = syncCommands.hdel("myhash", "field2");
System.out.println(res3); // >>> 0
// `hset` returns true because `field1` is a new field.
boolean res4 = syncCommands.hset("myhash", "field1", "Hello");
System.out.println(res4); // >>> true
String res5 = syncCommands.hget("myhash", "field1");
System.out.println(res5); // >>> Hello
// The `Map` overload of `hset` returns the number of new fields.
Map<String, String> newFields = new HashMap<>();
newFields.put("field2", "Hi");
newFields.put("field3", "World");
Long res6 = syncCommands.hset("myhash", newFields);
System.out.println(res6); // >>> 2
String res7 = syncCommands.hget("myhash", "field2");
System.out.println(res7); // >>> Hi
String res8 = syncCommands.hget("myhash", "field3");
System.out.println(res8); // >>> World
// `hgetall` returns a `Map`, whose iteration order isn't
// guaranteed. Wrap it in a `TreeMap` to sort the fields by name.
Map<String, String> res9 = syncCommands.hgetall("myhash");
System.out.println(new TreeMap<>(res9));
// >>> {field1=Hello, field2=Hi, field3=World}
// `hset` returns true because `field1` is a new field.
boolean res10 = syncCommands.hset("myhash", "field1", "foo");
System.out.println(res10); // >>> true
String res11 = syncCommands.hget("myhash", "field1");
System.out.println(res11); // >>> foo
// `hget` returns null because `field2` doesn't exist.
String res12 = syncCommands.hget("myhash", "field2");
System.out.println(res12); // >>> null
Map<String, String> hmgetFields = new HashMap<>();
hmgetFields.put("field1", "Hello");
hmgetFields.put("field2", "World");
syncCommands.hset("myhash", hmgetFields);
// `hmget` returns a `KeyValue` for each field you ask for, in the
// order you asked for them. A field that doesn't exist comes back
// as an empty `KeyValue`.
List<KeyValue<String, String>> res13 = syncCommands.hmget("myhash", "field1", "field2", "nofield");
System.out.println(res13);
// >>> [KeyValue[field1, Hello], KeyValue[field2, World], KeyValue[nofield].empty]
Map<String, String> hGetAllFields = new HashMap<>();
hGetAllFields.put("field1", "Hello");
hGetAllFields.put("field2", "World");
syncCommands.hset("myhash", hGetAllFields);
// `hgetall` returns a `Map`, whose iteration order isn't
// guaranteed. Wrap it in a `TreeMap` to sort the fields by name.
Map<String, String> res14 = syncCommands.hgetall("myhash");
System.out.println(new TreeMap<>(res14));
// >>> {field1=Hello, field2=World}
Map<String, String> hValsFields = new HashMap<>();
hValsFields.put("field1", "Hello");
hValsFields.put("field2", "World");
syncCommands.hset("myhash", hValsFields);
// The order of the values isn't guaranteed, so sort them before
// printing.
List<String> res15 = syncCommands.hvals("myhash");
List<String> sortedValues = new ArrayList<>(res15);
Collections.sort(sortedValues);
System.out.println(sortedValues); // >>> [Hello, World]
// Set up a hash with two fields.
Map<String, String> hExpireFields = new HashMap<>();
hExpireFields.put("field1", "Hello");
hExpireFields.put("field2", "World");
syncCommands.hset("myhash", hExpireFields);
// Set the expiration of both fields. `hexpire` returns a status
// code for each field, where 1 means the expiration was set.
List<Long> res16 = syncCommands.hexpire("myhash", 10, "field1", "field2");
System.out.println(res16); // >>> [1, 1]
// Check the time to live of the fields.
List<Long> res17 = syncCommands.httl("myhash", "field1", "field2");
System.out.println(res17); // >>> [10, 10]
// Try to set the expiration of a field that doesn't exist.
// The status code -2 means there's no such field.
List<Long> res18 = syncCommands.hexpire("myhash", 10, "nonexistent");
System.out.println(res18); // >>> [-2]
// `hset` returns true because `field1` is a new field.
boolean res19 = syncCommands.hset("myhash", "field1", "Hello");
System.out.println(res19); // >>> true
// `hset` returns true because `field2` is also a new field.
boolean res20 = syncCommands.hset("myhash", "field2", "World");
System.out.println(res20); // >>> true
Long res21 = syncCommands.hlen("myhash");
System.out.println(res21); // >>> 2
} finally {
redisClient.shutdown();
}
}
}
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();
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].empty]
}).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();
CompletableFuture<Void> hLenExample = asyncCommands.hset("myhash", "field1", "Hello").thenCompose(res1 -> {
// `hset` returns true because `field1` is a new field.
System.out.println(res1); // >>> true
return asyncCommands.hset("myhash", "field2", "World");
}).thenCompose(res2 -> {
// `hset` returns true because `field2` is also a new field.
System.out.println(res2); // >>> true
return asyncCommands.hlen("myhash");
}).thenAccept(res3 -> {
System.out.println(res3); // >>> 2
}).toCompletableFuture();
hLenExample.join();
} finally {
redisClient.shutdown();
}
}
}
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]
});
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].empty
});
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();
Mono<Boolean> hLenExample1 = reactiveCommands.hset("myhash", "field1", "Hello").doOnNext(result -> {
System.out.println(result); // >>> true
});
hLenExample1.block();
Mono<Boolean> hLenExample2 = reactiveCommands.hset("myhash", "field2", "World").doOnNext(result -> {
System.out.println(result); // >>> true
});
hLenExample2.block();
Mono<Long> hLenExample3 = reactiveCommands.hlen("myhash").doOnNext(result -> {
System.out.println(result); // >>> 2
});
hLenExample3.block();
} finally {
redisClient.shutdown();
}
}
}
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]
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")
}
func ExampleClient_hlen() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password
DB: 0, // use default DB
})
hlen1, err := rdb.HSet(ctx, "myhash", "field1", "Hello").Result()
if err != nil {
panic(err)
}
fmt.Println(hlen1) // >>> 1
hlen2, err := rdb.HSet(ctx, "myhash", "field2", "World").Result()
if err != nil {
panic(err)
}
fmt.Println(hlen2) // >>> 1
hlen3, err := rdb.HLen(ctx, "myhash").Result()
if err != nil {
panic(err)
}
fmt.Println(hlen3) // >>> 2
}
db.HashSet("myhash",
[
new("field1", "Hello"),
new("field2", "World")
]
);
RedisValue[] hValsResult = db.HashValues("myhash");
Array.Sort(hValsResult);
Console.WriteLine(string.Join(", ", hValsResult));
// >>> Hello, World
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
bool hlenRes1 = db.HashSet("myhash", "field1", "Hello");
Console.WriteLine(hlenRes1); // >>> True
bool hlenRes2 = db.HashSet("myhash", "field2", "World");
Console.WriteLine(hlenRes2); // >>> True
long hlenRes3 = db.HashLength("myhash");
Console.WriteLine(hlenRes3); // >>> 2
}
}
$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"]
<?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]
$hLenResult1 = $this->redis->hset('myhash', 'field1', 'Hello');
echo "HSET myhash field1 Hello: " . $hLenResult1 . "\n"; // >>> 1
$hLenResult2 = $this->redis->hset('myhash', 'field2', 'World');
echo "HSET myhash field2 World: " . $hLenResult2 . "\n"; // >>> 1
$hLenResult3 = $this->redis->hlen('myhash');
echo "HLEN myhash: " . $hLenResult3 . "\n"; // >>> 2
}
protected function tearDown(): void
{
// Clean up after each test
$this->redis->flushall();
$this->redis->disconnect();
}
}
r.hset('myhash', { 'field1' => 'Hello', 'field2' => 'World' })
res15 = r.hvals('myhash')
puts res15.inspect # >>> ["Hello", "World"]
require 'redis'
r = Redis.new
res1 = r.hset('myhash', 'field1', 'foo')
puts res1 # >>> 1
res2 = r.hdel('myhash', 'field1')
puts res2 # >>> 1
res3 = r.hdel('myhash', 'field2')
puts res3 # >>> 0
res4 = r.hset('myhash', 'field1', 'Hello')
puts res4 # >>> 1
res5 = r.hget('myhash', 'field1')
puts res5 # >>> Hello
res6 = r.hset('myhash', { 'field2' => 'Hi', 'field3' => 'World' })
puts res6 # >>> 2
res7 = r.hget('myhash', 'field2')
puts res7 # >>> Hi
res8 = r.hget('myhash', 'field3')
puts res8 # >>> World
res9 = r.hgetall('myhash')
puts res9.inspect
# >>> {"field1"=>"Hello", "field2"=>"Hi", "field3"=>"World"}
res10 = r.hset('myhash', 'field1', 'foo')
puts res10 # >>> 1
res11 = r.hget('myhash', 'field1')
puts res11 # >>> foo
res12 = r.hget('myhash', 'field2')
puts res12.inspect # >>> nil
r.hset('myhash', { 'field1' => 'Hello', 'field2' => 'World' })
res13 = r.hmget('myhash', 'field1', 'field2', 'nofield')
puts res13.inspect # >>> ["Hello", "World", nil]
r.hset('myhash', { 'field1' => 'Hello', 'field2' => 'World' })
res14 = r.hgetall('myhash')
puts res14.inspect # >>> {"field1"=>"Hello", "field2"=>"World"}
r.hset('myhash', { 'field1' => 'Hello', 'field2' => 'World' })
res15 = r.hvals('myhash')
puts res15.inspect # >>> ["Hello", "World"]
# Set up a hash with two fields.
r.hset('myhash', { 'field1' => 'Hello', 'field2' => 'World' })
# Set an expiration on both fields.
res16 = r.hexpire('myhash', 10, 'field1', 'field2')
puts res16.inspect # >>> [1, 1]
# Check the TTL of the fields.
res17 = r.httl('myhash', 'field1', 'field2')
puts res17.inspect # >>> [10, 10]
# Try to set an expiration on a field that does not exist.
res18 = r.hexpire('myhash', 10, 'nonexistent')
puts res18.inspect # >>> [-2]
res19 = r.hset('myhash', 'field1', 'Hello')
puts res19 # >>> 1
res20 = r.hset('myhash', 'field2', 'World')
puts res20 # >>> 1
res21 = r.hlen('myhash')
puts res21 # >>> 2
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;
}
}
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", "Hello") {
Ok(hlen1) => {
let hlen1: i32 = hlen1;
println!("{hlen1}"); // >>> 1
},
Err(e) => {
println!("Error setting hash field: {e}");
return;
}
}
match r.hset("myhash", "field2", "World") {
Ok(hlen2) => {
let hlen2: i32 = hlen2;
println!("{hlen2}"); // >>> 1
},
Err(e) => {
println!("Error setting hash field: {e}");
return;
}
}
match r.hlen("myhash") {
Ok(hlen3) => {
let hlen3: usize = hlen3;
println!("{hlen3}"); // >>> 2
},
Err(e) => {
println!("Error getting hash length: {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;
}
}
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;
}
}
match r.hset("myhash", "field1", "Hello").await {
Ok(res15) => {
let res15: i32 = res15;
println!("{res15}"); // >>> 1
},
Err(e) => {
println!("Error setting hash field: {e}");
return;
}
}
match r.hset("myhash", "field2", "World").await {
Ok(res16) => {
let res16: i32 = res16;
println!("{res16}"); // >>> 1
},
Err(e) => {
println!("Error setting hash field: {e}");
return;
}
}
match r.hlen("myhash").await {
Ok(res17) => {
let res17: usize = res17;
println!("{res17}"); // >>> 2
},
Err(e) => {
println!("Error getting hash length: {e}");
return;
}
}
}
}
Redis Software and Redis Cloud compatibility
| Redis Software |
Redis Cloud |
Notes |
|---|---|---|
| ✅ Standard |
✅ Standard |
Return information
Array reply: a list of values in the hash, or an empty list when the key does not exist