Golang DB.Get方法代码示例

func (ahr AddHashRequest) Execute(database *levigo.DB, ro *levigo.ReadOptions, wo *levigo.WriteOptions) (*kminvalues.KMinValues, error) {
	if ahr.Key == "" {
		return nil, NoKeySpecified
	}

	keyBytes := []byte(ahr.Key)

	data, err := database.Get(ro, keyBytes)
	if err != nil {
		return nil, err
	}

	kmv, err := kminvalues.KMinValuesFromBytes(data)
	if err != nil {
		if len(data) == 0 {
			kmv = kminvalues.NewKMinValues(*defaultSize)
		} else {
			return nil, err
		}
	}
	kmv.AddHash(ahr.Hash)

	err = database.Put(wo, keyBytes, kmv.Bytes())
	return kmv, err
}

func AddProc(procID int, db *levigo.DB) error {
	ro := levigo.NewReadOptions()
	wo := levigo.NewWriteOptions()

	data, err := db.Get(ro, []byte("procs"))
	spdata := bytes.Split(data, []byte(":"))

	for i, e := range spdata {

		if string(e) != "" {
			fmt.Println("ProcID: #", i, string(e))
			pid, err := strconv.Atoi(string(e))
			if err != nil {
				return err
			}
			if pid == procID {
				return errors.New("Process already exists")
			}
			if isProcAlive(pid) == false {
				removeProc(pid, db)
			}
		}

		if err != nil {
			return err
		}
	}

	strdata := string(data)
	strdata = strdata + ":" + strconv.Itoa(procID)

	err = db.Put(wo, []byte("procs"), []byte(strdata))
	return err
}

func getPlaylistFromDB(db *levigo.DB) []playListItem {
	log.Println("Loading Playlist from file...")

	ro := levigo.NewReadOptions()

	data, err := db.Get(ro, []byte("playlist"))
	if err != nil {
		log.Fatal(err)
	}

	p := bytes.NewBuffer(data)

	dec := gob.NewDecoder(p)

	var playlist []playListItem
	//we must decode into a pointer, so we'll take the address of e
	err = dec.Decode(&playlist)
	if err != nil {
		log.Print(err)
		playlist = []playListItem{}
	}

	log.Println("Loaded ", len(playlist), " items into playlist")
	log.Println(playlist)
	return playlist

}

func loadUsers(db *levigo.DB) map[string]User {
	log.Println("Loading Users from file...")

	ro := levigo.NewReadOptions()

	data, err := db.Get(ro, []byte("Users"))
	if err != nil {
		log.Fatal(err)
	}

	p := bytes.NewBuffer(data)

	dec := gob.NewDecoder(p)

	var users map[string]User
	//we must decode into a pointer, so we'll take the address of e
	err = dec.Decode(&users)
	if err != nil {
		log.Print(err)
		users = map[string]User{}
	}

	log.Println("Loaded ", len(users), " users")
	log.Printf("%+v", users)
	return users

}

// Fetch a Tx by hash
func GetTx(db *levigo.DB, txHash string) (tx *Tx, err error) {
	ro := levigo.NewReadOptions()
	defer ro.Close()
	txKey, blockErr := db.Get(ro, []byte(fmt.Sprintf("tx!%s", txHash)))
	if blockErr != nil {
		err = errors.New("Tx not found")
		return
	}

	txData, blockErr := db.Get(ro, txKey)
	if blockErr != nil {
		err = errors.New("Tx not found")
		return
	}

	tx = new(Tx)
	err = json.Unmarshal(txData, tx)
	if err != nil {
		return
	}

	for txo_index, txo := range tx.TxOuts {
		txo.Spent, _ = GetTxoSpent(db, txo.Addr, tx.Hash, txo_index)
	}

	return
}

// Return the last height processed
func GetLastHeight(db *levigo.DB) (lastHeight uint, err error) {
	ro := levigo.NewReadOptions()
	defer ro.Close()
	lastHeightRaw, _ := db.Get(ro, []byte("last-height"))
	lastHeightInt, _ := strconv.Atoi(string(lastHeightRaw[:]))
	lastHeight = uint(lastHeightInt)
	return
}

func AddIndex(index [2]string, key []byte, indexDb *levigo.DB, wb *levigo.WriteBatch) error {
	searchKey := []byte(index[0] + "~" + index[1])
	keys, err := indexDb.Get(LReadOptions, searchKey)
	if err != nil {
		return err
	}
	keys = appendDataKey(keys, key)
	wb.Put(searchKey, keys)
	return nil
}

/*
GetVal gets value of Key from provided db handle.
*/
func GetVal(key string, db *levigo.DB) string {
	reader := levigo.NewReadOptions()
	defer reader.Close()

	data, err := db.Get(reader, []byte(key))
	if err != nil {
		golerror.Boohoo("Key "+key+" query failed.", false)
		return ""
	}
	return string(data)
}

func (gr GetRequest) Execute(database *levigo.DB, ro *levigo.ReadOptions, wo *levigo.WriteOptions) (*KMinValues, error) {
	if gr.Key == "" {
		return nil, NoKeySpecified
	}

	data, err := database.Get(ro, []byte(gr.Key))
	if err != nil {
		return nil, err
	}

	// TODO: add error handling in FromBytes
	kmv := KMinValuesFromBytes(data)
	return kmv, nil
}

