redis-plus-plus常用函数介绍以及redis的一些边缘知识

news2024/11/28 14:30:14

文章目录

    • 渐进式遍历
    • scan
    • 数据库管理
    • 使用C++调用redis
      • 安装redis-plus-plus
    • get, set, exists , del, keys
    • expire, type
    • string的set, mset, mget
    • getrange, setrange
    • incr, decr
    • lpush, lrange,
    • lpop, rpop
    • blpop, llen
    • sadd, smembers
    • sismember, scard
    • sinter, sinterstore
    • hset, hget, hexists, hdel, hmget
    • zadd, zrange
    • zrem, zsocre, zrank

渐进式遍历

keys能够通过通配符匹配规则，将redis中所有符合条件的key筛选出来

keys pattern

但是这个命令很危险，若redis中的数据很多，导致keys的执行时间过长。由于redis是单线程，所以keys大概率将引起阻塞

通过渐进式遍历，就可以做到在保证服务器不阻塞的情况下，获取所有的key
渐进式遍历不是一次新地将所有key拿到，而是每执行一次命令，只获取其中一部分的key。这样就保证了每次操作不会阻塞服务器，要想获取所有的key，需要多次执行渐进式遍历

渐进式遍历其实是一组命令，这些命令的使用方法是一样的，其中的代表命令为scan

scan

scan cursor [pattern] [COUNT count] [TYPE type]

cursor：光标，执行当前遍历的位置，为0表示从头开始遍历。不能将其理解为下标，它只是一个字符串
count：限制这次的遍历要获取的元素数量，默认是10。和MySQL的limit不一样，count只是一个建议，返回结果的数量并不一定和count相同，只是和count差不多
type：根据key对应的value类型进行进一步的筛选
返回值分两部分：一部分为提示，下一次遍历时光标要从哪开始
一部分为遍历到的具体内容

当前已有的key
image.png

输入scan 0
image.png
7为下次遍历时，需要指定的光标位置，剩下的数据为遍历到的元素

当scan返回空集合或者光标为0，说明遍历结束
image.png
指定count参数为5，返回了6个结果
image.png

scan可以随时终止，不会对服务器产生任何副作用
若执行scan的过程中，key发生了变化（增加，删除），那么scan可能会出现遗漏或重复

数据库管理

MySQL中，可以创建多个数据库database。而在redis中，只能使用现成的（已经存在的）数据库，无法删除/创建数据库。redis提供了16个数据库（0~15），并且默认使用的是0号数据库
通过

select index

index为0~15，选择数据库
实际使用中很少切换数据库，一般都是直接使用0号数据库

获取当前数据库下的key数量：

dbsize

删除当前数据库中的所有key

flushdb

删除所有数据库中的所有key

flushall

使用C++调用redis

redis自定义了一个通信协议：RESP（redis serialization protocol）
要实现一个自定义客户端，就必须清楚服务端使用的协议。由于redis将协议的内容公开，所以我们能实现自己的redis客户端

RESP协议
优点：

  1. 简单好实现
  2. 快速进行解析
  3. 可读性高
    传输层基于TCP，但是与TCP没有强耦合关系
    请求和相应之间的通信模型是一问一答的
    客户端以bulk string数组的形式将命令发送给服务器，不同的命令返回结果不一样

服务端返回的数据：

  • 对于简单字符串（Simple String），第一个字节为"+"
  • 对于错误（Errors），第一个字节为"-"
  • 对于整数（Integers），第一个字节为":"
  • 对于Bulk String，第一个字节为"$"
  • 对于数组（Arrays），第一个字节为"*"

Bulk String和Simple String的区别，Bulk String可以用于传输二进制数据，因为其实现了二进制安全，而Simple String只能用于传输简单字符串

这些协议的序列化与反序列化已经有第三方库实现，我们不需要手动实现

安装redis-plus-plus

安装hiredis：

apt install -y libhiredis-dev

通过源码编译安装redis-plus-plus
下载源码：

git clone https://github.com/sewenew/redis-plus-plus.git

进入目录：

cd redis-plus-plus/

创建目录并进入：

mkdir build
cd build

安装cmake：

apt install -y cmake

执行：

cmake ..

最后安装：

make         # 编译生成动静态库
make install # 将动静态库拷贝到系统目录中

安装完成后，在/usr/local/include目录下会出现sw目录，存储了redis的头文件
/usr/local/lib目录下也存储了redis的库文件

ls /usr/local/include/sw
ls /usr/local/lib | grep redis

image.png
使用find命令查找相关文件也可以

find / -name "redis*"
find / -name "libredis*"

编写demo连接redis服务器，使用ping命令检测连通性

