Golang DB.Put方法代码示例

// write to leveldb immediately
func cacheStore(db *leveldb.DB, node *osmpbf.Node) {
	id, val := formatLevelDB(node)
	err := db.Put([]byte(id), []byte(val), nil)
	if err != nil {
		log.Fatal(err)
	}
}

func saveItem(db *leveldb.DB, it *gohn.Item) {
	pbmsg, err := proto.Marshal(it)
	check(err)
	key := []byte(strconv.Itoa(int(it.GetId())))
	err = db.Put(key, pbmsg, nil)
	check(err)
}

/*
	/Put the DATABASE
	/Write the Key and Value
*/
func dbPut(dbObj *leveldb.DB, putData string, putDBKey []byte) int {
	var result int = 0

	putError := dbObj.Put([]byte(putDBKey), []byte(putData), nil)
	if putError != nil {
		result = 1
	}
	return result
}

func setVersion(db *leveldb.DB, version int64, wo *opt.WriteOptions) error {
	buf := make([]byte, 8)
	order.PutUint64(buf, uint64(version))
	err := db.Put([]byte(versionKey), buf, wo)
	if err != nil {
		clog.Errorf("Couldn't write version!")
		return err
	}
	return nil
}

func levelDbWrite(db *leveldb.DB,
	key uint64, offset uint32, size uint32) error {
	bytes := make([]byte, 16)
	util.Uint64toBytes(bytes[0:8], key)
	util.Uint32toBytes(bytes[8:12], offset)
	util.Uint32toBytes(bytes[12:16], size)
	if err := db.Put(bytes[0:8], bytes[8:16], nil); err != nil {
		return fmt.Errorf("failed to write leveldb: %v", err)
	}
	return nil
}

func saveVideos(db *leveldb.DB, videos Videos) {
	for _, video := range videos {
		data, _ := db.Get([]byte(video.Url), nil)

		if len(data) == 0 {
			encoded, _ := json.Marshal(video)

			_ = db.Put([]byte(video.Url), []byte(encoded), nil)
		}
	}
}

func (rn *RaftNode) fSaveTerm(i int) {
	var currentTermDB *leveldb.DB
	var err error
	currentTermDB, err = leveldb.OpenFile(PATH+"/currentTerm", nil)
	for err != nil {
		currentTermDB, err = leveldb.OpenFile(PATH+"/currentTerm", nil)
	}
	// fmt.Println("sad", currentTermDB, reflect.TypeOf(currentTermDB), err, reflect.TypeOf(err))
	defer currentTermDB.Close()
	currentTermDB.Put([]byte(strconv.Itoa(rn.sm.ServerID)), []byte(strconv.Itoa(i)), nil)

}

func (rn *RaftNode) fSaveVotedFor(i int) {

	var votedForDB *leveldb.DB
	var err error
	votedForDB, err = leveldb.OpenFile(PATH+"/currentTerm", nil)
	for err != nil {
		votedForDB, err = leveldb.OpenFile(PATH+"/currentTerm", nil)
	}

	defer votedForDB.Close()
	votedForDB.Put([]byte(strconv.Itoa(rn.sm.ServerID)), []byte(strconv.Itoa(i)), nil)
}

//Write entry to leveldb
func (e *LogItem) writeToDB(db *leveldb.DB) error {
	var network bytes.Buffer
	enc := gob.NewEncoder(&network)
	err := enc.Encode(e)
	if err != nil {
		panic("gob error: " + err.Error())
	}
	buf := make([]byte, 8)
	binary.LittleEndian.PutUint64(buf, e.Index)
	err = db.Put(buf, []byte(network.String()), nil)
	return err

}

func InjectLevelDB(jsEngine *JSEngine, db *leveldb.DB) {
	jsEngine.Run("var db = {};")
	dbValue, _ := jsEngine.Get("db")
	dbObj := dbValue.Object()
	dbObj.Set("put", func(call otto.FunctionCall) otto.Value {
		key, err := call.Argument(0).ToString()
		if err != nil {
			log.Println("Error:", err.Error())
			return otto.FalseValue()
		}
		value, err := call.Argument(1).ToString()
		if err != nil {
			log.Println("Error:", err.Error())
			return otto.FalseValue()
		}

		err = db.Put([]byte(key), []byte(value), nil)
		if err != nil {
			log.Println("Error:", err.Error())
			return otto.FalseValue()
		}
		return otto.TrueValue()
	})
	dbObj.Set("get", func(call otto.FunctionCall) otto.Value {
		key, err := call.Argument(0).ToString()
		if err != nil {
			log.Println("Error:", err.Error())
			return otto.FalseValue()
		}
		data, err := db.Get([]byte(key), nil)
		if err != nil {
			log.Println("Error:", err.Error())
			return otto.FalseValue()
		}
		v, _ := otto.ToValue(string(data))
		return v
	})
	dbObj.Set("remove", func(call otto.FunctionCall) otto.Value {
		key, err := call.Argument(0).ToString()
		if err != nil {
			log.Println("Error:", err.Error())
			return otto.FalseValue()
		}
		err = db.Delete([]byte(key), nil)
		if err != nil {
			log.Println("Error:", err.Error())
			return otto.FalseValue()
		}
		return otto.TrueValue()
	})
}

