Golang C.leveldb_get函數代碼示例

func (db *LevelDB) Get(key []byte) ([]byte, error) {
	var vlen C.size_t
	var err *C.char
	val := C.leveldb_get(db.db, db.readOpts.Opts, C.CString(string(key)), C.size_t(len(key)), &vlen, &err)
	if err != nil {
		e := &DBError{}
		e.Err = C.GoString(err)
		return nil, e
	}
	if vlen == 0 {
		return nil, nil
	}
	return C.GoBytes(unsafe.Pointer(val), C.int(vlen)), nil
}

func (self *Leveldb) Get(key string, obj interface{}) error {
	cKey := C.CString(key)
	defer C.free(unsafe.Pointer(cKey))
	var valueLen C.size_t
	var cerr *C.char
	valueValue := C.leveldb_get(self.cdb, self.read_options, cKey, C.size_t(len(key)), &valueLen, &cerr)
	if cerr != nil {
		return errors.New(fmt.Sprintf("%s", cerr))
	}
	bs := C.GoBytes(unsafe.Pointer(valueValue), C.int(valueLen))
	r := bytes.NewReader(bs)
	err := decode(r, obj)
	if err != nil {
		return err
	}
	return nil
}

// Get returns the data associated with the key from the database.
//
// If the key does not exist in the database, a nil []byte is returned. If the
// key does exist, but the data is zero-length in the database, a zero-length
// []byte will be returned.
//
// The key byte slice may be reused safely. Get takes a copy of
// them before returning.
func (db *DB) Get(ro *ReadOptions, key []byte) ([]byte, error) {
	var errStr *C.char
	var vallen C.size_t
	var k *C.char
	if len(key) != 0 {
		k = (*C.char)(unsafe.Pointer(&key[0]))
	}

	value := C.leveldb_get(db.Ldb, ro.Opt,
		k, C.size_t(len(key)),
		&vallen, &errStr)

	if errStr != nil {
		return nil, DatabaseError(C.GoString(errStr))
	}

	if value == nil {
		return nil, nil
	}
	return C.GoBytes(unsafe.Pointer(value), C.int(vallen)), nil
}

func (db *LevelDB) Get(key string) (value string, err error) {

	opt := C.leveldb_readoptions_create() // write option
	defer C.leveldb_free(unsafe.Pointer(opt))

	k := C.CString(key) // copy
	defer C.leveldb_free(unsafe.Pointer(k))

	var vallen C.size_t
	var cerr *C.char
	cvalue := C.leveldb_get(db.CLevelDB, opt, k, C.size_t(len(key)), &vallen, &cerr)

	if cerr != nil {
		defer C.leveldb_free(unsafe.Pointer(cerr))
		return "", errors.New(C.GoString(cerr))
	}

	if cvalue == nil {
		return "", nil
	}

	defer C.leveldb_free(unsafe.Pointer(cvalue))
	return C.GoString(cvalue), nil
}

func (db *DB) getSlice(ro *ReadOptions, key []byte) (driver.ISlice, error) {
	var errStr *C.char
	var vallen C.size_t
	var k *C.char
	if len(key) != 0 {
		k = (*C.char)(unsafe.Pointer(&key[0]))
	}

	value := C.leveldb_get(
		db.db, ro.Opt, k, C.size_t(len(key)), &vallen, &errStr)

	if errStr != nil {
		return nil, saveError(errStr)
	}

	if value == nil {
		return nil, nil
	}

	return NewCSlice(unsafe.Pointer(value), int(vallen)), nil
}

func (ldb *Db) Get(key []byte, read_option *Readoptions) ([]byte, error) {
	var db_err *C.char
	var value_len C.size_t

	key_len := len(key)
	if key_len == 0 {
		return nil, ldb_error("key must not empty")
	}

	key_c := (*C.char)(unsafe.Pointer(&key[0]))
	value := C.leveldb_get(ldb.ldb, read_option.options, key_c, C.size_t(key_len),
		&value_len, &db_err)

	if db_err != nil {
		return nil, ldb_error(C.GoString(db_err))
	}

	if value == nil {
		return nil, nil
	}

	return C.GoBytes(unsafe.Pointer(value), C.int(value_len)), nil
}