コード例 #1
0
ファイル: cmd_script_test.go プロジェクト: Abioy/ledisdb
func TestCmdEval(t *testing.T) {
	c := getTestConn()
	defer c.Close()

	if v, err := ledis.Strings(c.Do("eval", "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}", 2, "key1", "key2", "first", "second")); err != nil {
		t.Fatal(err)
	} else if !reflect.DeepEqual(v, []string{"key1", "key2", "first", "second"}) {
		t.Fatal(fmt.Sprintf("%v", v))
	}

	if v, err := ledis.Strings(c.Do("eval", "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}", 2, "key1", "key2", "first", "second")); err != nil {
		t.Fatal(err)
	} else if !reflect.DeepEqual(v, []string{"key1", "key2", "first", "second"}) {
		t.Fatal(fmt.Sprintf("%v", v))
	}

	var sha1 string
	var err error
	if sha1, err = ledis.String(c.Do("script", "load", "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}")); err != nil {
		t.Fatal(err)
	} else if len(sha1) != 40 {
		t.Fatal(sha1)
	}

	if v, err := ledis.Strings(c.Do("evalsha", sha1, 2, "key1", "key2", "first", "second")); err != nil {
		t.Fatal(err)
	} else if !reflect.DeepEqual(v, []string{"key1", "key2", "first", "second"}) {
		t.Fatal(fmt.Sprintf("%v", v))
	}

	if ay, err := ledis.Values(c.Do("script", "exists", sha1, "01234567890123456789")); err != nil {
		t.Fatal(err)
	} else if !reflect.DeepEqual(ay, []interface{}{int64(1), int64(0)}) {
		t.Fatal(fmt.Sprintf("%v", ay))
	}

	if ok, err := ledis.String(c.Do("script", "flush")); err != nil {
		t.Fatal(err)
	} else if ok != "OK" {
		t.Fatal(ok)
	}

	if ay, err := ledis.Values(c.Do("script", "exists", sha1)); err != nil {
		t.Fatal(err)
	} else if !reflect.DeepEqual(ay, []interface{}{int64(0)}) {
		t.Fatal(fmt.Sprintf("%v", ay))
	}
}
コード例 #2
0
ファイル: cmd_kv_test.go プロジェクト: Abioy/ledisdb
func TestKVM(t *testing.T) {
	c := getTestConn()
	defer c.Close()

	if ok, err := ledis.String(c.Do("mset", "a", "1", "b", "2")); err != nil {
		t.Fatal(err)
	} else if ok != OK {
		t.Fatal(ok)
	}

	if v, err := ledis.MultiBulk(c.Do("mget", "a", "b", "c")); err != nil {
		t.Fatal(err)
	} else if len(v) != 3 {
		t.Fatal(len(v))
	} else {
		if vv, ok := v[0].([]byte); !ok || string(vv) != "1" {
			t.Fatal("not 1")
		}

		if vv, ok := v[1].([]byte); !ok || string(vv) != "2" {
			t.Fatal("not 2")
		}

		if v[2] != nil {
			t.Fatal("must nil")
		}
	}
}
コード例 #3
0
ファイル: cmd_hash_test.go プロジェクト: nzinfo/ledisdb
func TestHashM(t *testing.T) {
	c := getTestConn()
	defer c.Close()

	key := []byte("b")
	if ok, err := ledis.String(c.Do("hmset", key, 1, 1, 2, 2, 3, 3)); err != nil {
		t.Fatal(err)
	} else if ok != OK {
		t.Fatal(ok)
	}

	if n, err := ledis.Int(c.Do("hlen", key)); err != nil {
		t.Fatal(err)
	} else if n != 3 {
		t.Fatal(n)
	}

	if v, err := ledis.MultiBulk(c.Do("hmget", key, 1, 2, 3, 4)); err != nil {
		t.Fatal(err)
	} else {
		if err := testHashArray(v, 1, 2, 3, 0); err != nil {
			t.Fatal(err)
		}
	}

	if n, err := ledis.Int(c.Do("hdel", key, 1, 2, 3, 4)); err != nil {
		t.Fatal(err)
	} else if n != 3 {
		t.Fatal(n)
	}

	if n, err := ledis.Int(c.Do("hlen", key)); err != nil {
		t.Fatal(err)
	} else if n != 0 {
		t.Fatal(n)
	}

	if v, err := ledis.MultiBulk(c.Do("hmget", key, 1, 2, 3, 4)); err != nil {
		t.Fatal(err)
	} else {
		if err := testHashArray(v, 0, 0, 0, 0); err != nil {
			t.Fatal(err)
		}
	}

	if n, err := ledis.Int(c.Do("hlen", key)); err != nil {
		t.Fatal(err)
	} else if n != 0 {
		t.Fatal(n)
	}
}
コード例 #4
0
ファイル: cmd_hash_test.go プロジェクト: nzinfo/ledisdb
func TestHashGetAll(t *testing.T) {
	c := getTestConn()
	defer c.Close()

	key := []byte("d")

	if ok, err := ledis.String(c.Do("hmset", key, 1, 1, 2, 2, 3, 3)); err != nil {
		t.Fatal(err)
	} else if ok != OK {
		t.Fatal(ok)
	}

	if v, err := ledis.MultiBulk(c.Do("hgetall", key)); err != nil {
		t.Fatal(err)
	} else {
		if err := testHashArray(v, 1, 1, 2, 2, 3, 3); err != nil {
			t.Fatal(err)
		}
	}

	if v, err := ledis.MultiBulk(c.Do("hkeys", key)); err != nil {
		t.Fatal(err)
	} else {
		if err := testHashArray(v, 1, 2, 3); err != nil {
			t.Fatal(err)
		}
	}

	if v, err := ledis.MultiBulk(c.Do("hvals", key)); err != nil {
		t.Fatal(err)
	} else {
		if err := testHashArray(v, 1, 2, 3); err != nil {
			t.Fatal(err)
		}
	}

	if n, err := ledis.Int(c.Do("hclear", key)); err != nil {
		t.Fatal(err)
	} else if n != 3 {
		t.Fatal(n)
	}

	if n, err := ledis.Int(c.Do("hlen", key)); err != nil {
		t.Fatal(err)
	} else if n != 0 {
		t.Fatal(n)
	}
}
コード例 #5
0
ファイル: benchmark.go プロジェクト: holys-archive/benchmark
func setRead() {
	c := client.Get()

	var first bool = true

	var cursor []byte
	var total int64 = 0
	t1 := time.Now().UnixNano()

	for string(cursor) != "" || first {
		ay, err := ledis.Values(c.Do("scan", cursor, "count", *count))
		if err != nil {
			fmt.Printf("do scan err %s", err.Error())
			return
		} else if len(ay) != 2 {
			fmt.Println("scan result invalid")
			return
		}

		cursor = ay[0].([]byte)
		data, err := ledis.Strings(ay[1], nil)
		if err != nil {
			fmt.Println(err)
			return
		}

		for _, k := range data {
			ledis.String(c.Do("get", []byte(k)))
			total++

			if total%100000 == 0 {
				fmt.Println(total)
				fmt.Println(time.Now().Format("2006/01/02 15:04:05"))
			}
		}

		first = false
	}

	t2 := time.Now().UnixNano()
	delta := float64(t2-t1) / float64(time.Second)
	fmt.Printf("total %d kv keys , consumed %f seconds \n", total, delta)
}
コード例 #6
0
ファイル: cmd_kv_test.go プロジェクト: Abioy/ledisdb
func TestKV(t *testing.T) {
	c := getTestConn()
	defer c.Close()

	if ok, err := ledis.String(c.Do("set", "a", "1234")); err != nil {
		t.Fatal(err)
	} else if ok != OK {
		t.Fatal(ok)
	}

	if n, err := ledis.Int(c.Do("setnx", "a", "123")); err != nil {
		t.Fatal(err)
	} else if n != 0 {
		t.Fatal(n)
	}

	if n, err := ledis.Int(c.Do("setnx", "b", "123")); err != nil {
		t.Fatal(err)
	} else if n != 1 {
		t.Fatal(n)
	}

	if v, err := ledis.String(c.Do("get", "a")); err != nil {
		t.Fatal(err)
	} else if v != "1234" {
		t.Fatal(v)
	}

	if v, err := ledis.String(c.Do("getset", "a", "123")); err != nil {
		t.Fatal(err)
	} else if v != "1234" {
		t.Fatal(v)
	}

	if v, err := ledis.String(c.Do("get", "a")); err != nil {
		t.Fatal(err)
	} else if v != "123" {
		t.Fatal(v)
	}

	if n, err := ledis.Int(c.Do("exists", "a")); err != nil {
		t.Fatal(err)
	} else if n != 1 {
		t.Fatal(n)
	}

	if n, err := ledis.Int(c.Do("exists", "empty_key_test")); err != nil {
		t.Fatal(err)
	} else if n != 0 {
		t.Fatal(n)
	}

	if _, err := ledis.Int(c.Do("del", "a", "b")); err != nil {
		t.Fatal(err)
	}

	if n, err := ledis.Int(c.Do("exists", "a")); err != nil {
		t.Fatal(err)
	} else if n != 0 {
		t.Fatal(n)
	}

	if n, err := ledis.Int(c.Do("exists", "b")); err != nil {
		t.Fatal(err)
	} else if n != 0 {
		t.Fatal(n)
	}
}
コード例 #7
0
ファイル: cmd_bit_test.go プロジェクト: nzinfo/ledisdb
func testBitOpt(t *testing.T) {
	c := getTestConn()
	defer c.Close()

	dstk := []byte("bin_op_res")
	kmiss := []byte("bin_op_miss")

	k0 := []byte("bin_op_0")
	k1 := []byte("bin_op_1")
	c.Do("bmsetbit", k0, 10, 1, 30, 1, 50, 1, 70, 1, 100, 1)
	c.Do("bmsetbit", k1, 20, 1, 40, 1, 60, 1, 80, 1, 100, 1)

	//	case - lack of args
	//	todo ...

	//	case - 'not' on inexisting key
	if blen, err := ledis.Int(
		c.Do("bopt", "not", dstk, kmiss)); err != nil {
		t.Fatal(err)
	} else if blen != 0 {
		t.Fatal(blen)
	}

	if v, _ := ledis.String(c.Do("bget", dstk)); v != "" {
		t.Fatal(v)
	}

	//	case - 'and', 'or', 'xor' with inexisting key
	opts := []string{"and", "or", "xor"}
	for _, op := range opts {
		if blen, err := ledis.Int(
			c.Do("bopt", op, dstk, kmiss, k0)); err != nil {
			t.Fatal(err)
		} else if blen != 0 {
			t.Fatal(blen)
		}
	}

	//	case - 'and'
	if blen, err := ledis.Int(
		c.Do("bopt", "and", dstk, k0, k1)); err != nil {
		t.Fatal(err)
	} else if blen != 101 {
		t.Fatal(blen)
	}

	if v, _ := ledis.Int(c.Do("bgetbit", dstk, 100)); v != 1 {
		t.Fatal(v)
	}

	if v, _ := ledis.Int(c.Do("bgetbit", dstk, 20)); v != 0 {
		t.Fatal(v)
	}

	if v, _ := ledis.Int(c.Do("bgetbit", dstk, 40)); v != 0 {
		t.Fatal(v)
	}

	//	case - 'or'
	if blen, err := ledis.Int(
		c.Do("bopt", "or", dstk, k0, k1)); err != nil {
		t.Fatal(err)
	} else if blen != 101 {
		t.Fatal(blen)
	}

	if v, _ := ledis.Int(c.Do("bgetbit", dstk, 100)); v != 1 {
		t.Fatal(v)
	}

	if v, _ := ledis.Int(c.Do("bgetbit", dstk, 20)); v != 1 {
		t.Fatal(v)
	}

	if v, _ := ledis.Int(c.Do("bgetbit", dstk, 40)); v != 1 {
		t.Fatal(v)
	}

	//	case - 'xor'
	if blen, err := ledis.Int(
		c.Do("bopt", "xor", dstk, k0, k1)); err != nil {
		t.Fatal(err)
	} else if blen != 101 {
		t.Fatal(blen)
	}

	if v, _ := ledis.Int(c.Do("bgetbit", dstk, 100)); v != 0 {
		t.Fatal(v)
	}

	if v, _ := ledis.Int(c.Do("bgetbit", dstk, 20)); v != 1 {
		t.Fatal(v)
	}

	if v, _ := ledis.Int(c.Do("bgetbit", dstk, 40)); v != 1 {
		t.Fatal(v)
	}

	return
}