#include <iostream>
#include <string>
#include <sw/redis++/redis++.h> // 包含redis头文件
using std::cout;
using std::cin;
using std::endl;

int main()
{
	// 创建Redis对象时，需要指定redis服务的IP和端口
	// 字符串为一个url，RESP协议是基于TCP应用层协议
	sw::redis::Redis redis("tcp://127.0.0.1:6379"); 
	std::string res = redis.ping();
	cout << res << "\n";
	return 0;
}

要想与redis进行交互，就要初始化一个sw::redis::Redis对象，在redis命令行中输入的命令都能通过sw::redis::Redis进行发送。其中sw::redis是一个命名空间，其中定义了很多redis相关的类和方法
需要将一个url作为构造函数的参数传入，比如：“tcp://127.0.0.1:6379”，这个url中，tcp表示用tcp协议进行通信（redis是基于tcp的），127.0.0.1表示redis服务所在的IP地址，6379表示redis服务所在的端口号
redis.ping()等价于在redis命令行中输入ping，由于这个命令返回一个字符串，用string将其接收并打印

编写makefile文件，需要将使用到的动态库放到编译指令中（hiredis, redis++, pthread）

demo:demo.cc
	g++ -o $@ $^ -std=c++17 -lpthread -lhiredis -lredis++

.PHONY:clean
clean:
	rm -rf demo

配置系统文件，使链接器能找到hiredis的动态库，其他动态库已经位于系统路径下

cd /etc/ld.so.conf.d

创建配置文件，将find / -name libhiredis*返回的目录写入配置文件中
image.png
写入动态库所在目录即可

vim redis.conf

image.png
执行

sudo ldconcig

此时配置完成
执行demo返回PONG说明redis-plus-plus安装完成
image.png

get, set, exists , del, keys

set：

void set(const sw::redis::StringView &key, const sw::redis::StringView &val);

其中StringView是sw::redis中定义的一个只读字符串（相比于普通字符串，StringView做了更多的优化），以字符串的形式传入key和value的值即可，如redis.set("k1", "111");

get：

sw::redis::OptionalString get(const sw::redis::StringView &key)

将key以字符串的形式传入，get将返回key对应的value值。返回值为sw::redis::OptionalString，该类重载了bool，若key不存在，那么OptionalString的bool值为false。若key存在，那么OptionalString的bool值为true
由于该类没有重载<<运算符，所以不能直接输出，但该类的value()方法可以以字符串的方式返回value值，value()的返回值可以直接输出

// get set的使用
void test1(sw::redis::Redis& redis)
{
	redis.flushall(); // 清空当前数据库，慎用

	redis.set("k1", "111");
	redis.set("k2", "222");
	redis.set("k3", "333");

	auto v1 = redis.get("k1");
	if (v1) cout << "k1-" << v1.value() << "\n";

	auto v2 = redis.get("k2");
	if (v2) cout << "k2-" << v2.value() << "\n";

	auto v3 = redis.get("k3");
	if (v3) cout << "k3-" << v3.value() << "\n";

	auto v4 = redis.get("k4");
	if (v4) cout << "k4-" << v4.value() << "\n";
}

image.png

exists：

long long exists(const sw::redis::StringView &key);

以字符串的方式传入key，exists将返回存在的key的数量
用初始化列表存储多个字符串，并将初始化列表作为参数传入，就能询问这些key是否在数据库中存在

void test2(sw::redis::Redis& redis)
{
	redis.flushall();
	redis.set("k1", "111");
	redis.set("k2", "222");
	redis.set("k3", "333");

	auto t = redis.exists("k1");
	cout << "k1:" << t << "\n";

	t = redis.exists({"k1", "k2", "k3"});
	cout << "k1, k2, k3:" << t << "\n";

	t = redis.exists("t4");
	cout << "k4:" << t << "\n";
}

image.png

del和exists的使用相同，参数一样，也能使用初始化列表作为参数删除多个key，返回值为成功删除的元素数量

void test3(sw::redis::Redis& redis)
{
	redis.flushall();
	redis.set("k1", "111");
	redis.set("k2", "222");
	redis.set("k3", "333");

	auto t = redis.exists({"k1", "k2", "k3"});
	cout << "k1, k2, k3:" << t << "\n";
	redis.del("k2");
	t = redis.del({"k1", "k2", "k3"});
	cout << "del->k1, k2, k3:" << t << "\n";

	t = redis.exists({"k1", "k2", "k3"});
	cout << "k1, k2, k3:" << t << "\n";
}

image.png

keys：

void Redis::keys(const StringView &pattern, Output output)

