func ExampleScanSlice() { c, err := dial() if err != nil { fmt.Println(err) return } defer c.Close() c.Send("HMSET", "album:1", "title", "Red", "rating", 5) c.Send("HMSET", "album:2", "title", "Earthbound", "rating", 1) c.Send("HMSET", "album:3", "title", "Beat", "rating", 4) c.Send("LPUSH", "albums", "1") c.Send("LPUSH", "albums", "2") c.Send("LPUSH", "albums", "3") values, err := redis.Values(c.Do("SORT", "albums", "BY", "album:*->rating", "GET", "album:*->title", "GET", "album:*->rating")) if err != nil { fmt.Println(err) return } var albums []struct { Title string Rating int } if err := redis.ScanSlice(values, &albums); err != nil { fmt.Println(err) return } fmt.Printf("%v\n", albums) // Output: // [{Earthbound 1} {Beat 4} {Red 5}] }
func TestBlankCommmand(t *testing.T) { c, err := redistest.Dial() if err != nil { t.Fatalf("error connection to database, %v", err) } defer c.Close() for _, cmd := range testCommands { if err := c.Send(cmd.args[0].(string), cmd.args[1:]...); err != nil { t.Fatalf("Send(%v) returned error %v", cmd.args, err) } } reply, err := redis.Values(c.Do("")) if err != nil { t.Fatalf("Do() returned error %v", err) } if len(reply) != len(testCommands) { t.Fatalf("len(reply)=%d, want %d", len(reply), len(testCommands)) } for i, cmd := range testCommands { actual := reply[i] if !reflect.DeepEqual(actual, cmd.expected) { t.Errorf("Receive(%v) = %v, want %v", cmd.args, actual, cmd.expected) } } }
func ExampleArgs() { c, err := dial() if err != nil { fmt.Println(err) return } defer c.Close() var p1, p2 struct { Title string `redis:"title"` Author string `redis:"author"` Body string `redis:"body"` } p1.Title = "Example" p1.Author = "Gary" p1.Body = "Hello" if _, err := c.Do("HMSET", redis.Args{}.Add("id1").AddFlat(&p1)...); err != nil { fmt.Println(err) return } m := map[string]string{ "title": "Example2", "author": "Steve", "body": "Map", } if _, err := c.Do("HMSET", redis.Args{}.Add("id2").AddFlat(m)...); err != nil { fmt.Println(err) return } for _, id := range []string{"id1", "id2"} { v, err := redis.Values(c.Do("HGETALL", id)) if err != nil { fmt.Println(err) return } if err := redis.ScanStruct(v, &p2); err != nil { fmt.Println(err) return } fmt.Printf("%+v\n", p2) } // Output: // {Title:Example Author:Gary Body:Hello} // {Title:Example2 Author:Steve Body:Map} }
func c_redis_counters(server string, db int) (opentsdb.MultiDataPoint, error) { var md opentsdb.MultiDataPoint conn, err := redis.Dial("tcp", server, redis.DialDatabase(db)) if err != nil { return md, err } defer conn.Close() if _, err := conn.Do("CLIENT", "SETNAME", "scollector"); err != nil { return md, err } cursor := 0 for { vals, err := redis.Values(conn.Do("HSCAN", collect.RedisCountersKey, cursor)) if err != nil { return md, err } if len(vals) != 2 { return md, fmt.Errorf("Unexpected number of values") } cursor, err = redis.Int(vals[0], nil) if err != nil { return md, err } pairs, err := redis.StringMap(vals[1], nil) if err != nil { return md, err } for mts, val := range pairs { parts := strings.Split(mts, ":") if len(parts) != 2 { slog.Errorf("Invalid metric tag set counter: %s", mts) continue } metric := parts[0] tags, err := opentsdb.ParseTags(parts[1]) if err != nil { slog.Errorf("Invalid tags: %s", parts[1]) continue } v, err := strconv.Atoi(val) if err != nil { slog.Errorf("Invalid counter value: %s", val) continue } Add(&md, metric, v, tags, metadata.Counter, metadata.Count, "") } if cursor == 0 { break } } return md, nil }
func int64s(reply interface{}, err error) ([]int64, error) { if err != nil { return nil, slog.Wrap(err) } ints := []int64{} values, err := redis.Values(reply, err) if err != nil { return ints, slog.Wrap(err) } if err := redis.ScanSlice(values, &ints); err != nil { return ints, slog.Wrap(err) } return ints, nil }
func (d *dataAccess) GetMetricMetadata(metric string) (*MetricMetadata, error) { defer collect.StartTimer("redis", opentsdb.TagSet{"op": "GetMetricMeta"})() conn := d.GetConnection() defer conn.Close() v, err := redis.Values(conn.Do("HGETALL", metricMetaKey(metric))) if err != nil { return nil, err } if len(v) == 0 { return nil, nil } mm := &MetricMetadata{} if err := redis.ScanStruct(v, mm); err != nil { return nil, err } return mm, nil }
func ExampleScan() { c, err := dial() if err != nil { fmt.Println(err) return } defer c.Close() c.Send("HMSET", "album:1", "title", "Red", "rating", 5) c.Send("HMSET", "album:2", "title", "Earthbound", "rating", 1) c.Send("HMSET", "album:3", "title", "Beat") c.Send("LPUSH", "albums", "1") c.Send("LPUSH", "albums", "2") c.Send("LPUSH", "albums", "3") values, err := redis.Values(c.Do("SORT", "albums", "BY", "album:*->rating", "GET", "album:*->title", "GET", "album:*->rating")) if err != nil { fmt.Println(err) return } for len(values) > 0 { var title string rating := -1 // initialize to illegal value to detect nil. values, err = redis.Scan(values, &title, &rating) if err != nil { fmt.Println(err) return } if rating == -1 { fmt.Println(title, "not-rated") } else { fmt.Println(title, rating) } } // Output: // Beat not-rated // Earthbound 1 // Red 5 }
func (d *dataAccess) GetMetricTagSets(metric string, tags opentsdb.TagSet) (map[string]int64, error) { defer collect.StartTimer("redis", opentsdb.TagSet{"op": "GetMetricTagSets"})() conn := d.GetConnection() defer conn.Close() var cursor = "0" result := map[string]int64{} for { vals, err := redis.Values(conn.Do(d.HSCAN(), searchMetricTagSetKey(metric), cursor)) if err != nil { return nil, slog.Wrap(err) } cursor, err = redis.String(vals[0], nil) if err != nil { return nil, slog.Wrap(err) } mtss, err := stringInt64Map(vals[1], nil) if err != nil { return nil, slog.Wrap(err) } for mts, t := range mtss { ts, err := opentsdb.ParseTags(mts) if err != nil { return nil, slog.Wrap(err) } if ts.Subset(tags) { result[mts] = t } } if cursor == "" || cursor == "0" { break } } return result, nil }
// TextExecError tests handling of errors in a transaction. See // http://redis.io/topics/transactions for information on how Redis handles // errors in a transaction. func TestExecError(t *testing.T) { c, err := redistest.Dial() if err != nil { t.Fatalf("error connection to database, %v", err) } defer c.Close() // Execute commands that fail before EXEC is called. c.Do("ZADD", "k0", 0, 0) c.Send("MULTI") c.Send("NOTACOMMAND", "k0", 0, 0) c.Send("ZINCRBY", "k0", 0, 0) v, err := c.Do("EXEC") if err == nil { t.Fatalf("EXEC returned values %v, expected error", v) } // Execute commands that fail after EXEC is called. The first command // returns an error. c.Do("ZADD", "k1", 0, 0) c.Send("MULTI") c.Send("HSET", "k1", 0, 0) c.Send("ZINCRBY", "k1", 0, 0) v, err = c.Do("EXEC") if err != nil { t.Fatalf("EXEC returned error %v", err) } vs, err := redis.Values(v, nil) if err != nil { t.Fatalf("Values(v) returned error %v", err) } if len(vs) != 2 { t.Fatalf("len(vs) == %d, want 2", len(vs)) } if _, ok := vs[0].(error); !ok { t.Fatalf("first result is type %T, expected error", vs[0]) } if _, ok := vs[1].([]byte); !ok { t.Fatalf("second result is type %T, expected []byte", vs[2]) } // Execute commands that fail after EXEC is called. The second command // returns an error. c.Do("ZADD", "k2", 0, 0) c.Send("MULTI") c.Send("ZINCRBY", "k2", 0, 0) c.Send("HSET", "k2", 0, 0) v, err = c.Do("EXEC") if err != nil { t.Fatalf("EXEC returned error %v", err) } vs, err = redis.Values(v, nil) if err != nil { t.Fatalf("Values(v) returned error %v", err) } if len(vs) != 2 { t.Fatalf("len(vs) == %d, want 2", len(vs)) } if _, ok := vs[0].([]byte); !ok { t.Fatalf("first result is type %T, expected []byte", vs[0]) } if _, ok := vs[1].(error); !ok { t.Fatalf("second result is type %T, expected error", vs[2]) } }
ve(redis.Ints(nil, nil)), ve([]int(nil), redis.ErrNil), }, { "strings([v1, v2])", ve(redis.Strings([]interface{}{[]byte("v1"), []byte("v2")}, nil)), ve([]string{"v1", "v2"}, nil), }, { "strings(nil)", ve(redis.Strings(nil, nil)), ve([]string(nil), redis.ErrNil), }, { "values([v1, v2])", ve(redis.Values([]interface{}{[]byte("v1"), []byte("v2")}, nil)), ve([]interface{}{[]byte("v1"), []byte("v2")}, nil), }, { "values(nil)", ve(redis.Values(nil, nil)), ve([]interface{}(nil), redis.ErrNil), }, { "float64(1.0)", ve(redis.Float64([]byte("1.0"), nil)), ve(float64(1.0), nil), }, { "float64(nil)", ve(redis.Float64(nil, nil)),