Redis select选择数据库

小咪咪 2022-05-23 13:38 174阅读 0赞

Redis的功能真是强大，可以做数据库，可以做缓存。

今天发现Redis支持分隔操作空间，使得空间与空间之间互不影响。

**SELECT index**  
切换到指定的数据库，数据库索引号 index 用数字值指定，以 0 作为起始索引值。  
默认使用 0 号数据库。

**可用版本：**  
>= 1.0.0  
**时间复杂度：**  
O(1)  
**返回值：**  
OK

redis> SET number 0         # 默认使用 0 号数据库
    OK
    
    redis> SELECT 1                # 使用 1 号数据库
    OK
    
    redis[1]> GET number        # 已经切换到 1 号数据库，注意 Redis 现在的命令提示符多了个 [1]
    (nil)
    
    redis[1]> SET number 1
    OK
    
    redis[1]> GET number
    "1"
    
    redis[1]> SELECT 3             # 再切换到 3 号数据库
    OK
    
    redis[3]>                      # 提示符从 [1] 改变成了 [3]

select index操作可以选择数据库，如果不选择，则默认是db 0。每个连接建立后，如果不select，默认是对db 0操作。

## Example1 ##

以下代码，建立一个连接，进行select操作，选择db 3，然后关闭。接着再分别建立两个连接进行sadd操作。从输出结果可以看到，两次sadd的操作都是对db 0操作的。

package main
    
    import (
        "log"
    
        "github.com/garyburd/redigo/redis"
    )
    
    const (
    
    
        redisServer = "10.194.80.35:6379"
    
    )
    
    func main() {
    
        selectDB(3)
        batchSADD()
        batchSADD2()
    
    }
    
    
    func selectDB(num int){
    
    
        option := redis.DialPassword("123456")
        c, err := redis.Dial("tcp", redisServer, option)
        if err != nil {
            log.Println("connect server failed:", err)
            return
        }
    
        defer c.Close()
    
        v, err := redis.String(c.Do("SELECT", num))
        if err != nil {
            log.Println("select failed:", err)
            return
        }
    
    
        log.Println("select:",v)
    
    }
    
    func batchSADD(){
        option := redis.DialPassword("123456")
        c, err := redis.Dial("tcp", redisServer, option)
        if err != nil {
            log.Println("connect server failed:", err)
            return
        }
    
        defer c.Close()
    
        setKey := "myset"
        args := []interface{}{setKey}
        args = append(args, "10.1")
        args = append(args, "10.2")
        v, err := redis.Int64(c.Do("SADD", args...))
        if err != nil {
            log.Println("SADD failed:", err)
            return
        }
    
        log.Println("sadd:",v)
    }
    
    
    func batchSADD2(){
        option := redis.DialPassword("123456")
        c, err := redis.Dial("tcp", redisServer, option)
        if err != nil {
            log.Println("connect server failed:", err)
            return
        }
    
        defer c.Close()
    
        setKey := "myset"
        args := []interface{}{setKey}
        args = append(args, "10.3")
        args = append(args, "10.4")
        v, err := redis.Int64(c.Do("SADD", args...))
        if err != nil {
            log.Println("SADD failed:", err)
            return
        }
    
        log.Println("sadd:",v)
    }

/\*

select db 3

first sadd to db 0  
second sadd to db 0

\*/

output结果：

> 127.0.0.1:6379> SMEMBERS myset  
> 1) “10.1”  
> 2) “10.4”  
> 3) “10.2”  
> 4) “10.3”  
> 127.0.0.1:6379>  
> 127.0.0.1:6379>  
> 127.0.0.1:6379> select 3  
> OK  
> 127.0.0.1:6379\[3\]> SMEMBERS myset  
> (empty list or set)  
> 127.0.0.1:6379\[3\]>

## Example2 ##

建立连接，select 3选择db 3，然后sadd，再建立一个连接，直接sadd。从结果可以看到，第一次sadd操作对db 3操作，第二次sadd对db 0操作的。

package main
    
    import (
        "log"
    
        "github.com/garyburd/redigo/redis"
    )
    
    const (
    
    
        redisServer = "10.194.80.35:6379"
    
    )
    
    func main() {
    
        batchSADD()
        batchSADD2()
    
    }
    
    
    func selectDB(num int){
    
    
        option := redis.DialPassword("123456")
        c, err := redis.Dial("tcp", redisServer, option)
        if err != nil {
            log.Println("connect server failed:", err)
            return
        }
    
        defer c.Close()
    
        v, err := redis.String(c.Do("SELECT", num))
        if err != nil {
            log.Println("select failed:", err)
            return
        }
    
    
        log.Println("select:",v)
    
    }
    
    func batchSADD(){
        option := redis.DialPassword("123456")
        c, err := redis.Dial("tcp", redisServer, option)
        if err != nil {
            log.Println("connect server failed:", err)
            return
        }
    
        defer c.Close()
    
        ret, err := redis.String(c.Do("SELECT", 3))
        if err != nil {
            log.Println("select failed:", err)
            return
        }
    
        log.Println("select:",ret)
    
        setKey := "myset"
        args := []interface{}{setKey}
        args = append(args, "10.1")
        args = append(args, "10.2")
        v, err := redis.Int64(c.Do("SADD", args...))
        if err != nil {
            log.Println("SADD failed:", err)
            return
        }
    
        log.Println("sadd:",v)
    }
    
    
    func batchSADD2(){
        option := redis.DialPassword("123456")
        c, err := redis.Dial("tcp", redisServer, option)
        if err != nil {
            log.Println("connect server failed:", err)
            return
        }
    
        defer c.Close()
    
        setKey := "myset"
        args := []interface{}{setKey}
        args = append(args, "10.5")
        args = append(args, "10.6")
        v, err := redis.Int64(c.Do("SADD", args...))
        if err != nil {
            log.Println("SADD failed:", err)
            return
        }
    
        log.Println("sadd:",v)
    }

/\*  
firt sadd to db 3

second sadd to db 0

\*/

output结果：

> 127.0.0.1:6379> SMEMBERS myset  
> 1) “10.6”  
> 2) “10.1”  
> 3) “10.5”  
> 4) “10.4”  
> 5) “10.2”  
> 6) “10.3”  
> 127.0.0.1:6379> select 3  
> OK  
> 127.0.0.1:6379\[3\]> SMEMBERS myset  
> 1) “10.1”  
> 2) “10.2”  
> 127.0.0.1:6379\[3\]>

## 参考 ##

[http://redisdoc.com/connection/select.html][http_redisdoc.com_connection_select.html]

[http_redisdoc.com_connection_select.html]: http://redisdoc.com/connection/select.html