key的第一个参数为字符串形式的规则表达式，用来匹配key
keys的第二个参数为一个插入迭代器，我们需要先创建一个存储结果的容器，再创建一个指向该容器的插入迭代器，将其作为keys的第二个参数，keys的返回结果将保存到之前创建的容器中
STL中有五种迭代器：

  1. 输入迭代器（只读）
  2. 输出迭代器（可写）
  3. 前向迭代器
  4. 双向迭代器
  5. 随机访问迭代器

插入迭代器属于一种输出迭代器（用来将数据输出），有三种插入迭代器

  1. front_insert_iterator（将数据输出到容器的开头）
  2. back_insert_iterator（将数据输出到容器的末尾）
  3. insert_iterator（将数据输出到容器的任意位置，指向位置之前）

每种迭代器都有相应的方法，调用这些方法以构造相应的迭代器
如back_inserter()，将容器作为参数传入，该方法返回相应的迭代器
使用：

vector<string> res;
auto it = std::back_inserter(res);

template <class T>
void printContainer(const T& container)
{
    for (const auto& elem : container)
    {
        cout << elem << "\n";
    }
}

void test4(sw::redis::Redis& redis)
{
	redis.flushall();
	redis.set("k1", "111");
	redis.set("k2", "222");
	redis.set("k3", "333");
	redis.set("k4", "444");
	redis.set("k5", "555");
	redis.set("k6", "666");

	vector<string> res;
	auto it = std::back_inserter(res);
	redis.keys("*", it);
	printContainer(res);
}

image.png

expire, type

expire

bool Redis::expire(const StringView &key, const std::chrono::seconds &timeout)

以字符串的形式将key作为第一个参数，将时间作为第二个参数

#include <chrono>
using namespace std::chrono_literals;

引入头文件和声明命名空间：C++11之后，支持了更多的字面值，如3s，7min，以及h, ms, us, ns。这些字面值可以提高程序的可读性
expire的第二个参数就可以使用7s这样的字面值，前提是引入头文件和声明命名空间

ttl：

long long sw::redis::Redis::ttl(const sw::redis::StringView &key)

ttl返回long long表示key的剩余存活时间

void test5(sw::redis::Redis& redis)
{
	using namespace std::chrono_literals;
	redis.flushall();
	redis.set("k1", "111");

	redis.expire("k1", 7s);
	std::this_thread::sleep_for(3s); // 线程休眠3s

	auto time = redis.ttl("k1");
	cout << "k1:" << time << "s" << "\n";
}

image.png

type：

std::string sw::redis::Redis::type(const sw::redis::StringView &key)

返回key所属的类型，返回值是类型是std::string

void test6(sw::redis::Redis& redis)
{
	redis.flushall();
	redis.set("k1", "111");
	redis.lpush("k2", "222");

	auto res = redis.type("k1");
	cout << "k1:" << res << "\n";

	res = redis.type("k2");
	cout << "k2:" << res << "\n";
}

image.png

string的set, mset, mget

超时设置与NX|XX

redis.set("k1", "111", 5s, sw::redis::UpdateType::EXIST)

第三个参数为超时时间，引入了chrono头文件并使用命名空间std::chrono_literals后，即可使用这样的字面值
第四个参数有两个可选项：sw::redis::UpdateType::NOT_EXIST和sw::redis::UpdateType::EXIST。分别对应着NX和XX模式，即只创建与只更新两种模式

若不想使用第三个参数，但是要使用第四个参数，将第三个参数设置为0s即可

mset：

// 第一种方法
redis.mset({std::make_pair("k1", "111"), std::make_pair("k2", "222")});

// 第二种方法
vector<std::pair<string, string>> keys = {
	{"k1", "111"},
	{"k2", "222"},
	{"k3", "333"}
};
redis.mset(keys.begin(), keys.end());

第一种方法：直接用初始化列表存储多个pair，将初始化列表作为参数传入
第二种方法：将多个键值对保存到容器中，将容器的头尾迭代器传入

mget的使用和keys类似，需要先创建一个保存结果的容器，再创建一个指向该容器的插入迭代器并将该容器传入
至于说mget的第一个参数，用初始化列表存储要查询的key即可，具体见demo

void test1(sw::redis::Redis& redis)
{
    redis.flushall();
    // mset的第一种使用方法
	redis.mset({std::make_pair("k1", "111"), std::make_pair("k2", "222")});
	// mset的第二种使用方法
    vector<std::pair<string, string>> keys = {
		{"k1", "111"},
		{"k2", "222"},
		{"k3", "333"}
	};
	redis.mset(keys.begin(), keys.end());
	
	vector<sw::redis::OptionalString> res;
	auto it = std::back_inserter(res); 
	redis.mget({"k1", "k2", "k3"}, it);
	
	printContainerOptional(res);
}

