...
This commit is contained in:
parent
1ae9ecd2a9
commit
877dd02e28
|
@ -10,43 +10,71 @@ import (
|
||||||
// Node
|
// Node
|
||||||
|
|
||||||
type IAVLNode struct {
|
type IAVLNode struct {
|
||||||
key []byte
|
key []byte
|
||||||
value []byte
|
value []byte
|
||||||
size uint64
|
size uint64
|
||||||
height uint8
|
height uint8
|
||||||
hash []byte
|
hash []byte
|
||||||
left *IAVLNode
|
leftHash []byte
|
||||||
right *IAVLNode
|
rightHash []byte
|
||||||
|
persisted bool
|
||||||
|
|
||||||
// volatile
|
// May or may not be persisted nodes, but they'll get cleared
|
||||||
flags byte
|
// when this this node is saved.
|
||||||
|
leftCached *IAVLNode
|
||||||
|
rightCached *IAVLNode
|
||||||
}
|
}
|
||||||
|
|
||||||
const (
|
|
||||||
IAVLNODE_FLAG_PERSISTED = byte(0x01)
|
|
||||||
IAVLNODE_FLAG_PLACEHOLDER = byte(0x02)
|
|
||||||
)
|
|
||||||
|
|
||||||
func NewIAVLNode(key []byte, value []byte) *IAVLNode {
|
func NewIAVLNode(key []byte, value []byte) *IAVLNode {
|
||||||
return &IAVLNode{
|
return &IAVLNode{
|
||||||
key: key,
|
key: key,
|
||||||
value: value,
|
value: value,
|
||||||
size: 1,
|
size: 1,
|
||||||
|
persisted: false,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func ReadIAVLNode(r io.Reader, n *int64, err *error) *IAVLNode {
|
||||||
|
node := &IAVLNode{}
|
||||||
|
|
||||||
|
// node header & key
|
||||||
|
node.height = ReadUInt8(r, &n, &err)
|
||||||
|
node.size = ReadUInt64(r, &n, &err)
|
||||||
|
node.key = ReadByteSlice(r, &n, &err)
|
||||||
|
if err != nil {
|
||||||
|
panic(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// node value or children.
|
||||||
|
if node.height == 0 {
|
||||||
|
// value
|
||||||
|
node.value = ReadByteSlice(r, &n, &err)
|
||||||
|
} else {
|
||||||
|
// left
|
||||||
|
node.leftHash = ReadByteSlice(r, &n, &err)
|
||||||
|
// right
|
||||||
|
node.rightHash = ReadByteSlice(r, &n, &err)
|
||||||
|
}
|
||||||
|
if err != nil {
|
||||||
|
panic(err)
|
||||||
|
}
|
||||||
|
return node
|
||||||
|
}
|
||||||
|
|
||||||
func (self *IAVLNode) Copy() *IAVLNode {
|
func (self *IAVLNode) Copy() *IAVLNode {
|
||||||
if self.height == 0 {
|
if self.height == 0 {
|
||||||
panic("Why are you copying a value node?")
|
panic("Why are you copying a value node?")
|
||||||
}
|
}
|
||||||
return &IAVLNode{
|
return &IAVLNode{
|
||||||
key: self.key,
|
key: self.key,
|
||||||
size: self.size,
|
size: self.size,
|
||||||
height: self.height,
|
height: self.height,
|
||||||
left: self.left,
|
hash: nil, // Going to be mutated anyways.
|
||||||
right: self.right,
|
leftHash: self.leftHash,
|
||||||
hash: nil,
|
rightHash: self.rightHash,
|
||||||
flags: byte(0),
|
persisted: self.persisted,
|
||||||
|
leftCached: self.leftCached,
|
||||||
|
rightCached: self.rightCached,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -58,7 +86,7 @@ func (self *IAVLNode) Height() uint8 {
|
||||||
return self.height
|
return self.height
|
||||||
}
|
}
|
||||||
|
|
||||||
func (self *IAVLNode) has(db Db, key []byte) (has bool) {
|
func (self *IAVLNode) has(ndb *IAVLNodeDB, key []byte) (has bool) {
|
||||||
if bytes.Equal(self.key, key) {
|
if bytes.Equal(self.key, key) {
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
@ -66,14 +94,14 @@ func (self *IAVLNode) has(db Db, key []byte) (has bool) {
|
||||||
return false
|
return false
|
||||||
} else {
|
} else {
|
||||||
if bytes.Compare(key, self.key) == -1 {
|
if bytes.Compare(key, self.key) == -1 {
|
||||||
return self.leftFilled(db).has(db, key)
|
return self.getLeft(ndb).has(ndb, key)
|
||||||
} else {
|
} else {
|
||||||
return self.rightFilled(db).has(db, key)
|
return self.getRight(ndb).has(ndb, key)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (self *IAVLNode) get(db Db, key []byte) (value []byte) {
|
func (self *IAVLNode) get(ndb *IAVLNodeDB, key []byte) (value []byte) {
|
||||||
if self.height == 0 {
|
if self.height == 0 {
|
||||||
if bytes.Equal(self.key, key) {
|
if bytes.Equal(self.key, key) {
|
||||||
return self.value
|
return self.value
|
||||||
|
@ -82,9 +110,9 @@ func (self *IAVLNode) get(db Db, key []byte) (value []byte) {
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
if bytes.Compare(key, self.key) == -1 {
|
if bytes.Compare(key, self.key) == -1 {
|
||||||
return self.leftFilled(db).get(db, key)
|
return self.getLeft(ndb).get(ndb, key)
|
||||||
} else {
|
} else {
|
||||||
return self.rightFilled(db).get(db, key)
|
return self.getRight(ndb).get(ndb, key)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -104,105 +132,108 @@ func (self *IAVLNode) HashWithCount() ([]byte, uint64) {
|
||||||
return self.hash, hashCount + 1
|
return self.hash, hashCount + 1
|
||||||
}
|
}
|
||||||
|
|
||||||
func (self *IAVLNode) Save(db Db) {
|
func (self *IAVLNode) Save(ndb *IAVLNodeDB) []byte {
|
||||||
if self.hash == nil {
|
if self.hash == nil {
|
||||||
panic("savee.hash can't be nil")
|
hash, _ := self.HashWithCount()
|
||||||
|
self.hash = hash
|
||||||
}
|
}
|
||||||
if self.flags&IAVLNODE_FLAG_PERSISTED > 0 ||
|
if self.persisted {
|
||||||
self.flags&IAVLNODE_FLAG_PLACEHOLDER > 0 {
|
return self.hash
|
||||||
return
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// children
|
// children
|
||||||
if self.height > 0 {
|
if self.leftCached != nil {
|
||||||
self.left.Save(db)
|
self.leftHash = self.leftCached.Save(ndb)
|
||||||
self.right.Save(db)
|
self.leftCached = nil
|
||||||
|
}
|
||||||
|
if self.rightCached != nil {
|
||||||
|
self.rightHash = self.rightCached.Save(ndb)
|
||||||
|
self.rightCached = nil
|
||||||
}
|
}
|
||||||
|
|
||||||
// save self
|
// save self
|
||||||
buf := bytes.NewBuffer(nil)
|
ndb.Save(self)
|
||||||
_, err := self.WriteTo(buf)
|
return self.hash
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
db.Set([]byte(self.hash), buf.Bytes())
|
|
||||||
|
|
||||||
self.flags |= IAVLNODE_FLAG_PERSISTED
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func (self *IAVLNode) set(db Db, key []byte, value []byte) (_ *IAVLNode, updated bool) {
|
func (self *IAVLNode) set(ndb *IAVLNodeDB, key []byte, value []byte) (_ *IAVLNode, updated bool) {
|
||||||
if self.height == 0 {
|
if self.height == 0 {
|
||||||
if bytes.Compare(key, self.key) == -1 {
|
if bytes.Compare(key, self.key) == -1 {
|
||||||
return &IAVLNode{
|
return &IAVLNode{
|
||||||
key: self.key,
|
key: self.key,
|
||||||
height: 1,
|
height: 1,
|
||||||
size: 2,
|
size: 2,
|
||||||
left: NewIAVLNode(key, value),
|
leftCached: NewIAVLNode(key, value),
|
||||||
right: self,
|
rightCached: self,
|
||||||
}, false
|
}, false
|
||||||
} else if bytes.Equal(self.key, key) {
|
} else if bytes.Equal(self.key, key) {
|
||||||
return NewIAVLNode(key, value), true
|
return NewIAVLNode(key, value), true
|
||||||
} else {
|
} else {
|
||||||
return &IAVLNode{
|
return &IAVLNode{
|
||||||
key: key,
|
key: key,
|
||||||
height: 1,
|
height: 1,
|
||||||
size: 2,
|
size: 2,
|
||||||
left: self,
|
leftCached: self,
|
||||||
right: NewIAVLNode(key, value),
|
rightCached: NewIAVLNode(key, value),
|
||||||
}, false
|
}, false
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
self = self.Copy()
|
self = self.Copy()
|
||||||
if bytes.Compare(key, self.key) == -1 {
|
if bytes.Compare(key, self.key) == -1 {
|
||||||
self.left, updated = self.leftFilled(db).set(db, key, value)
|
self.leftCached, updated = self.getLeft(ndb).set(ndb, key, value)
|
||||||
|
self.leftHash = nil
|
||||||
} else {
|
} else {
|
||||||
self.right, updated = self.rightFilled(db).set(db, key, value)
|
self.rightCached, updated = self.getRight(ndb).set(ndb, key, value)
|
||||||
|
self.rightHash = nil
|
||||||
}
|
}
|
||||||
if updated {
|
if updated {
|
||||||
return self, updated
|
return self, updated
|
||||||
} else {
|
} else {
|
||||||
self.calcHeightAndSize(db)
|
self.calcHeightAndSize(ndb)
|
||||||
return self.balance(db), updated
|
return self.balance(ndb), updated
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// newKey: new leftmost leaf key for tree after successfully removing 'key' if changed.
|
// newKey: new leftmost leaf key for tree after successfully removing 'key' if changed.
|
||||||
func (self *IAVLNode) remove(db Db, key []byte) (newSelf *IAVLNode, newKey []byte, value []byte, err error) {
|
// only one of newSelfHash or newSelf is returned.
|
||||||
|
func (self *IAVLNode) remove(ndb *IAVLNodeDB, key []byte) (newSelfHash []byte, newSelf *IAVLNode, newKey []byte, value []byte, err error) {
|
||||||
if self.height == 0 {
|
if self.height == 0 {
|
||||||
if bytes.Equal(self.key, key) {
|
if bytes.Equal(self.key, key) {
|
||||||
return nil, nil, self.value, nil
|
return nil, nil, nil, self.value, nil
|
||||||
} else {
|
} else {
|
||||||
return self, nil, nil, NotFound(key)
|
return nil, self, nil, nil, NotFound(key)
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
if bytes.Compare(key, self.key) == -1 {
|
if bytes.Compare(key, self.key) == -1 {
|
||||||
|
var newLeftHash []byte
|
||||||
var newLeft *IAVLNode
|
var newLeft *IAVLNode
|
||||||
newLeft, newKey, value, err = self.leftFilled(db).remove(db, key)
|
newLeftHash, newLeft, newKey, value, err = self.getLeft(ndb).remove(ndb, key)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return self, nil, value, err
|
return nil, self, nil, value, err
|
||||||
} else if newLeft == nil { // left node held value, was removed
|
} else if newLeftHash == nil && newLeft == nil { // left node held value, was removed
|
||||||
return self.right, self.key, value, nil
|
return self.rightHash, self.rightCached, self.key, value, nil
|
||||||
}
|
}
|
||||||
self = self.Copy()
|
self = self.Copy()
|
||||||
self.left = newLeft
|
self.leftHash, self.leftCached = newLeftHash, newLeft
|
||||||
} else {
|
} else {
|
||||||
|
var newRightHash []byte
|
||||||
var newRight *IAVLNode
|
var newRight *IAVLNode
|
||||||
newRight, newKey, value, err = self.rightFilled(db).remove(db, key)
|
newRightHash, newRight, newKey, value, err = self.getRight(ndb).remove(ndb, key)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return self, nil, value, err
|
return nil, self, nil, value, err
|
||||||
} else if newRight == nil { // right node held value, was removed
|
} else if newRightHash == nil && newRight == nil { // right node held value, was removed
|
||||||
return self.left, nil, value, nil
|
return self.leftHash, self.leftCached, nil, value, nil
|
||||||
}
|
}
|
||||||
self = self.Copy()
|
self = self.Copy()
|
||||||
self.right = newRight
|
self.rightHash, self.rightCached = newRightHash, newRight
|
||||||
if newKey != nil {
|
if newKey != nil {
|
||||||
self.key = newKey
|
self.key = newKey
|
||||||
newKey = nil
|
newKey = nil
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
self.calcHeightAndSize(db)
|
self.calcHeightAndSize(ndb)
|
||||||
return self.balance(db), newKey, value, err
|
return nil, self.balance(ndb), newKey, value, err
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -226,170 +257,133 @@ func (self *IAVLNode) saveToCountHashes(w io.Writer) (n int64, hashCount uint64,
|
||||||
WriteByteSlice(w, self.value, &n, &err)
|
WriteByteSlice(w, self.value, &n, &err)
|
||||||
} else {
|
} else {
|
||||||
// left
|
// left
|
||||||
leftHash, leftCount := self.left.HashWithCount()
|
if self.leftCached != nil {
|
||||||
hashCount += leftCount
|
leftHash, leftCount := self.left.HashWithCount()
|
||||||
WriteByteSlice(w, leftHash, &n, &err)
|
self.leftHash = leftHash
|
||||||
|
hashCount += leftCount
|
||||||
|
}
|
||||||
|
WriteByteSlice(w, self.leftHash, &n, &err)
|
||||||
// right
|
// right
|
||||||
rightHash, rightCount := self.right.HashWithCount()
|
if self.rightCached != nil {
|
||||||
hashCount += rightCount
|
rightHash, rightCount := self.right.HashWithCount()
|
||||||
WriteByteSlice(w, rightHash, &n, &err)
|
self.rightHash = rightHash
|
||||||
|
hashCount += rightCount
|
||||||
|
}
|
||||||
|
WriteByteSlice(w, self.rightHash, &n, &err)
|
||||||
}
|
}
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
// Given a placeholder node which has only the hash set,
|
func (self *IAVLNode) getLeft(ndb *IAVLNodeDB) *IAVLNode {
|
||||||
// load the rest of the data from db.
|
if self.leftCached != nil {
|
||||||
// Not threadsafe.
|
return self.leftCached
|
||||||
func (self *IAVLNode) fill(db Db) {
|
|
||||||
if self.hash == nil {
|
|
||||||
panic("placeholder.hash can't be nil")
|
|
||||||
}
|
|
||||||
buf := db.Get(self.hash)
|
|
||||||
r := bytes.NewReader(buf)
|
|
||||||
var n int64
|
|
||||||
var err error
|
|
||||||
|
|
||||||
// node header & key
|
|
||||||
self.height = ReadUInt8(r, &n, &err)
|
|
||||||
self.size = ReadUInt64(r, &n, &err)
|
|
||||||
self.key = ReadByteSlice(r, &n, &err)
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// node value or children.
|
|
||||||
if self.height == 0 {
|
|
||||||
// value
|
|
||||||
self.value = ReadByteSlice(r, &n, &err)
|
|
||||||
} else {
|
} else {
|
||||||
// left
|
return ndb.Get(leftHash)
|
||||||
leftHash := ReadByteSlice(r, &n, &err)
|
|
||||||
self.left = &IAVLNode{
|
|
||||||
hash: leftHash,
|
|
||||||
flags: IAVLNODE_FLAG_PERSISTED | IAVLNODE_FLAG_PLACEHOLDER,
|
|
||||||
}
|
|
||||||
// right
|
|
||||||
rightHash := ReadByteSlice(r, &n, &err)
|
|
||||||
self.right = &IAVLNode{
|
|
||||||
hash: rightHash,
|
|
||||||
flags: IAVLNODE_FLAG_PERSISTED | IAVLNODE_FLAG_PLACEHOLDER,
|
|
||||||
}
|
|
||||||
if r.Len() != 0 {
|
|
||||||
panic("buf not all consumed")
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
self.flags &= ^IAVLNODE_FLAG_PLACEHOLDER
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func (self *IAVLNode) leftFilled(db Db) *IAVLNode {
|
func (self *IAVLNode) getRight(ndb *IAVLNodeDB) *IAVLNode {
|
||||||
if self.left.flags&IAVLNODE_FLAG_PLACEHOLDER > 0 {
|
if self.rightCached != nil {
|
||||||
self.left.fill(db)
|
return self.rightCached
|
||||||
|
} else {
|
||||||
|
return ndb.Get(rightHash)
|
||||||
}
|
}
|
||||||
return self.left
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func (self *IAVLNode) rightFilled(db Db) *IAVLNode {
|
func (self *IAVLNode) rotateRight(ndb *IAVLNodeDB) *IAVLNode {
|
||||||
if self.right.flags&IAVLNODE_FLAG_PLACEHOLDER > 0 {
|
|
||||||
self.right.fill(db)
|
|
||||||
}
|
|
||||||
return self.right
|
|
||||||
}
|
|
||||||
|
|
||||||
func (self *IAVLNode) rotateRight(db Db) *IAVLNode {
|
|
||||||
self = self.Copy()
|
self = self.Copy()
|
||||||
sl := self.leftFilled(db).Copy()
|
sl := self.getLeft(ndb).Copy()
|
||||||
slr := sl.right
|
|
||||||
|
|
||||||
sl.right = self
|
slrHash, slrCached := sl.rightHash, sl.rightCached
|
||||||
self.left = slr
|
sl.rightHash, sl.rightCached = nil, self
|
||||||
|
self.leftHash, self.leftCached = slrHash, slrCached
|
||||||
|
|
||||||
self.calcHeightAndSize(db)
|
self.calcHeightAndSize(ndb)
|
||||||
sl.calcHeightAndSize(db)
|
sl.calcHeightAndSize(ndb)
|
||||||
|
|
||||||
return sl
|
return sl
|
||||||
}
|
}
|
||||||
|
|
||||||
func (self *IAVLNode) rotateLeft(db Db) *IAVLNode {
|
func (self *IAVLNode) rotateLeft(ndb *IAVLNodeDB) *IAVLNode {
|
||||||
self = self.Copy()
|
self = self.Copy()
|
||||||
sr := self.rightFilled(db).Copy()
|
sr := self.getRight(ndb).Copy()
|
||||||
srl := sr.left
|
|
||||||
|
|
||||||
sr.left = self
|
srlHash, srlCached := sr.leftHash, sr.leftCached
|
||||||
self.right = srl
|
sr.leftHash, sr.leftCached = nil, self
|
||||||
|
self.rightHash, self.rightCached = srlHash, srlCached
|
||||||
|
|
||||||
self.calcHeightAndSize(db)
|
self.calcHeightAndSize(ndb)
|
||||||
sr.calcHeightAndSize(db)
|
sr.calcHeightAndSize(ndb)
|
||||||
|
|
||||||
return sr
|
return sr
|
||||||
}
|
}
|
||||||
|
|
||||||
func (self *IAVLNode) calcHeightAndSize(db Db) {
|
func (self *IAVLNode) calcHeightAndSize(ndb *IAVLNodeDB) {
|
||||||
self.height = maxUint8(self.leftFilled(db).Height(), self.rightFilled(db).Height()) + 1
|
self.height = maxUint8(self.getLeft(ndb).Height(), self.getRight(ndb).Height()) + 1
|
||||||
self.size = self.leftFilled(db).Size() + self.rightFilled(db).Size()
|
self.size = self.getLeft(ndb).Size() + self.getRight(ndb).Size()
|
||||||
}
|
}
|
||||||
|
|
||||||
func (self *IAVLNode) calcBalance(db Db) int {
|
func (self *IAVLNode) calcBalance(ndb *IAVLNodeDB) int {
|
||||||
return int(self.leftFilled(db).Height()) - int(self.rightFilled(db).Height())
|
return int(self.getLeft(ndb).Height()) - int(self.getRight(ndb).Height())
|
||||||
}
|
}
|
||||||
|
|
||||||
func (self *IAVLNode) balance(db Db) (newSelf *IAVLNode) {
|
func (self *IAVLNode) balance(ndb *IAVLNodeDB) (newSelf *IAVLNode) {
|
||||||
balance := self.calcBalance(db)
|
balance := self.calcBalance(ndb)
|
||||||
if balance > 1 {
|
if balance > 1 {
|
||||||
if self.leftFilled(db).calcBalance(db) >= 0 {
|
if self.getLeft(ndb).calcBalance(ndb) >= 0 {
|
||||||
// Left Left Case
|
// Left Left Case
|
||||||
return self.rotateRight(db)
|
return self.rotateRight(ndb)
|
||||||
} else {
|
} else {
|
||||||
// Left Right Case
|
// Left Right Case
|
||||||
self = self.Copy()
|
self = self.Copy()
|
||||||
self.left = self.leftFilled(db).rotateLeft(db)
|
self.leftHash, self.leftCached = nil, self.getLeft(ndb).rotateLeft(ndb)
|
||||||
//self.calcHeightAndSize()
|
//self.calcHeightAndSize()
|
||||||
return self.rotateRight(db)
|
return self.rotateRight(ndb)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if balance < -1 {
|
if balance < -1 {
|
||||||
if self.rightFilled(db).calcBalance(db) <= 0 {
|
if self.getRight(ndb).calcBalance(ndb) <= 0 {
|
||||||
// Right Right Case
|
// Right Right Case
|
||||||
return self.rotateLeft(db)
|
return self.rotateLeft(ndb)
|
||||||
} else {
|
} else {
|
||||||
// Right Left Case
|
// Right Left Case
|
||||||
self = self.Copy()
|
self = self.Copy()
|
||||||
self.right = self.rightFilled(db).rotateRight(db)
|
self.rightHash, self.rightCached = nil, self.getRight(ndb).rotateRight(ndb)
|
||||||
//self.calcHeightAndSize()
|
//self.calcHeightAndSize()
|
||||||
return self.rotateLeft(db)
|
return self.rotateLeft(ndb)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// Nothing changed
|
// Nothing changed
|
||||||
return self
|
return self
|
||||||
}
|
}
|
||||||
|
|
||||||
func (self *IAVLNode) lmd(db Db) *IAVLNode {
|
// Only used in testing...
|
||||||
|
func (self *IAVLNode) lmd(ndb *IAVLNodeDB) *IAVLNode {
|
||||||
if self.height == 0 {
|
if self.height == 0 {
|
||||||
return self
|
return self
|
||||||
}
|
}
|
||||||
return self.leftFilled(db).lmd(db)
|
return self.getLeft(ndb).lmd(ndb)
|
||||||
}
|
}
|
||||||
|
|
||||||
func (self *IAVLNode) rmd(db Db) *IAVLNode {
|
// Only used in testing...
|
||||||
|
func (self *IAVLNode) rmd(ndb *IAVLNodeDB) *IAVLNode {
|
||||||
if self.height == 0 {
|
if self.height == 0 {
|
||||||
return self
|
return self
|
||||||
}
|
}
|
||||||
return self.rightFilled(db).rmd(db)
|
return self.getRight(ndb).rmd(ndb)
|
||||||
}
|
}
|
||||||
|
|
||||||
func (self *IAVLNode) traverse(db Db, cb func(*IAVLNode) bool) bool {
|
func (self *IAVLNode) traverse(ndb *IAVLNodeDB, cb func(*IAVLNode) bool) bool {
|
||||||
stop := cb(self)
|
stop := cb(self)
|
||||||
if stop {
|
if stop {
|
||||||
return stop
|
return stop
|
||||||
}
|
}
|
||||||
if self.height > 0 {
|
if self.height > 0 {
|
||||||
stop = self.leftFilled(db).traverse(db, cb)
|
stop = self.getLeft(ndb).traverse(ndb, cb)
|
||||||
if stop {
|
if stop {
|
||||||
return stop
|
return stop
|
||||||
}
|
}
|
||||||
stop = self.rightFilled(db).traverse(db, cb)
|
stop = self.getRight(ndb).traverse(ndb, cb)
|
||||||
if stop {
|
if stop {
|
||||||
return stop
|
return stop
|
||||||
}
|
}
|
||||||
|
|
|
@ -9,38 +9,24 @@ This tree is not concurrency safe.
|
||||||
You must wrap your calls with your own mutex.
|
You must wrap your calls with your own mutex.
|
||||||
*/
|
*/
|
||||||
type IAVLTree struct {
|
type IAVLTree struct {
|
||||||
db Db
|
ndb IAVLNodeDB
|
||||||
root *IAVLNode
|
root *IAVLNode
|
||||||
}
|
}
|
||||||
|
|
||||||
func NewIAVLTree(db Db) *IAVLTree {
|
func NewIAVLTree(db DB) *IAVLTree {
|
||||||
return &IAVLTree{
|
return &IAVLTree{
|
||||||
db: db,
|
ndb: NewIAVLNodeDB(db),
|
||||||
root: nil,
|
root: nil,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// TODO rename to Load.
|
func LoadIAVLTreeFromHash(db DB, hash []byte) *IAVLTree {
|
||||||
func NewIAVLTreeFromHash(db Db, hash []byte) *IAVLTree {
|
ndb := NewIAVLNodeDB(db)
|
||||||
root := &IAVLNode{
|
root := ndb.Get(hash)
|
||||||
hash: hash,
|
if root == nil {
|
||||||
flags: IAVLNODE_FLAG_PERSISTED | IAVLNODE_FLAG_PLACEHOLDER,
|
|
||||||
}
|
|
||||||
root.fill(db)
|
|
||||||
return &IAVLTree{db: db, root: root}
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewIAVLTreeFromKey(db Db, key string) *IAVLTree {
|
|
||||||
hash := db.Get([]byte(key))
|
|
||||||
if hash == nil {
|
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
root := &IAVLNode{
|
return &IAVLTree{ndb: ndb, root: root}
|
||||||
hash: hash,
|
|
||||||
flags: IAVLNODE_FLAG_PERSISTED | IAVLNODE_FLAG_PLACEHOLDER,
|
|
||||||
}
|
|
||||||
root.fill(db)
|
|
||||||
return &IAVLTree{db: db, root: root}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func (t *IAVLTree) Size() uint64 {
|
func (t *IAVLTree) Size() uint64 {
|
||||||
|
@ -61,7 +47,7 @@ func (t *IAVLTree) Has(key []byte) bool {
|
||||||
if t.root == nil {
|
if t.root == nil {
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
return t.root.has(t.db, key)
|
return t.root.has(t.ndb, key)
|
||||||
}
|
}
|
||||||
|
|
||||||
func (t *IAVLTree) Set(key []byte, value []byte) (updated bool) {
|
func (t *IAVLTree) Set(key []byte, value []byte) (updated bool) {
|
||||||
|
@ -69,7 +55,7 @@ func (t *IAVLTree) Set(key []byte, value []byte) (updated bool) {
|
||||||
t.root = NewIAVLNode(key, value)
|
t.root = NewIAVLNode(key, value)
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
t.root, updated = t.root.set(t.db, key, value)
|
t.root, updated = t.root.set(t.ndb, key, value)
|
||||||
return updated
|
return updated
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -93,7 +79,7 @@ func (t *IAVLTree) Save() {
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
t.root.HashWithCount()
|
t.root.HashWithCount()
|
||||||
t.root.Save(t.db)
|
t.root.Save(t.ndb)
|
||||||
}
|
}
|
||||||
|
|
||||||
func (t *IAVLTree) SaveKey(key string) {
|
func (t *IAVLTree) SaveKey(key string) {
|
||||||
|
@ -101,29 +87,70 @@ func (t *IAVLTree) SaveKey(key string) {
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
hash, _ := t.root.HashWithCount()
|
hash, _ := t.root.HashWithCount()
|
||||||
t.root.Save(t.db)
|
t.root.Save(t.ndb)
|
||||||
t.db.Set([]byte(key), hash)
|
t.ndb.Set([]byte(key), hash)
|
||||||
}
|
}
|
||||||
|
|
||||||
func (t *IAVLTree) Get(key []byte) (value []byte) {
|
func (t *IAVLTree) Get(key []byte) (value []byte) {
|
||||||
if t.root == nil {
|
if t.root == nil {
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
return t.root.get(t.db, key)
|
return t.root.get(t.ndb, key)
|
||||||
}
|
}
|
||||||
|
|
||||||
func (t *IAVLTree) Remove(key []byte) (value []byte, err error) {
|
func (t *IAVLTree) Remove(key []byte) (value []byte, err error) {
|
||||||
if t.root == nil {
|
if t.root == nil {
|
||||||
return nil, NotFound(key)
|
return nil, NotFound(key)
|
||||||
}
|
}
|
||||||
newRoot, _, value, err := t.root.remove(t.db, key)
|
newRootHash, newRoot, _, value, err := t.root.remove(t.ndb, key)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
t.root = newRoot
|
if newRoot == nil && newRootHash != nil {
|
||||||
|
t.root = t.ndb.Get(newRootHash)
|
||||||
|
} else {
|
||||||
|
t.root = newRoot
|
||||||
|
}
|
||||||
return value, nil
|
return value, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (t *IAVLTree) Copy() Tree {
|
func (t *IAVLTree) Copy() Tree {
|
||||||
return &IAVLTree{db: t.db, root: t.root}
|
return &IAVLTree{ndb: t.ndb, root: t.root}
|
||||||
|
}
|
||||||
|
|
||||||
|
//-----------------------------------------------------------------------------
|
||||||
|
|
||||||
|
type IAVLNodeDB struct {
|
||||||
|
db DB
|
||||||
|
cache map[string]*IAVLNode
|
||||||
|
// XXX expire entries
|
||||||
|
}
|
||||||
|
|
||||||
|
func (ndb *IAVLNodeDB) Get(hash []byte) *IAVLNode {
|
||||||
|
buf := ndb.db.Get(hash)
|
||||||
|
r := bytes.NewReader(buf)
|
||||||
|
var n int64
|
||||||
|
var err error
|
||||||
|
node := ReadIAVLNode(r, &n, &err)
|
||||||
|
if err != nil {
|
||||||
|
panic(err)
|
||||||
|
}
|
||||||
|
node.persisted = true
|
||||||
|
ndb.cache[string(hash)] = node
|
||||||
|
return node
|
||||||
|
}
|
||||||
|
|
||||||
|
func (ndb *IAVLNodeDB) Save(node *IAVLNode) {
|
||||||
|
hash := node.hash
|
||||||
|
if hash != nil {
|
||||||
|
panic("Expected to find node.hash, but none found.")
|
||||||
|
}
|
||||||
|
buf := bytes.NewBuffer(nil)
|
||||||
|
_, err := self.WriteTo(buf)
|
||||||
|
if err != nil {
|
||||||
|
panic(err)
|
||||||
|
}
|
||||||
|
node.persisted = true
|
||||||
|
ndb.cache[string(hash)] = node
|
||||||
|
ndb.db.Set(hash, buf.Bytes())
|
||||||
}
|
}
|
||||||
|
|
|
@ -4,7 +4,7 @@ import (
|
||||||
"fmt"
|
"fmt"
|
||||||
)
|
)
|
||||||
|
|
||||||
type Db interface {
|
type DB interface {
|
||||||
Get([]byte) []byte
|
Get([]byte) []byte
|
||||||
Set([]byte, []byte)
|
Set([]byte, []byte)
|
||||||
}
|
}
|
||||||
|
|
Loading…
Reference in New Issue