BeetleX.Redis基础操作和对象格式

Decr

为键 key 储存的数字值减去一。

如果键 key 不存在， 那么键 key 的值会先被初始化为 0 ， 然后再执行 DECR 操作。

如果键 key 储存的值不能被解释为数字， 那么 DECR 命令将返回一个错误。

本操作的值限制在 64 位(bit)有符号数字表示之内。

var set = await DB.Set("mykey", "10");
var decr = await DB.Decr("mykey");

Decrby

将键 key 储存的整数值减去减量 decrement 。

如果键 key 不存在， 那么键 key 的值会先被初始化为 0 ， 然后再执行 DECRBY 命令。

如果键 key 储存的值不能被解释为数字， 那么 DECRBY 命令将返回一个错误。

本操作的值限制在 64 位(bit)有符号数字表示之内。

var set = await DB.Set("mykey", "10");
var decrby = await DB.Decrby("mykey", 5);

Del

删除给定的一个或多个 key 。

不存在的 key 会被忽略。

var add = await DB.Set("test", "henryfan");
var del = await DB.Del("test");

Dump

序列化给定 key ，并返回被序列化的值，使用 RESTORE 命令可以将这个值反序列化为 Redis 键。

序列化生成的值有以下几个特点：

它带有 64 位的校验和，用于检测错误， RESTORE 在进行反序列化之前会先检查校验和。

值的编码格式和 RDB 文件保持一致。

RDB 版本会被编码在序列化值当中，如果因为 Redis 的版本不同造成 RDB 格式不兼容，那么 Redis 会拒绝对这个值进行反序列化操作。

序列化的值不包括任何生存时间信息。

var add = await DB.Set("test", "henryfan");
var result = await DB.Dump("test");

Exists

检查给定 key 是否存在。

var add = await DB.Set("aa", "sfsdfsd");
var count = await DB.Exists("aa");
count = await DB.Exists("sdfsdf", "aa");
count = await DB.Exists("sdfsdf", "sdfsdfdsaa");

Expire

为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。

在 Redis 中，带有生存时间的 key 被称为『易失的』(volatile)。

生存时间可以通过使用 DEL 命令来删除整个 key 来移除，或者被 SET 和 GETSET 命令覆写(overwrite)，这意味着，如果一个命令只是修改(alter)一个带生存时间的 key 的值而不是用一个新的 key 值来代替(replace)它的话，那么生存时间不会被改变。

var add = await DB.Set("mykey", "hello");
var expire = await DB.Expire("mykey", 10);
var ttl = await DB.Ttl("mykey");
add = await DB.Set("mykey", "hello world");
ttl = await DB.Ttl("mykey");

Expireat

EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间。

不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。

var set = await DB.Set("mykey", "hello");
var extist = await DB.Exists("mykey");
var expireat = await DB.Expireat("mykey", 1293840000);
extist = await DB.Exists("mykey");

Flushall

清空整个 Redis 服务器的数据(删除所有数据库的所有 key )。

此命令从不失败。

 await DB.Flushall();

Get

返回与键 key 相关联的字符或对象（当不指定序列化格式的情况都要用）

var get = await DB.Get<string>("nonexisting");
var set = await DB.Set("mykey", "hello");
get = await DB.Get<string>("mykey");

GetBit

对 key 所储存的字符串值，获取指定偏移量上的位(bit)。

当 offset 比字符串值的长度大，或者 key 不存在时，返回 0

var set = await DB.SetBit("mykey", 7, true);
var get = await DB.GetBit("mykey", 0);
get = await DB.GetBit("mykey", 7);
get = await DB.GetBit("mykey", 100);

GetRange

返回键 key 储存的字符串值的指定部分， 字符串的截取范围由 start 和 end 两个偏移量决定 (包括 start 和 end 在内)。

负数偏移量表示从字符串的末尾开始计数， -1 表示最后一个字符， -2 表示倒数第二个字符， 以此类推。

var set = await DB.Set("mykey", "This is a string");
var region = await DB.GetRange("mykey", 0, 3);
region = await DB.GetRange("mykey", -3, -1);
region = await DB.GetRange("mykey", 0, -1);
region = await DB.GetRange("mykey", 10, 100);