image.png

getrange, setrange

getrange

std::string sw::redis::Redis::getrange(const sw::redis::StringView &key, long long start, long long end)

传入key与一个闭区间的左右端点，getrange将返回key对应value的子字符串。若区间方法，将返回空字符串

void test2(sw::redis::Redis& redis)
{
    redis.flushall();
	redis.set("k1", "helloworld");
	string res = redis.getrange("k1", 3, 7);
	cout << "helloworld(3, 7):" << res << "\n";
}

image.png

setrange

long long setrange(const sw::redis::StringView &key, long long offset, const sw::redis::StringView &val)

将key对应的value，从offset个字符开始往后替换为val字符串

void test2(sw::redis::Redis& redis)
{
    redis.flushall();
	redis.set("k1", "helloworld");
	string res = redis.getrange("k1", 3, 7);
	cout << "helloworld(3, 7):" << res << "\n";

	redis.setrange("k1", 3, "xxxxx");
	auto val = redis.get("k1");
	cout << val.value() << "\n";
}

image.png

incr, decr

long long sw::redis::Redis::incr(const sw::redis::StringView &key)

将传入的key对应的value值自增1，并且返回自增后的结果，类型为long long
如果用get获取其value，那么其类型为OptionalString，需要调用其value方法并将字符串转换成整数才能使用
所以要使用incr的结果，推荐接收incr的返回值

void test3(sw::redis::Redis& redis)
{
    redis.flushall();
	redis.set("k1", "2");
	auto res = redis.incr("k1");
	cout << res << "\n";

	res = redis.decr("k1");
	cout << res << "\n";
}

image.png

lpush, lrange,

lpush：指定要插入的key，可以插入一个/多个key
插入多个key时，可以通过初始化列表也可以通过迭代器的方式进行

long long lpush(const sw::redis::StringView &key, const sw::redis::StringView &val)
long long lpush<T>(const sw::redis::StringView &key, std::initializer_list<T> il)
long long lpush<Input>(const sw::redis::StringView &key, Input first, Input last)

lrange：

void lrange<Output>(const sw::redis::StringView &key, long long start, long long stop, Output output)

lrange获取list中指定范围内的元素，参数和命令行相同，只是需要添加一个插入迭代器以保存多个元素

void test1(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.lpush("k1", "111");
    redis.lpush("k1", "222");
    vector<string> data = {"333", "444", "555"};
    redis.lpush("k1", data.begin(), data.end());

    vector<string> res;
    auto it = back_inserter(res);
    redis.lrange("k1", 0, -1, it);
    printContainer(res);
}

image.png

lpop, rpop

lpop：
将key对应list的头部元素删除并返回，返回类型为OptionalString，需要判断其bool值是否为真，再调用其value方法，输出被删除的值

sw::redis::OptionalString lpop(const sw::redis::StringView &key)

void test1(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.lpush("k1", "111");
    redis.lpush("k1", "222");
    vector<string> data = {"333", "444", "555"};
    redis.lpush("k1", data.begin(), data.end());
    vector<string> res;
    auto it = back_inserter(res);
    redis.lrange("k1", 0, -1, it);
    printContainer(res);

    auto t = redis.lpop("k1");
    if (t) cout << "pop:" << t.value() << "\n";
}

image.png

blpop, llen

阻塞版本的头删除，可以用第二个参数设置阻塞时间，默认为0秒
第一个参数可以是一个key，也可以是多个key（初始化列表或者迭代器），但是只会删除第一个有数据key

sw::redis::OptionalStringPair blpop(const sw::redis::StringView &key, const std::chrono::seconds &timeout = std::chrono::seconds{0})

返回类型为OptionalStringPair，可以理解为pair<string, string>，第一个元素为被删除元素所属key，第二个元素为被删除元素
假设有一个OptionalStringPair对象v，获取第一个参数v.value().first，或者v->first，该类重载了->运算符，可以通过->直接获取参数值

void test1(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.lpush("k1", "111");
    redis.lpush("k1", "222");
    vector<string> data = {"333", "444", "555"};
    redis.lpush("k1", data.begin(), data.end());
    vector<string> res;
    auto it = back_inserter(res);
    redis.lrange("k1", 0, -1, it);
    printContainer(res);

    auto t = redis.lpop("k1");
    if (t) cout << "pop:" << t.value() << "\n";

    auto v = redis.blpop("k1", 10s);
    if (v) cout << "key:" << v->first << " val:" << v.value().second << "\n";
}

image.png

llen：返回指定key的长度，类型为long long

long long llen(const sw::redis::StringView &key)

