Redis select选择数据库

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
7. "10.1"
8. "10.2"
   
   127.0.0.1:6379[3]>

参考

http://redisdoc.com/connection/select.html