BeetleX.Redis列表和哈希表操作

列表

组件通过 RedisList<T> 对象来封装列表操作的相关方法，在使用这些方法的时候需要先创建一个列表对象

var list = DB.CreateList<Employee>("employees");

通过 CreateList 方法来创建一个列表，并且指定列表的类型.

BLPop

它是 LPOP key 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止

超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。

var list = DB.CreateList<Employee>("employees");
Write(await list.BLPop(30));

BRPop

它是 RPOP key 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BRPOP 命令阻塞，直到等待超时或发现可弹出元素为止。

超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。

var list = DB.CreateList<Employee>("employees");
Write(await list.BRPop());

BRPopLPush

BRPOPLPUSH 是 RPOPLPUSH source destination 的阻塞版本，当给定列表 source 不为空时， BRPOPLPUSH 的表现和 RPOPLPUSH source destination 一样。

当列表 source 为空时， BRPOPLPUSH 命令将阻塞连接，直到等待超时，或有另一个客户端对 source 执行 LPUSH key value [value …] 或 RPUSH key value [value …] 命令为止。

超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。

var list = DB.CreateList<Employee>("employees");
Write(await list.BRPopLPush("employees1"));

LIndex

返回列表 key 中，下标为 index 的元素。

下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。

你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

如果 key 不是列表类型，返回一个错误。

var list = DB.CreateList<Employee>("employees");
Write(await list.Push(GetEmployee(1)));
Write(await list.Push(GetEmployee(2)));
Write(await list.Index(0));
Write(await list.Index(-1));
Write(await list.Index(3));

LInsert

将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。

当 pivot 不存在于列表 key 时，不执行任何操作。

当 key 不存在时， key 被视为空列表，不执行任何操作。

如果 key 不是列表类型，返回一个错误。

var list = DB.CreateList<Employee>("employees");
Write(await list.RPush(GetEmployee(1)));
Write(await list.RPush(GetEmployee(2)));
Write(await list.Insert(true, GetEmployee(2), GetEmployee(3)));
Write(await list.Range(0, -1));

LLen

返回列表 key 的长度。

如果 key 不存在，则 key 被解释为一个空列表，返回 0 .

如果 key 不是列表类型，返回一个错误。

var list = DB.CreateList<Employee>("employees");
Write(await list.RPush(GetEmployee(1)));
Write(await list.RPush(GetEmployee(2)));
Write(list.Len());

LPop

移除并返回列表 key 的头元素

var list = DB.CreateList<Employee>("employees");
Write(await list.RPush(GetEmployee(1)));
Write(await list.RPush(GetEmployee(2)));
Write(await list.RPush(GetEmployee(3)));
Write(await list.RPush(GetEmployee(4)));
Write(await list.Pop());
Write(await list.Range(0, -1));
Write(await list.Len());

LPush

将一个或多个值 value 插入到列表 key 的表头

如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头：比如说，对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a ，这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三个命令。

如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。

当 key 存在但不是列表类型时，返回一个错误。

var list = DB.CreateList<Employee>("employees");
Write(await list.Push(GetEmployee(1)));
Write(await list.Push(GetEmployee(2)));
Write(await list.RPush(GetEmployee(3)));
Write(await list.RPush(GetEmployee(4)));
Write(await list.Range(0, -1));

LPushX

将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。

var list = DB.CreateList<Employee>("employees");
Write(await list.Push(GetEmployee(1)));
Write(await list.PushX(GetEmployee(2)));
var myotherlist = DB.CreateList<Employee>("myotherlist ");
Write(await myotherlist.PushX(GetEmployee(2)));
Write(await list.Range(0, -1));
Write(await myotherlist.Range(0, -1));

LRem

根据参数 count 的值，移除列表中与参数 value 相等的元素。

count 的值可以是以下几种：

count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。

count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。

count = 0 : 移除表中所有与 value 相等的值。