void test1(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.lpush("k1", "111");
    redis.lpush("k1", "222");
    vector<string> data = {"333", "444", "555"};
    redis.lpush("k1", data.begin(), data.end());
    vector<string> res;
    auto it = back_inserter(res);
    redis.lrange("k1", 0, -1, it);
    printContainer(res);

    auto t = redis.lpop("k1");
    if (t) cout << "pop:" << t.value() << "\n";

    auto v = redis.blpop("k1", 10s);
    if (v) cout << "key:" << v->first << " val:" << v.value().second << "\n";
    
    cout << "len:" << redis.llen("k1") << "\n";
}

image.png

sadd, smembers

sadd同样支持一次插入一个/多个元素，方法与之前的函数类型，这里不再赘述
smembers：

void smembers<Output>(const sw::redis::StringView &key, Output output)

指定要获取的key，该函数将value值保存到插入迭代器指向的容器中，和之前的获取函数的使用类似

void test2(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.sadd("k1", {"111", "222", "333"});

    std::set<string> res;
    auto it = inserter(res, res.begin());
    redis.smembers("k1", it);
    printContainer(res);
}

image.png

sismember, scard

sismember：

bool sismember(const sw::redis::StringView &key, const sw::redis::StringView &member)

函数返回一个bool，表示member是否为key的元素

void test2(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.sadd("k1", {"111", "222", "333"});

    std::set<string> res;
    auto it = inserter(res, res.begin());
    redis.smembers("k1", it);
    printContainer(res);

    cout << "111 is k1 member? :" << redis.sismember("k1", "111") << "\n";
}

image.png

scard：获取set中的元素个数

long long scard(const sw::redis::StringView &key)

void test2(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.sadd("k1", {"111", "222", "333"});

    std::set<string> res;
    auto it = inserter(res, res.begin());
    redis.smembers("k1", it);
    printContainer(res);

    cout << "111 is k1 member? :" << redis.sismember("k1", "111") << "\n";
    cout << "scard:" << redis.scard("k1") << "\n";
}

image.png

spop：

sw::redis::OptionalString spop(const sw::redis::StringView &key)

void test2(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.sadd("k1", {"111", "222", "333"});

    std::set<string> res;
    auto it = inserter(res, res.begin());
    redis.smembers("k1", it);
    printContainer(res);

    cout << "111 is k1 member? :" << redis.sismember("k1", "111") << "\n";
    cout << "scard:" << redis.scard("k1") << "\n";
    auto t = redis.spop("k1");
    if (t) cout << "spop:" << t.value() << "\n";
}

image.png

sinter, sinterstore

sinter：

void sinter<T, Output>(std::initializer_list<T> il, Output output)

初始化列表表示用求并集的key，output为保存并集的插入迭代器

void test3(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.sadd("k1", {"111", "222", "333"});
    redis.sadd("k2", {"222", "333", "444"});

    std::set<string> res;
    auto it = inserter(res, res.begin());
    redis.sinter({"k1", "k2"}, it);
    printContainer(res);
}

image.png

sinterstore：

long long sinterstore<T>(const sw::redis::StringView &destination, std::initializer_list<T> il)

第一个参数为存储并集的key，第二个参数为求哪些集合并集

void test3(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.sadd("k1", {"111", "222", "333"});
    redis.sadd("k2", {"222", "333", "444"});

    std::set<string> res;
    auto it = inserter(res, res.begin());
    redis.sinter({"k1", "k2"}, it);
    printContainer(res);

    redis.sinterstore("k3", {"k1", "k2"});
    std::set<string> t;
    it = inserter(t, t.begin());
    redis.smembers("k3", it);
    printContainer(t);
}

image.png

hset, hget, hexists, hdel, hmget

hset：

long long hset(const sw::redis::StringView &key, const sw::redis::StringView &field, const sw::redis::StringView &val)
long long hset(const sw::redis::StringView &key, const std::pair<sw::redis::StringView, sw::redis::StringView> &item)
long long hset<T>(const sw::redis::StringView &key, std::initializer_list<T> il)
long long hset<Input>(const sw::redis::StringView &key, Input first, Input last)

支持一次插入一个/多个元素，由于hash存储的是field和value，所以初始化列表中的元素需要为pair，容器中的元素也需要为pair

hget：获取key的field对应的value

sw::redis::OptionalString hget(const sw::redis::StringView &key, const sw::redis::StringView &field)

void test4(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.hset("k1", {std::make_pair("kk1", "111"), std::make_pair("kk2", "222")});
    auto res = redis.hget("k1", "kk1");
    if (res) cout << res.value() << "\n";
}

image.png

hexists：判断key的field是否存在

