Redigo: हैश समर्थन जोड़ें

Redigo HMSET सहित किसी भी कमांड को निष्पादित कर सकता है। क्या आप कोड की वह पंक्ति साझा कर सकते हैं जहां आप एचएमएसईटी लागू करते हैं?

package main

import (
    "fmt"
    "github.com/garyburd/redigo/redis"
    "log"
)

var (
    conn redis.Conn
)

// Connect to Redis
func init() {
    var err error
    conn, err = redis.Dial("tcp", ":6379")
    if err != nil {
        log.Fatalf("Couldn't connect to Redis: %v\n", err)
    }
}

func main() {
    defer conn.Close()

    stockData := map[string]map[string]string{
        "GOOG": {"company_name":"Google Inc.", "open_price":"803.99", "ask_price":"795.50", "close_price":"802.66", "bid_price":"793.36"},
        "MSFT": {"ask_price":"N/A", "open_price":"28.30", "company_name":"Microsoft Corpora", "bid_price":"28.50", "close_price":"28.37"},
    }

    conn.Send("HMSET", "stocks")
    // conn.Send("HMSET")
    // conn.Send("stocks")
    // var cmd []interface{}
    for sym, row := range stockData {
        for colName, val := range row {
            key := sym + ":" + colName
            // cmd = append(cmd, key, val)
            conn.Send(key, val)
        }
    }
    // conn.Send("HMSET", cmd...)
    reply, err := conn.Do("EXEC")
    if err != nil {
        log.Fatalf("Error setting hash: %v\n", err)
    }
    fmt.Printf("reply == %+v\n", reply)
}

टिप्पणियाँ उन अन्य संस्करणों को प्रकट करती हैं जिन्हें मैंने भी आज़माया है, जैसे कि (लगभग) सभी कमांड एक साथ conn.Send("HMSET", cmd...) साथ भेजना। conn.Send("HMSET", "stocks", cmd...) संकलित नहीं करता है।

कोई विचार मैं गलत क्या कर रहा हूँ?

निम्नलिखित उदाहरण दिखाते हैं कि प्रत्येक प्रतीक के लिए एक हैश कैसे बनाया जाता है।

package main

import (
    "github.com/garyburd/redigo/redis"
    "log"
)

func main() {
    conn, err := redis.Dial("tcp", ":6379")
    if err != nil {
        log.Fatalf("Couldn't connect to Redis: %v\n", err)
    }
    defer conn.Close()

    stockData := map[string]map[string]string{
        "GOOG": {"company_name": "Google Inc.", "open_price": "803.99", "ask_price": "795.50", "close_price": "802.66", "bid_price": "793.36"},
        "MSFT": {"ask_price": "N/A", "open_price": "28.30", "company_name": "Microsoft Corpora", "bid_price": "28.50", "close_price": "28.37"},
    }

    // Example 1: Write command arguments out explicitly.

    for sym, row := range stockData {
        if _, err := conn.Do("HMSET", sym,
            "company_name", row["company_name"],
            "open_price", row["open_price"],
            "ask_price", row["ask_price"],
            "bid_price", row["bid_price"]); err != nil {
            log.Fatal(err)
        }
    }

    printAndDel(conn, "example 1", stockData)

    // Example 2: Construct command arguments using range over a row map.

    for sym, row := range stockData {
        args := []interface{}{sym}
        for k, v := range row {
            args = append(args, k, v)
        }
        if _, err := conn.Do("HMSET", args...); err != nil {
            log.Fatal(err)
        }
    }

    printAndDel(conn, "example 2", stockData)

    // Example 3: Construct command arguments using Redigo helper function.

    for sym, row := range stockData {
        if _, err := conn.Do("HMSET", redis.Args{sym}.AddFlat(row)...); err != nil {
            log.Fatal(err)
        }
    }

    printAndDel(conn, "example 3", stockData)
}

func printAndDel(conn redis.Conn, message string, stockData map[string]map[string]string) {
    log.Print(message)
    for sym := range stockData {
        values, err := redis.Values(conn.Do("HGETALL", sym))
        if err != nil {
            log.Fatal(err)
        }
        log.Print(sym)
        for i := 0; i < len(values); i += 2 {
            log.Printf("  %s: %s", values[i], values[i+1])
        }
    }
    for sym := range stockData {
        if _, err := conn.Do("DEL", sym); err != nil {
            log.Fatal(err)
        }
    }
}

यहां एक और उदाहरण है जो मानचित्र के बजाय संरचना का उपयोग करता है। यह उदाहरण डेटा को पिछले उदाहरणों के समान प्रारूप में संग्रहीत करता है।

package main

import (
    "github.com/garyburd/redigo/redis"
    "log"
)

type Stock struct {
    CompanyName string `redis:"company_name"`
    OpenPrice   string `redis:"open_price"`
    AskPrice    string `redis:"ask_price"`
    ClosePrice  string `redis:"close_price"`
    BidPrice    string `redis:"bid_price"`
}

func main() {
    conn, err := redis.Dial("tcp", ":6379")
    if err != nil {
        log.Fatalf("Couldn't connect to Redis: %v\n", err)
    }
    defer conn.Close()

    stockData := map[string]*Stock{
        "GOOG": &Stock{CompanyName: "Google Inc.", OpenPrice: "803.99", AskPrice: "795.50", ClosePrice: "802.66", BidPrice: "793.36"},
        "MSFT": &Stock{AskPrice: "N/A", OpenPrice: "28.30", CompanyName: "Microsoft Corpora", BidPrice: "28.50", ClosePrice: "28.37"},
    }

    for sym, row := range stockData {
        if _, err := conn.Do("HMSET", redis.Args{sym}.AddFlat(row)...); err != nil {
            log.Fatal(err)
        }
    }

    for sym := range stockData {
        values, err := redis.Values(conn.Do("HGETALL", sym))
        if err != nil {
            log.Fatal(err)
        }
        var stock Stock
        if err := redis.ScanStruct(values, &stock); err != nil {
            log.Fatal(err)
        }
        log.Printf("%s: %+v", sym, &stock)
    }
}

महान उदाहरण, धन्यवाद! मैंने कुछ और पढ़ा और ऐसा लगता है कि रेडिस नेस्टेड हैश का समर्थन नहीं करता है, इसलिए मुझे लगता है कि मैं जो करने की कोशिश कर रहा था वह काम नहीं करेगा: एक रेडिस हैश बनाना जिसमें प्रतीकों से स्टॉक डेटा तक एक और हैश होता है। मैं कुछ JSON को एक स्ट्रिंग के रूप में संग्रहीत करने की शायद-अच्छी-पर्याप्त हैक का प्रयास कर सकता हूं क्योंकि वास्तव में मुझे यही चाहिए।

किसी न किसी तरह, मैं यह काम कर पाऊंगा, खासकर आपके द्वारा दिए गए उदाहरणों के साथ। एक बार फिर धन्यवाद!

नेस्टेड हैश समर्थित नहीं हैं। फ्री और शॉर्ट द लिटिल रेडिस बुक रेडिस द्वारा समर्थित प्रकारों का एक अच्छा अवलोकन देता है।

जेएसओएन को रेडिस में स्टोर करना आम बात है। यदि आप केवल गो से डेटा एक्सेस कर रहे हैं, तो नेस्टेड डेटा संग्रहीत करने के लिए एन्कोडिंग/गोब एक और अच्छा विकल्प है।