func doOperation(fileNm []byte, finalByt []byte, cmdTyp string, fileDB *leveldb.DB, wo *opt.WriteOptions) {

	var err error

	mutex.Lock()
	switch cmdTyp {
	case "write":
		err = fileDB.Put(fileNm, finalByt, nil)
	case "delete":
		err = fileDB.Delete([]byte(fileNm), wo)
	}
	mutex.Unlock()
	checkError(err)
}

func doWrite(cmd *utils.Cmd, db *leveldb.DB) *utils.Cmd {

	dirMutex.Lock()
	defer dirMutex.Unlock()
	fi := dir[cmd.Filename]
	if fi != nil {
		if fi.Timer != nil {
			fi.Timer.Stop()
			fi.Timer = nil
		}
	} else {
		fi = &Metadata{}
	}

	if cmd.Exptime != 0 {
		dur := time.Duration(cmd.Exptime) * time.Second
		fi.Exptime = time.Now().Add(dur)
		// create timer for deletion
		timerFunc := func(name string, ver int64) func() {
			return func() {
				doDelete(&utils.Cmd{Type: "delete",
					Filename: name,
					Version:  ver}, db)
			}
		}(cmd.Filename, gversion)

		fi.Timer = time.AfterFunc(dur, timerFunc)

	}
	err := db.Put([]byte(cmd.Filename), cmd.Content, nil)

	if err != nil {
		log.Fatal(err)

	}

	gversion += 1
	fi.Version = gversion
	fi.Numbytes = cmd.Numbytes
	dir[cmd.Filename] = fi

	return &utils.Cmd{Type: "O", Version: gversion}
}

func applyLog(sc *ServerConfig, store *leveldb.DB) {
	timer := time.NewTimer(500 * time.Millisecond)
	var er error
	for {
		<-timer.C
		dbg4.Println(sc.basicCluster.Mypid, "logAplied", sc.commitIndex, sc.lastApplied, sc.votedFor)
		for i := sc.lastApplied + 1; i < sc.commitIndex; i++ {
			logMsg := sc.log[i].Msg.(string)
			splits := strings.Split(logMsg, " ")
			//dbg5.Println(splits)
			if splits[0] == "set" {
				er = store.Put([]byte(splits[1]), []byte(splits[2]), nil)
				//dbg5.Println("storing", er)
				if er == nil {
					sc.lastApplied += 1
				}
			}
		}
		timer = time.NewTimer(500 * time.Millisecond)
	}
}

func update(db *leveldb.DB, id protocol.DeviceID, addrs []address) {
	var newAddrs addressList

	val, err := db.Get(id[:], nil)
	if err == nil {
		newAddrs.UnmarshalXDR(val)
	}

nextAddr:
	for _, newAddr := range addrs {
		for i, exAddr := range newAddrs.addresses {
			if bytes.Compare(newAddr.ip, exAddr.ip) == 0 {
				newAddrs.addresses[i] = newAddr
				continue nextAddr
			}
		}
		newAddrs.addresses = append(newAddrs.addresses, newAddr)
	}

	db.Put(id[:], newAddrs.MarshalXDR(), nil)
}

func clean(statsLog io.Writer, db *leveldb.DB) {
	for {
		now := next(cacheLimitSeconds)
		nowSecs := now.Unix()

		var kept, deleted int64
		iter := db.NewIterator(nil, nil)
		for iter.Next() {
			var addrs addressList
			addrs.UnmarshalXDR(iter.Value())

			// Remove expired addresses
			newAddrs := addrs.addresses
			for i := 0; i < len(newAddrs); i++ {
				if nowSecs-newAddrs[i].seen > cacheLimitSeconds {
					newAddrs[i] = newAddrs[len(newAddrs)-1]
					newAddrs = newAddrs[:len(newAddrs)-1]
				}
			}

			// Delete empty records
			if len(newAddrs) == 0 {
				db.Delete(iter.Key(), nil)
				deleted++
				continue
			}

			// Update changed records
			if len(newAddrs) != len(addrs.addresses) {
				addrs.addresses = newAddrs
				db.Put(iter.Key(), addrs.MarshalXDR(), nil)
			}
			kept++
		}
		iter.Release()

		fmt.Fprintf(statsLog, "%d Kept:%d Deleted:%d Took:%0.04fs\n", nowSecs, kept, deleted, time.Since(now).Seconds())
	}
}