bool hexists(const sw::redis::StringView &key, const sw::redis::StringView &field)

void test4(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.hset("k1", {std::make_pair("kk1", "111"), std::make_pair("kk2", "222")});
    auto res = redis.hget("k1", "kk1");
    if (res) cout << res.value() << "\n";
    cout << "k1的kk2是否存在? :" << redis.hexists("k1", "kk2") << "\n";
}

image.png

hdel：

long long hdel(const sw::redis::StringView &key, const sw::redis::StringView &field)
long long hdel<T>(const sw::redis::StringView &key, std::initializer_list<T> il)
long long hdel<Input>(const sw::redis::StringView &key, Input first, Input last)

支持一次删除一个/多个key的field，返回值为成功删除的field数量

hkeys：获取key下的fields

void hkeys<Output>(const sw::redis::StringView &key, Output output)

hvals：获取key下的values

void hvals<Output>(const sw::redis::StringView &key, Output output)

void test5(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.hset("k1", {
        std::make_pair("kk1", "111"), 
        std::make_pair("kk2", "222"),
        std::make_pair("kk3", "333"),
        std::make_pair("kk4", "444"),
        });

    vector<string> keyres;
    auto it = back_inserter(keyres);
    redis.hkeys("k1", it);
    cout << "keys:\n";
    printContainer(keyres);

    vector<string> valres;
    it = back_inserter(valres);
    redis.hvals("k1", it);
    cout << "vals:\n";
    printContainer(valres);
}

image.png

hget只支持获取单个key下field对应的value
而hmget支持获取一个/多个key下field对应的value

void hmget<T, Output>(const sw::redis::StringView &key, std::initializer_list<T> il, Output output)
void hmget<Input, Output>(const sw::redis::StringView &key, Input first, Input last, Output output)

void test6(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.hset("k1", {
        std::make_pair("kk1", "111"), 
        std::make_pair("kk2", "222"),
        std::make_pair("kk3", "333"),
        std::make_pair("kk4", "444"),
        });

    vector<string> res;
    auto it = back_inserter(res);
    redis.hmget("k1", {"kk1", "kk2"}, it);
    printContainer(res);
}

image.png

zadd, zrange

zadd

long long zadd(const sw::redis::StringView &key, const sw::redis::StringView &member, double score)
long long zadd<T>(const sw::redis::StringView &key, std::initializer_list<T> il)
long long zadd<Input>(const sw::redis::StringView &key, Input first, Input last)

zadd支持一次向有序集合中添加一个/多个元素，添加多个元素时，元素的类型为pair<string, double>

zrange：
根据指定范围查询，可以只查询member，也可以查询member和score

void zrange<Output>(const sw::redis::StringView &key, long long start, long long stop, Output output)

若插入迭代器指向的容器类型为<string, double>，那么此时查询member和score
若插入迭代器指向的容器类型为string，那么此时查询member

void test7(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.zadd("k1", {
        std::make_pair("aa", "99"),
        std::make_pair("bb", "98"),
        std::make_pair("cc", "97")
    });

    vector<std::pair<string, double>> resms;
    auto itms = back_inserter(resms);

    vector<string> resm;
    auto itm = back_inserter(resm);
    
    redis.zrange("k1", 0, -1, itms);
    redis.zrange("k1", 0, -1, itm);

    cout << "只查询member:\n";
    for (auto t : resm) cout << t << "\n";
    cout << "查询member和score:\n";
    for (auto t : resms) cout << t.first << ' ' << t.second << "\n";
}

image.png

zrem, zsocre, zrank

zrem

long long zrem(const sw::redis::StringView &key, const sw::redis::StringView &member)
long long zrem<T>(const sw::redis::StringView &key, std::initializer_list<T> il)
long long zrem<Input>(const sw::redis::StringView &key, Input first, Input last)

支持一次删除key下的一个/多个member，返回成功删除的数量

zscore：返回key下member对应的score

sw::redis::OptionalDouble zscore(const sw::redis::StringView &key, const sw::redis::StringView &member)

sw::redis::OptionalLongLong zrank(const sw::redis::StringView &key, const sw::redis::StringView &member)

void test8(sw::redis::Redis& redis)
{
    redis.flushall();
    redis.zadd("k1", {
        std::make_pair("aa", "99"),
        std::make_pair("bb", "98"),
        std::make_pair("cc", "97")
    });

    auto res = redis.zscore("k1", "bb");
    if (res) cout << "zscore(k1.bb):" << res.value() << "\n";
    auto t = redis.zrank("k1", "bb");
    if (t) cout << "zrank(k1.bb)" << t.value() << "\n";
}

image.png

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1168657.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