Write(await list.RPush(GetEmployee(1)));
Write(await list.RPush(GetEmployee(1)));
Write(await list.RPush(GetEmployee(2)));
Write(await list.RPush(GetEmployee(1)));
Write(await list.Rem(-2, GetEmployee(1)));
Write(await list.Range(0, -1));

LSet

将列表 key 下标为 index 的元素的值设置为 value 。

当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。

var list = DB.CreateList<Employee>("employees");
Write(await list.RPush(GetEmployee(1)));
Write(await list.RPush(GetEmployee(2)));
Write(await list.RPush(GetEmployee(3)));
Write(await list.Set(0, GetEmployee(4)));
Write(await list.Set(-2, GetEmployee(5)));
Write(await list.Range(0, -1));

LTrim

对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。

举个例子，执行命令 LTRIM list 0 2 ，表示只保留列表 list 的前三个元素，其余元素全部删除。

下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。

你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

当 key 不是列表类型时，返回一个错误。

var list = DB.CreateList<Employee>("employees");
Write(await list.RPush(GetEmployee(1)));
Write(await list.RPush(GetEmployee(2)));
Write(await list.RPush(GetEmployee(3)));
Write(await list.Trim(1, -1));
Write(await list.Range(0, -1));

RPop

移除并返回列表 key 的尾元素

var list = DB.CreateList<Employee>("employees");
Write(await list.RPush(GetEmployee(1)));
Write(await list.RPush(GetEmployee(2)));
Write(await list.RPush(GetEmployee(3)));
Write(await list.RPop());
Write(await list.Range(0, -1));

RPopLPush

命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作：

将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。

将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。

举个例子，你有两个列表 source 和 destination ， source 列表有元素 a, b, c ， destination 列表有元素 x, y, z ，执行 RPOPLPUSH source destination 之后， source 列表包含元素 a, b ， destination 列表包含元素 c, x, y, z ，并且元素 c 会被返回给客户端。

如果 source 不存在，值 nil 被返回，并且不执行其他动作。

如果 source 和 destination 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转(rotation)操作。

var list = DB.CreateList<Employee>("employees");
Write(await list.RPush(GetEmployee(1)));
Write(await list.RPush(GetEmployee(2)));
Write(await list.RPush(GetEmployee(3)));
Write(await list.RPopLPush("myotherlist"));
Write(await list.Range(0, -1));
var otherList = DB.CreateList<Employee>("myotherlist");
Write(await otherList.Range(0, -1));

RPush

将一个或多个值 value 插入到列表 key 的表尾(最右边)。

如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾：比如对一个空列表 mylist 执行 RPUSH mylist a b c ，得出的结果列表为 a b c ，等同于执行命令 RPUSH mylist a 、 RPUSH mylist b 、 RPUSH mylist c 。

如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。

当 key 存在但不是列表类型时，返回一个错误。

var list = DB.CreateList<Employee>("employees");
Write(await list.RPush(GetEmployee(1)));
Write(await list.RPush(GetEmployee(2)));
Write(await list.Range(0, -1));

RPushX

将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。

和 RPUSH key value [value …] 命令相反，当 key 不存在时， RPUSHX 命令什么也不做

var list = DB.CreateList<Employee>("employees");
var otherlist = DB.CreateList<Employee>("othrelist");
Write(await list.RPush(GetEmployee(1)));
Write(await list.RPushX(GetEmployee(2)));
Write(await otherlist.RPushX(GetEmployee(2)));
Write(await list.Range(0, -1));
Write(await otherlist.Range(0, -1));

Range

返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。

下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。

你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

var list = DB.CreateList<Employee>("employees");
Write(await list.RPush(GetEmployee(1)));
Write(await list.RPush(GetEmployee(2)));
Write(await list.RPush(GetEmployee(3)));
Write(await list.Range(0, 0));
Line();
Write(await list.Range(-3, 2));
Line();
Write(await list.Range(-100, 100));
Line();
Write(await list.Range(5, 10));

哈希表

组件通过 RedisHashTable 来封装相关哈希表的操作方法，在操作前需要创建相关对象