GetSet

将键 key 的值设为 value ， 并返回键 key 在被设置之前的旧值。

var set = await DB.GetSet<string>("aaa", "aaa");
set = await DB.GetSet<string>("aaa", "bbb");
var incr = await DB.Incr("mycounter");
var getset = await DB.GetSet<string>("mycounter", 0);
var get = await DB.Get<string>("mycounter");

Incr

为键 key 储存的数字值加上一。

如果键 key 不存在， 那么它的值会先被初始化为 0 ， 然后再执行 INCR 命令。

如果键 key 储存的值不能被解释为数字， 那么 INCR 命令将返回一个错误。

本操作的值限制在 64 位(bit)有符号数字表示之内。

var set = await DB.Set("mykey", 10000000);
var incr = await DB.Incr("mykey");
var get = await DB.Get<string>("mykey");

Incrby

为键 key 储存的数字值加上增量 increment 。

如果键 key 不存在， 那么键 key 的值会先被初始化为 0 ， 然后再执行 INCRBY 命令。

如果键 key 储存的值不能被解释为数字， 那么 INCRBY 命令将返回一个错误。

本操作的值限制在 64 位(bit)有符号数字表示之内。

关于递增(increment) / 递减(decrement)操作的更多信息， 请参见 INCR 命令的文档。

var set = await DB.Set("mykey", 10000000);
var incr = await DB.Incrby("mykey", 10);
var get = await DB.Get<string>("mykey");

IncrbyFloat

为键 key 储存的值加上浮点数增量 increment 。

如果键 key 不存在， 那么 INCRBYFLOAT 会先将键 key 的值设为 0 ， 然后再执行加法操作。

如果命令执行成功， 那么键 key 的值会被更新为执行加法计算之后的新值， 并且新值会以字符串的形式返回给调用者。

var set = await DB.Set("mykey", "10.5");
var incr = await DB.IncrbyFloat("mykey", 0.1f);
set = await DB.Set("mykey", "5.0e3");
incr = await DB.IncrbyFloat("mykey", 200f);

Keys

查找所有符合给定模式 pattern 的 key ， 比如说：

KEYS * 匹配数据库中所有 key 。

KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。

KEYS h*llo 匹配 hllo 和 heeeeello 等。

KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。

var mset = await DB.MSet(("one", 1), ("tow", 2), ("three", 2), ("four", 4));
var keys = await DB.Keys("*o*");
keys = await DB.Keys("t??");
keys = await DB.Keys("*");

MGet

返回给定的一个或多个字符串键的值。

如果给定的字符串键里面， 有某个键不存在， 那么这个键的值将以特殊值 nil 表示。

await DB.Flushall();
var mset = await DB.MSet(
    ("key1", "value1"),
    ("key2", "value2"),
    ("key3", "value3"));
Write(mset);
var mget = await DB.MGet<string, string, string>("key1", "key2", "key3");

MSet

同时为多个键设置值。

如果某个给定键已经存在， 那么 MSET 将使用新值去覆盖旧值， 如果这不是你所希望的效果， 请考虑使用 MSETNX 命令， 这个命令只会在所有给定键都不存在的情况下进行设置。

MSET 是一个原子性(atomic)操作， 所有给定键都会在同一时间内被设置， 不会出现某些键被设置了但是另一些键没有被设置的情况。

var result = await DB.MSet(("key1", "hello"), ("key2", "world"));
var get = await DB.Get<string>("key1");
get = await DB.Get<string>("key2");

MSetNX

当且仅当所有给定键都不存在时， 为所有给定键设置值。

即使只有一个给定键已经存在， MSETNX 命令也会拒绝执行对所有键的设置操作。

MSETNX 是一个原子性(atomic)操作， 所有给定键要么就全部都被设置， 要么就全部都不设置， 不可能出现第三种状态。

var msetnx = await DB.MSetNX(("key1", "hello"), ("key2", "there"));
msetnx = await DB.MSetNX(("key3", "world"), ("key2", "there"));
var mget = await DB.MGet<string, string, string>("key1", "key2", "key3");