创意无限，体验非凡——Cinema 4D 2024 Mac 版强势来袭

创意无限，体验非凡——Cinema 4D 2024 Mac 版强势来袭

尊贵的设计师们&#xff0c;艺术与技术的完美结合&#xff0c;正是我们对于设计行业的追求。而在这个追求中&#xff0c;Cinema 4D 2024 Mac 版的问世&#xff0c;必将成为您的得力助手&#xff0c;为您的创作之路注入无限的活力与灵感。 Cinema 4D 一直以来都是设计师们最爱用…
阅读更多...
导轨电表适不适合家用？

导轨电表适不适合家用？

导轨电表&#xff0c;作为一种新型的电能计量设备&#xff0c;近年来在我国得到了广泛的应用。然而&#xff0c;对于家用市场来说&#xff0c;导轨电表是否适用仍然存在争议。那么&#xff0c;导轨电表适不适合家用呢&#xff1f;接下来&#xff0c;小编来为大家讲解下&#xf…
阅读更多...
kaggle使用说明

kaggle使用说明

kaggle kaggle使用参考1、kaggle目录2、kaggle上传本地文件后&#xff0c;如何不改代码就可运行3、已上传文件的修改3.1 重新上传3.2 重写文件 4、创建文件夹5、结果下载5.1 多文件&#xff1a;先打包再下载5.2 重定文件下载链接 kaggle使用参考 Kaggle 新手入门必看&#xff…
阅读更多...
InetAddress.getLocalHost() 执行非常慢

InetAddress.getLocalHost() 执行非常慢

昨天同事反馈网关的请求非常慢&#xff0c;一个获取的token的接口响应都超过了30s&#xff0c;还好只是测试环境。 经过验证&#xff0c;几乎所有接口响应都很慢&#xff0c;很多都响应超时。 排查步骤&#xff1a; 0. 本地启动项目测试&#xff0c;没有这个问题。而且生产环…
阅读更多...
COCOS2DX3.17.2 Android升级targetSDK30问题解决方案

COCOS2DX3.17.2 Android升级targetSDK30问题解决方案

一、luajit不兼容问题 不兼容版本&#xff1a;【2.1.0-bate2、2.1.0-bate3都存在异常】 出问题系统&#xff1a;Android11&#xff1b;Android10的系统部分机型有问题&#xff0c;部分机型正常 异常点1&#xff1a;c调用lua接口&#xff0c;pushObjiect的时候crash 异常点2…
阅读更多...
Skywalking介绍

Skywalking介绍

一个优秀的项目&#xff0c;除了具有高拓展的架构、高性能的方案、高质量的代码之外&#xff0c;还应该在上线后具备多角度的监控功能。现在企业中的监控服务也有很多&#xff0c;Skywalking除了提供多维度、多粒度的监控之外&#xff0c;也提供了良好的图形化界面以及性能剖析…
阅读更多...
研究人员发现34个Windows驱动程序易受完全设备接管攻击

研究人员发现34个Windows驱动程序易受完全设备接管攻击

最近&#xff0c;研究人员发现了34个易受攻击的Windows驱动程序&#xff0c;这些漏洞可能被非特权威胁行为者利用来完全接管设备&#xff0c;并在底层系统上执行任意代码。这一发现引发了广泛关注&#xff0c;并引起了Windows用户的担忧。 导语 随着科技的不断进步&#xff0c;…
阅读更多...
【23真题】最难！两电一邮中最难的！

【23真题】最难！两电一邮中最难的！

今天分享的是23年西安电子科技大学821的信号与系统试题及解析。 本套试卷难度分析&#xff1a;22年西电811考研真题&#xff0c;我发布过&#xff0c;若有需要戳这里自取&#xff01;这里统计了811的上岸平均分为110-120分&#xff01;最高分为143分&#xff0c;该院校考察的是…
阅读更多...
06.Oracle数据备份与恢复

06.Oracle数据备份与恢复

Oracle数据备份与恢复 一、通过RMAN方式备份二、使用emp/imp和expdb/impdb工具进行备份和恢复三、使用Data guard进行备份与恢复 一、通过RMAN方式备份 通过 RMAN&#xff08;Oracle 数据库备份和恢复管理器&#xff09;方式备份 Oracle 数据库&#xff0c;可以使用以下步骤&a…
阅读更多...
dubbo没有找到生产者

dubbo没有找到生产者

1、没有找到生产者 com.alibaba.dubbo.rpc.RpcException: No provider available from registry 127.0.0.1:2181 for service .... , please check status of providers(disabled, not registered or in blacklist)2、 查看是不是 对应的providers 没有 注册上去 找到 zk 对应…
阅读更多...
每天五分钟计算机视觉：池化层的反向传播

