入门指南 - 图1

Redka旨在使用SQLite重新实现Redis的优秀部分，同时保持与Redis API的兼容性。

主要特点包括：

  • 数据不必适应RAM。
  • ACID事务。
  • 用于更好的内省和报告的SQL视图。
  • 包括进程内（Go API）和独立（RESP）服务器。
  • Redis兼容的命令和传输协议。

这还在不断发展中。请参阅下文以了解当前状态和路线图。

命令 • 安装 • 使用 • 持久化 • 性能 • 路线图 • 更多

命令

Redka旨在支持五种核心的Redis数据类型：字符串、列表、集合、哈希和有序集合。

字符串

字符串是Redis中最基本的数据类型，表示一系列字节。Redka支持以下与字符串相关的命令：

  1. Command      Go API                 Description
  2. -------      ------                 -----------
  3. DECR         DB.Str().Incr          将键的整数值减一
  4. DECRBY       DB.Str().Incr          将键的整数值减去一个数字
  5. GET          DB.Str().Get           返回键的值
  6. GETSET       DB.Str().GetSet        设置键的新值并返回先前的值。
  7. INCR         DB.Str().Incr          将键的整数值增加一。
  8. INCRBY       DB.Str().Incr          将键的整数值增加指定的数字。
  9. INCRBYFLOAT  DB.Str().IncrFloat     将键的浮点数值增加指定的数字。
  10. MGET         DB.Str().GetMany       返回一个或多个键的值。
  11. MSET         DB.Str().SetMany       Sets the values of one or more keys.
  12. MSETNX       DB.Str().SetManyNX     Sets the values of one or more keys when all keys don't exist.
  13. PSETEX       DB.Str().SetExpires    Sets the value and expiration time (in ms) of a key.
  14. SET          DB.Str().Set           Sets the value of a key.
  15. SETEX        DB.Str().SetExpires    Sets the value and expiration (in sec) time of a key.
  16. SETNX        DB.Str().SetNotExists  Sets the value of a key when the key doesn't exist.

以下与字符串相关的命令不计划在1.0版本中实现：

APPEND GETDEL GETEX GETRANGE LCS SETRANGE STRLEN SUBSTR

列表

列表是按插入顺序排序的字符串列表。Redka旨在在1.0版本中支持以下与列表相关的命令： LINDEX LINSERT LLEN LPOP LPUSHX LRANGE LREM LSET LTRIM RPOP RPOPLPUSH RPUSH RPUSHX

集合

集合是唯一字符串的无序集合。Redka旨在在1.0版本中支持以下与集合相关的命令：

  1. SADD  SCARD  SDIFF  SDIFFSTORE  SINTER  SINTERSTORE
  2. SISMEMBER  SMEMBERS  SMOVE  SPOP  SRANDMEMBER  SREM
  3. SUNION  SUNIONSTORE

哈希

哈希是字段-值（键-值）映射。Redka支持以下与哈希相关的命令：

  1. Command       Go API                  Description
  2. -------       ------------------      -----------
  3. HDEL          DB.Hash().Delete        Deletes one or more fields and their values.
  4. HEXISTS       DB.Hash().Exists        Determines whether a field exists.
  5. HGET          DB.Hash().Get           Returns the value of a field.
  6. HGETALL       DB.Hash().Items         Returns all fields and values.
  7. HINCRBY       DB.Hash().Incr          Increments the integer value of a field.
  8. HINCRBYFLOAT  DB.Hash().IncrFloat     Increments the float value of a field.
  9. HKEYS         DB.Hash().Keys          Returns all fields.
  10. HLEN          DB.Hash().Len           Returns the number of fields.
  11. HMGET         DB.Hash().GetMany       Returns the values of multiple fields.
  12. HMSET         DB.Hash().SetMany       Sets the values of multiple fields.
  13. HSCAN         DB.Hash().Scanner       Iterates over fields and values.
  14. HSET          DB.Hash().SetMany       Sets the values of one or more fields.
  15. HSETNX        DB.Hash().SetNotExists  Sets the value of a field when it doesn't exist.
  16. HVALS         DB.Hash().Exists        Returns all values.

以下与哈希相关的命令不计划在 1.0 版本中实现：

HRANDFIELD HSTRLEN

有序集合

有序集合是按每个字符串的相关分数排序的唯一字符串的集合。Redka旨在在1.0版本中支持以下有序集合相关的命令：

  1. ZADD  ZCARD  ZCOUNT  ZINCRBY  ZINTERSTORE  ZRANGE
  2. ZRANK  ZREM  ZSCORE

键管理

Redka 支持以下键管理（通用）命令：

  1. Command    Go API                    Description
  2. -------    ------                    -----------
  3. DEL        DB.Key().Delete           Deletes one or more keys.
  4. EXISTS     DB.Key().Count            Determines whether one or more keys exist.
  5. EXPIRE     DB.Key().Expire           Sets the expiration time of a key (in seconds).
  6. EXPIREAT   DB.Key().ExpireAt         Sets the expiration time of a key to a Unix timestamp.
  7. KEYS       DB.Key().Keys             Returns all key names that match a pattern.
  8. PERSIST    DB.Key().Persist          Removes the expiration time of a key.
  9. PEXPIRE    DB.Key().Expire           Sets the expiration time of a key in ms.
  10. PEXPIREAT  DB.Key().ExpireAt         Sets the expiration time of a key to a Unix ms timestamp.
  11. RANDOMKEY  DB.Key().Random           Returns a random key name from the database.
  12. RENAME     DB.Key().Rename           Renames a key and overwrites the destination.
  13. RENAMENX   DB.Key().RenameNotExists  Renames a key only when the target key name doesn't exist.
  14. SCAN       DB.Key().Scanner          Iterates over the key names in the database.