Move

将当前数据库的 key 移动到给定的数据库 db 当中。

如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者 key 不存在于当前数据库，那么 MOVE 没有任何效果。

因此，也可以利用这一特性，将 MOVE 当作锁(locking)原语(primitive)。

var move = await DB.Move("one", 9);

PSetEX

这个命令和 SETEX 命令相似， 但它以毫秒为单位设置 key 的生存时间， 而不是像 SETEX 命令那样以秒为单位进行设置。

var psetex = await DB.PSetEX("mykey", 1000, "hello");
var pttl = await DB.PTtl("mykey");
var get = await DB.Get<string>("mykey");

Persist

移除给定 key 的生存时间，将这个 key 从“易失的”(带生存时间 key )转换成“持久的”(一个不带生存时间、永不过期的 key )。

var set = await DB.Set("mykey", "hello");
var expire = await DB.Expire("mykey", 10);
var ttl = await DB.Ttl("mykey");
var persist = await DB.Persist("mykey");
ttl = await DB.Ttl("mykey");

Pexpire

这个命令和 EXPIRE 命令的作用类似，但是它以毫秒为单位设置 key 的生存时间，而不像 EXPIRE 命令那样，以秒为单位。

var set = await DB.Set("mykey", "hello");
var pexpire = await DB.Pexpire("mykey", 1500);
var ttl = await DB.Ttl("mykey");
ttl = await DB.PTtl("mykey");

Pexpireat

这个命令和 expireat 命令类似，但它以毫秒为单位设置 key 的过期 unix 时间戳，而不是像 expireat 那样，以秒为单位。

var set = await DB.Set("mykey", "hello");
var pexpireat = await DB.Pexpireat("mykey", 1555555555005);
var ttl = await DB.Ttl("mykey");
var pttl = await DB.PTtl("mykey");

Ping

使用客户端向 Redis 服务器发送一个 PING

var result = await DB.Ping();

Pttl

这个命令类似于 TTL 命令，但它以毫秒为单位返回 key 的剩余生存时间，而不是像 TTL 命令那样，以秒为单位。

var set = await DB.Set("mykey", "hello");
var expire = await DB.Expire("mykey", 1);
var pttl = await DB.PTtl("mykey");

Publish

将信息 message 发送到指定的频道 channel

await DB.Publish("channel", DateTime.Now)

Randomkey

从当前数据库中随机返回一个键值

await DB.Randomkey();

Rename

将 key 改名为 newkey 。

当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。

var set = await DB.Set("mykey", "hello");
var ren = await DB.Rename("mykey", "myotherkey");
var get = await DB.Get<string>("myotherkey");

Renamenx

当且仅当 newkey 不存在时，将 key 改名为 newkey

var set = await DB.Set("mykey", "hello");
set = await DB.Set("myotherkey", "World");
var ren = await DB.Renamenx("mykey", "myotherkey");
var get = await DB.Get<string>("myotherkey");

Set

将字符串值 value 关联到 key 。

如果 key 已经持有其他值， SET 就覆写旧值， 无视类型。

当 SET 命令对一个带有生存时间（TTL）的键进行设置之后， 该键原有的 TTL 将被清除。

var result = await DB.Set("test", "henryfan1");
var value = await DB.Get<string>("test");

SetBit

对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)。

位的设置或清除取决于 value 参数，可以是 0 也可以是 1 。

当 key 不存在时，自动生成一个新的字符串值。

字符串会进行伸展(grown)以确保它可以将 value 保存在指定的偏移量上。当字符串值进行伸展时，空白位置以 0 填充。

offset 参数必须大于或等于 0 ，小于 2^32 (bit 映射被限制在 512 MB 之内)。

var setbit = await DB.SetBit("mykey", 7, true);
var get = await DB.Get<string>("mykey");
setbit = await DB.SetBit("mykey", 7, false);
get = await DB.Get<string>("mykey");

SetEX

将键 key 的值设置为 value ， 并将键 key 的生存时间设置为 seconds 秒钟。

如果键 key 已经存在， 那么 SETEX 命令将覆盖已有的值。