每天五分钟计算机视觉：池化层的反向传播

本文重点 卷积神经网络（Convolutional Neural Network，CNN）作为一种强大的深度学习模型，在计算机视觉任务中取得了巨大成功。其中，池化层（Pooling Layer）在卷积层之后起到了信息压缩和特征提取的作用。然而，池化层的反向传播一直以来都是一个相对复杂和深奥的问题。本…
阅读更多...
【报错】错误 C1004 ：发现意外的文件尾

【报错】错误 C1004 ：发现意外的文件尾

文章目录 情景在现出错原因解决方案问题解决 情景在现 出错原因 这个错误通常是由于您在源文件中漏写了某些括号或者分号&#xff0c;导致编译器在处理到文件末尾时发现没有遇到预期的符号。 解决方案 解决这个错误的方法是&#xff0c;打开您的源文件&#xff0c;仔细检查是否…
阅读更多...
虾皮买家号批量注册软件

虾皮买家号批量注册软件

shopee买家通系统可以自动注册虾皮买家号&#xff0c;并且支持多个国家使用&#xff0c;可以用于菲律宾、印度尼西亚、泰国、马来西亚、越南等。 如果想要自动化注册&#xff0c;资料方面也有一定要求&#xff0c;手机号需要相应国家的号码 ip环境也要用相应国家的才可以&…
阅读更多...
C# 3D人脸重建，人头姿势估计

C# 3D人脸重建，人头姿势估计

效果 项目 代码 using OpenCvSharp; using System; using System.Collections.Generic; using System.Drawing; using System.Windows.Forms;namespace Onnx_Demo {public partial class frmMain : Form{public frmMain(){InitializeComponent();}string fileFilter "*.…
阅读更多...
道本科技||紧跟数字化转型趋势，企业如何提高合同管理能效？

道本科技||紧跟数字化转型趋势，企业如何提高合同管理能效？

随着数字化转型的快速发展&#xff0c;合同管理对于企业的运营效率和风险控制起着至关重要的作用。那么&#xff0c;如何紧跟数字化转型趋势&#xff0c;利用现代技术和工具提高合同管理的能效&#xff0c;以实现企业更高效、更安全的合同管理就成了企业管理中的核心问题。 在…
阅读更多...
【MySQL事务篇】事务基础知识

【MySQL事务篇】事务基础知识

事务基础知识 文章目录 事务基础知识1. 概述2. 事务的ACID特性3. 事务的状态4. 事务的使用4.1 显式事务4.2 隐式事务 5. 事务隔离级别5.1 数据并发问题5.2 SQL中的四种隔离级别 1. 概述 事务&#xff1a;一组逻辑操作单元&#xff0c;使数据从一种状态变换到另一种状态 事务处…
阅读更多...
ECharts折线图去掉图例和线段上的小圆点

ECharts折线图去掉图例和线段上的小圆点

官方的初始效果 折线图的图例有小圆点&#xff0c;并且图表中也有小圆点 最终效果 去掉图例和图标中的小圆点 并且柱状图和折线图的图例要不同 代码实现 去掉图例小圆点 官方文档 itemStyle: { opacity: 0 } 折线图中的小圆点去掉 官方文档 两个代码二选一就行&#x…
阅读更多...
uniapp小程序砸金蛋抽奖

uniapp小程序砸金蛋抽奖

砸之前是金蛋png图片&#xff0c;点击砸完之后切换砸金蛋动效gif图片&#xff1b; 当前代码封装为砸金蛋的组件&#xff1b; vue代码&#xff1a; <template><view class"page" v-if"merchantInfo.cdn_static"><image class"bg&qu…
阅读更多...
实习输出（1）

实习输出（1）

一、几项注意事项 1、uTools 一款很好用的工具。里面汇聚了截图、翻译、笔记、todo等等功能&#xff0c;并且支持快捷键打开&#xff0c;方便电脑开发使用。 2、IDEA &#xff0c;因为目前主流开发都是使用IDEA。首先要熟悉最基本的IDEA的快捷键 使用&#xff0c;像进入方法&…
阅读更多...
日本it培训学费 想去日本做IT，需要具备哪些技术？

日本it培训学费 想去日本做IT，需要具备哪些技术？

日本的IT行业历史比较悠久&#xff0c;业务以上层前端业务为主&#xff0c;如设计和构建软件。日本IT公司组织庞大&#xff0c;行业内部有着严格的分工和部署&#xff0c;工作会被细分化&#xff0c;分配给个人的工作量不会太大&#xff0c;难度也不会很高&#xff0c;所以日本…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023