// TODO: refactor with above.
func RemoveIndex(index [2]string, key []byte, indexDb *levigo.DB, wb *levigo.WriteBatch) error {
	searchKey := []byte(index[0] + "~" + index[1])
	keys, err := indexDb.Get(LReadOptions, searchKey)
	if err != nil {
		return err
	}
	keys = removeDataKey(keys, key)
	if len(keys) > 0 {
		wb.Put(searchKey, keys)
	} else {
		wb.Delete(searchKey)
	}
	return nil
}

// Return block hash in the main chain given the height
func GetBlockHashByHeight(db *levigo.DB, blockHeight uint) (hash string, err error) {
	ro := levigo.NewReadOptions()
	defer ro.Close()
	blocks, _ := GetRange(db, []byte(fmt.Sprintf("bl!height!%v!", blockHeight)), []byte(fmt.Sprintf("bl!height!%v!\xff", blockHeight)))
	for _, bl := range blocks {
		blStatus, _ := db.Get(ro, []byte(fmt.Sprintf("bl!%v!main", bl.Value)))
		blStatus2, _ := strconv.Atoi(string(blStatus[:]))
		if blStatus2 == 1 {
			hash = bl.Value
			return
		}
	}
	err = errors.New("Block not found")
	return
}

// Read the datastore version of a leveldb instance.
func readLayoutVersion(store *dataStore, ldb *levigo.DB) (uint32, error) {
	buf, err := ldb.Get(store.readOpts, []byte{VERSION_KEY})
	if err != nil {
		return 0, err
	}
	if len(buf) == 0 {
		return 0, nil
	}
	r := bytes.NewBuffer(buf)
	decoder := gob.NewDecoder(r)
	var v uint32
	err = decoder.Decode(&v)
	if err != nil {
		return 0, err
	}
	return v, nil
}

func GetSentByAddress(db *levigo.DB, addr string) (total uint, err error) {
	total = uint(0)
	ro := levigo.NewReadOptions()
	defer ro.Close()
	start := []byte(fmt.Sprintf("%s-txo!", addr))
	end := []byte(fmt.Sprintf("%s-txo!\xff", addr))
	txos, _ := GetRange(db, start, end)
	for _, txo := range txos {
		log.Println(txo.Key)
		new_key := strings.Replace(txo.Key, "-txo", "-txo-spent", 1)
		log.Println(new_key)
		r, _ := db.Get(ro, []byte(new_key))
		log.Println(string(r[:]))
		val, _ := strconv.Atoi(txo.Value)
		total += uint(val)
	}
	return
}

// Fetch a single block by hash
func GetBlock(db *levigo.DB, blockHash string, fetchTx bool) (block *Block, err error) {
	ro := levigo.NewReadOptions()
	defer ro.Close()
	blockDataRaw, blockErr := db.Get(ro, []byte(fmt.Sprintf("bl!%s", blockHash)))
	if blockErr != nil {
		err = errors.New("Block not found")
		return
	}

	//blockStatus, _ := db.Get(ro, []byte(fmt.Sprintf("bl!%v!main", blockHash)))
	//blockPrv, _ := db.Get(ro, []byte(fmt.Sprintf("bl!%v!prv", blockHash)))

	if len(blockDataRaw) == 0 {
		err = errors.New("Block not found")
		return
	}

	block = new(Block)
	err = json.Unmarshal(blockDataRaw, block)
	if err != nil {
		return
	}

	if fetchTx {

		blockNxts, _ := GetRange(db, []byte(fmt.Sprintf("bl!%v!nxt!", block.Hash)), []byte(fmt.Sprintf("bl!%v!nxt!\xff", block.Hash)))
		for _, nxt := range blockNxts {
			blStatus, _ := db.Get(ro, []byte(fmt.Sprintf("bl!%v!main", nxt.Value)))
			blStatus2, _ := strconv.Atoi(string(blStatus[:]))
			if blStatus2 == 1 {
				block.Next = nxt.Value
			}
		}
		txs_kv, _ := GetRange(db, []byte(fmt.Sprintf("bl!%v!tx!", block.Hash)), []byte(fmt.Sprintf("bl!%v!tx!\xff", block.Hash)))

		for _, tx_kv := range txs_kv {
			tx, _ := GetTxFromKv(tx_kv)
			block.Txs = append(block.Txs, tx)
		}
	}

	return
}

func ListProcs(db *levigo.DB) (map[int]int, error) {
	ro := levigo.NewReadOptions()
	procs, err := db.Get(ro, []byte("procs"))

	if err != nil {
		return map[int]int{}, err
	}

	procs_arr := strings.Split(string(procs), ":")
	var procs_arr2 = map[int]int{}
	for _, p := range procs_arr {
		status, err := db.Get(ro, []byte("status:"+p))
		if err == nil {
			p_int, _ := strconv.Atoi(p)
			procs_arr2[p_int], _ = strconv.Atoi(string(status))
		}
	}
	return procs_arr2, err

}