var setex = await DB.SetEX("mykey", 10, "hello");
var ttl = await DB.Ttl("mykey");
var get = await DB.Get<string>("mykey");

SetNX

只在键 key 不存在的情况下， 将键 key 的值设置为 value 。

若键 key 已经存在， 则 SETNX 命令不做任何动作。

SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。

var setnx = await DB.SetNX("mykey", "hello");
setnx = await DB.SetNX("mykey", "World");
var get = await DB.Get<string>("mykey");

SetRange

从偏移量 offset 开始， 用 value 参数覆写(overwrite)键 key 储存的字符串值。

不存在的键 key 当作空白字符串处理。

var set = await DB.Set("key1", "hello world");
var setrange = await DB.SetRange("key1", 6, "redis");
var get = await DB.Get<string>("key1");
setrange = await DB.SetRange("key2", 6, "redis");
get = await DB.Get<string>("key2");

Strlen

返回键 key 储存的字符串值的长度。

var set = await DB.Set("key1", "hello world");
var strlen = await DB.Strlen("key1");
strlen = await DB.Strlen("nonexisting");

Type

返回 key 所储存的值的类型。

var set = await DB.Set("key1", "hello");
set = await DB.Set("key2", "word");
var type = await DB.Type("key1");
type = await DB.Type("key2");

对象序列化配置

组件默认提供三种数据对象的支持，分别json,protobuf和messagepack

json

Redis.Default.DataFormater = new JsonFormater();
//or
DB = new RedisDB(0, new JsonFormater());

protobuf

Redis.Default.DataFormater = new ProtobufFormater();
//or
DB = new RedisDB(0, new ProtobufFormater());

messagepack

Redis.Default.DataFormater = new MessagePackFormater();
//or
DB = new RedisDB(0, new MessagePackFormater());

所有基础操作不变，只是内容会根据配置的序列化类型进行对象序列化处理。

Get

Write(await DB.Get<Employee>("nonexisting"));
Write(await DB.Set("emp3", GetEmployee(3)));
Write(await DB.Get<Employee>("emp3"));

GetSet

Write(await DB.GetSet<Employee>("emp1", GetEmployee(1)));
Write(await DB.Set("emp1", GetEmployee(2)));
Write(await DB.Get<Employee>("emp1"));
Write(await DB.GetSet<Employee>("emp1", GetEmployee(1)));
Write(await DB.Get<Employee>("emp1"));

MGet

Write(await DB.Set("emp1", GetEmployee(1)));
Write(await DB.Set("emp2", GetEmployee(2)));
Write(await DB.MGet<Employee, Employee>("emp2", "emp1"));

MSet

await DB.Flushall();
Write(await DB.MSet(
("emp1", GetEmployee(1)),
("emp2", GetEmployee(2))
));
Write(await DB.Get<Employee>("emp1"));
Write(await DB.Get<Employee>("emp2"));

MSetNX

Write(await DB.MSetNX(("key1", GetEmployee(1)), ("key2", GetEmployee(2))));
Write(await DB.MSetNX(("key2", GetEmployee(2)), ("key3", GetEmployee(3))));
var items = await DB.MGet<Employee, Employee, Employee>("key1", "key2", "key3");
Write(items.Item1);
Write(items.Item2);
Write(items.Item3);

PSetEX

Write(await DB.PSetEX("key1", 1000, GetEmployee(1)));
Write(await DB.PTtl("key1"));
Write(await DB.Get<Employee>("key1"));

Publish

for (int i = 0; i < 5; i++)
{
    Write(await DB.Publish("test1", GetEmployee(i)));
}

Set

Write(await DB.Set("key1", GetEmployee(4)));
Write(await DB.Get<Employee>("key1"));

SetEX

Write(await DB.SetEX("key1", 10, GetEmployee(1)));
Write(await DB.Ttl("key1"));
Write(await DB.Get<Employee>("key1"));

SetNX

Write(await DB.SetNX("key1", GetEmployee(1)));
Write(await DB.SetNX("key1", GetEmployee(2)));
Write(await DB.Get<Employee>("key1"));