以下通用命令不计划在 1.0 版本中实现：

  1. COPY  DUMP  EXPIRETIME  MIGRATE  MOVE  OBJECT  PEXPIRETIME
  2. PTTL  RESTORE  SORT  SORT_RO  TOUCH  TTL  TYPE  UNLINK
  3. WAIT  WAITAOF

事务

Redka 支持以下事务命令：

  1. Command    Go API                 Description
  2. -------    ------                 -----------
  3. DISCARD    DB.View / DB.Update    Discards a transaction.
  4. EXEC       DB.View / DB.Update    Executes all commands in a transaction.
  5. MULTI      DB.View / DB.Update    Starts a transaction.

与Redis不同，Redka的事务是完全符合ACID的，在失败的情况下提供自动回滚。

以下事务命令不计划在1.0版本中实现：

UNWATCH WATCH

服务器/连接管理

Redka 仅支持几个服务器和连接管理命令：

  1. Command    Go API                Description
  2. -------    ------                -----------
  3. ECHO       -                     Returns the given string.
  4. FLUSHDB    DB.Key().DeleteAll    Remove all keys from the database.

安装

Redka可以安装为独立的Redis兼容服务器，也可以作为用于进程内使用的Go模块。

独立服务器

Redka服务器是一个单文件二进制文件。从发布页面下载它。

Linux（仅限x86 CPU）:

  1. curl -L -O "https://github.com/nalgeon/redka/releases/download/v0.2.0/redka_linux_amd64.zip"
  2. unzip redka_linux_amd64.zip
  3. chmod +x redka

macOS（x86和ARM/Apple Silicon CPU均适用）:

  1. curl -L -O "https://github.com/nalgeon/redka/releases/download/v0.2.0/redka_darwin_amd64.zip"
  2. unzip redka_darwin_amd64.zip
  3. # remove the build from quarantine
  4. # (macOS disables unsigned binaries)
  5. xattr -d com.apple.quarantine redka
  6. chmod +x redka

或者使用 Docker 拉取，命令如下（x86/ARM）:

docker pull nalgeon/redka

或者从源代码构建（需要Go 1.22和GCC）:

  1. git clone https://github.com/nalgeon/redka.git
  2. cd redka
  3. make setup build
  4. # the path to the binary after the build
  5. # will be ./build/redka

Go 模块

按照以下步骤安装模块： go get github.com/nalgeon/redka

如果您不介意使用 CGO，您还需要一个 SQLite 驱动程序。否则，请使用纯Go驱动程序 modernc.org/sqlite。像这样使用 go get 安装任何一个：

  1. go get github.com/mattn/go-sqlite3

使用

Redka可以用作独立的Redis兼容服务器，也可以作为可嵌入的进程内服务器，使用Go API。

独立服务器

Redka 服务器是一个单文件二进制文件。在下载并解压发布文件后，可以按如下方式运行它：

  1. redka [-h host] [-p port] [db-path]

例如：

  1. ./redka
  2. ./redka data.db
  3. ./redka -h 0.0.0.0 -p 6379 data.db

服务器的默认设置为主 机localhost，端口 6379 和空的数据库路径。

在没有数据库路径的情况下运行将创建一个内存数据库。在这种情况下，数据不会持久化，并且在服务器停止时将被删除。

您也可以按照以下方式使用 Docker 运行 Redka：

  1. # database inside the container
  2. # will be lost when the container stops
  3. docker run --rm -p 6379:6379 nalgeon/redka
  5. # persistent database
  6. # using the /path/to/data host directory
  7. docker run --rm -p 6379:6379 -v /path/to/data:/data nalgeon/redka
  9. # in-memory database, custom post
  10. docker run --rm -p 6380:6380 nalgeon/redka redka -h 0.0.0.0 -p 6380

在 Docker 中，服务器的默认设置为主机 0.0.0.0，端口 6379 和数据库路径 /data/redka.db。

一旦服务器运行起来，您可以使用 redis-cli 或者类似 redis-py 或 go-redis 的API客户端连接到它 — 就像您连接到Redis一样。

redis-cli -h localhost -p 6379

  1. 127.0.0.1:6379> echo hello
  2. "hello"
  3. 127.0.0.1:6379> set name alice
  4. OK
  5. 127.0.0.1:6379> get name
  6. "alice"

进程内服务器

在 Redka 中，主要对象是 DB。要打开或创建您的数据库，请使用 redka.Open() 函数：

  1. package main
  3. import (
  4.     "log"
  6.     _ "github.com/mattn/go-sqlite3"
  7.     "github.com/nalgeon/redka"
  8. )
  10. func main() {
  11.     // Open or create the data.db file.
  12.     db, err := redka.Open("data.db", nil)
  13.     if err != nil {
  14.         log.Fatal(err)
  15.     }
  16.     // Always close the database when you are finished.
  17.     defer db.Close()
  18.     // ...
  19. }