DB.CreateHashTable("myhash");

HDel

删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。

var table = DB.CreateHashTable("myhash");
Write(await table.MSet(("emp1", GetEmployee(1))));
Write(await table.Del("emp1"));
Write(await table.Del("emp2"));
Write(await table.Len());

HExists

检查给定域 field 是否存在于哈希表 hash 当中。

var table = DB.CreateHashTable("myhash");
Write(await table.MSet(("emp1", GetEmployee(1))));
Write(await table.Exists("emp1"));
Write(await table.Exists("emp2"));

HGet

返回哈希表中给定域的值。

var table = DB.CreateHashTable("myhash");
Write(await table.MSet(("emp1", GetEmployee(1))));
Write(await table.Get<Employee>("emp1"));
Write(await table.Get<Employee>("emp2"));

HKeys

返回哈希表 key 中的所有域。

var table = DB.CreateHashTable("myhash");
Write(await table.MSet(("field1", GetEmployee(1)), ("field2", GetEmployee(2))));
Write(await table.Keys());

HLen

返回哈希表 key 中域的数量

var table = DB.CreateHashTable("myhash");
Write(table.MSet(("field1", GetCustomer(1)), ("field2", GetCustomer(2))));
Write(await table.Len());

HMGet

返回哈希表 key 中，一个或多个给定域的值。

如果给定的域不存在于哈希表，那么返回一个 nil 值。

因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。

await DB.Flushall();
var table = DB.CreateHashTable("myhash");
Write(await table.MSet(
("emp", GetEmployee(1)),
("order", GetOrder(1)),
("customer", GetCustomer(1))
));
var values = await table.Get<Employee, Order, Customer>("emp", "order", "customer");
Write(values.Item1);
Write(values.Item2);
Write(values.Item3);

HMGet

返回哈希表 key 中，一个或多个给定域的值。

如果给定的域不存在于哈希表，那么返回一个 nil 值。

因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。

var table = DB.CreateHashTable("myhash");
Write(await table.MSet(("emp", GetEmployee(1)),
("order", GetOrder(1))
));
var values = await table.Get<Employee, Order>("emp", "order");
Write(values.Item1);
Write(values.Item2);

HMSet

同时将多个 field-value (域-值)对设置到哈希表 key 中。

此命令会覆盖哈希表中已存在的域。

如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。

var table = DB.CreateHashTable("myhash");
Write(await table.MSet(("field1", GetEmployee(1)), ("field2", GetCustomer(1))));
Write(await table.Get<Employee>("field1"));
Write(await table.Get<Customer>("field2"));

HSet

将哈希表 hash 中域 field 的值设置为 value 。

如果给定的哈希表并不存在， 那么一个新的哈希表将被创建并执行 HSET 操作。

如果域 field 已经存在于哈希表中， 那么它的旧值将被新值 value 覆盖。

var table = DB.CreateHashTable("myhash");
Write(await table.Set("field1", GetEmployee(1)));
Write(await table.Get<Employee>("field1"));

HSetNX

当且仅当域 field 尚未存在于哈希表的情况下， 将它的值设置为 value 。

如果给定域已经存在于哈希表当中， 那么命令将放弃执行设置操作。

如果哈希表 hash 不存在， 那么一个新的哈希表将被创建并执行 HSETNX 命令。

var table = DB.CreateHashTable("myhash");
Write(await table.SetNX("field", GetEmployee(1)));
Write(await table.SetNX("field", GetEmployee(2)));
Write(await table.Get<Employee>("field"));

HStrLen

返回哈希表 key 中， 与给定域 field 相关联的值的字符串长度（string length）。

如果给定的键或者域不存在， 那么命令返回 0

var table = DB.CreateHashTable("myhash");
Write(await table.MSet(("f1", "helloworld"), ("f2", 99), ("f3", -256)));
Write(await table.StrLen("f1"));
Write(await table.StrLen("f2"));
Write(await table.StrLen("f3"));