func (self *BpNode) put_value_at(i int, value interface{}) error {
if len(self.values) == cap(self.values) {
return errors.BpTreeError("Block is full.")
}
if self.Internal() {
return errors.BpTreeError("Expected a leaf node")
}
self.values = self.values[:len(self.values)+1]
for j := len(self.values) - 1; j > i; j-- {
self.values[j] = self.values[j-1]
}
self.values[i] = value
return nil
}
func (self *BpNode) put_pointer_at(i int, pointer *BpNode) error {
if len(self.pointers) == cap(self.pointers) {
return errors.BpTreeError("Block is full.")
}
if !self.Internal() {
return errors.BpTreeError("Expected a internal node")
}
self.pointers = self.pointers[:len(self.pointers)+1]
for j := len(self.pointers) - 1; j > i; j-- {
self.pointers[j] = self.pointers[j-1]
}
self.pointers[i] = pointer
return nil
}
func (self *BpNode) leaf_remove(key, stop types.Sortable, where types.WhereFunc) (a *BpNode, err error) {
if self.Internal() {
return nil, errors.BpTreeError("Expected a leaf node")
}
a = self
for j, l, next := self.forward(key, key)(); next != nil; j, l, next = next() {
if where(l.values[j]) {
if err := l.remove_key_at(j); err != nil {
return nil, err
}
if err := l.remove_value_at(j); err != nil {
return nil, err
}
}
if len(l.keys) == 0 {
remove_linked_list_node(l)
if l.next == nil {
a = nil
} else if stop == nil {
a = nil
} else if !l.next.keys[0].Equals(stop) {
a = l.next
} else {
a = nil
}
}
}
return a, nil
}
/* a pure leaf split has two cases:
* 1) the inserted key is less than the current pure block.
* - a new block should be created before the current block
* - the key should be put in it
* 2) the inserted key is greater than or equal to the pure block.
* - the end of run of pure blocks should be found
* - if the key is equal to pure block and the last block is not full insert
* the new kv
* - else split by making a new block after the last block in the run
* and putting the new key there.
* - always return the current block as "a" and the new block as "b"
*/
func (self *BpNode) pure_leaf_split(key types.Sortable, value interface{}) (a, b *BpNode, err error) {
if self.Internal() || !self.Pure() {
return nil, nil, errors.BpTreeError("Expected a pure leaf node")
}
if key.Less(self.keys[0]) {
a = NewLeaf(self.NodeSize(), self.no_dup)
b = self
if err := a.put_kv(key, value); err != nil {
return nil, nil, err
}
insert_linked_list_node(a, b.prev, b)
return a, b, nil
} else {
a = self
e := self.find_end_of_pure_run()
if e.keys[0].Equals(key) && !e.Full() {
if err := e.put_kv(key, value); err != nil {
return nil, nil, err
}
return a, nil, nil
} else {
b = NewLeaf(self.NodeSize(), self.no_dup)
if err := b.put_kv(key, value); err != nil {
return nil, nil, err
}
insert_linked_list_node(b, e, e.next)
if e.keys[0].Equals(key) {
return a, nil, nil
}
return a, b, nil
}
}
}
/* - first find the child to insert into
* - do the child insert
* - if there was a split:
* - if the block is full, split this block
* - else insert the new key/pointer into this block
*/
func (self *BpNode) internal_insert(key types.Sortable, value interface{}) (a, b *BpNode, err error) {
if !self.Internal() {
return nil, nil, errors.BpTreeError("Expected a internal node")
}
i, has := self.find(key)
if !has && i > 0 {
// if it doesn't have it and the index > 0 then we have the next block
// so we have to subtract one from the index.
i--
}
child := self.pointers[i]
p, q, err := child.insert(key, value)
if err != nil {
return nil, nil, err
}
self.keys[i] = p.keys[0]
self.pointers[i] = p
if q != nil {
// we had a split
if self.Full() {
return self.internal_split(q.keys[0], q)
} else {
if err := self.put_kp(q.keys[0], q); err != nil {
return nil, nil, err
}
return self, nil, nil
}
}
return self, nil, nil
}
func (self *BpNode) Height() int {
if !self.Internal() {
return 1
} else if len(self.pointers) == 0 {
panic(errors.BpTreeError("Internal node has no pointers but asked for height"))
}
return self.pointers[0].Height() + 1
}
func (self *BpNode) remove_key_at(i int) error {
if i >= len(self.keys) || i < 0 {
return errors.BpTreeError("i, %v, is out of bounds, %v, %v %v.", i, len(self.keys), len(self.values), self)
}
for j := i; j < len(self.keys)-1; j++ {
self.keys[j] = self.keys[j+1]
}
self.keys = self.keys[:len(self.keys)-1]
return nil
}
func (self *BpNode) remove_ptr_at(i int) error {
if i >= len(self.pointers) || i < 0 {
return errors.BpTreeError("i, %v, is out of bounds, %v.", i, len(self.pointers))
}
for j := i; j < len(self.pointers)-1; j++ {
self.pointers[j] = self.pointers[j+1]
}
self.pointers = self.pointers[:len(self.pointers)-1]
return nil
}
/* a must be full and b must be empty else there will be a panic
*/
func balance_nodes(a, b *BpNode) {
if len(b.keys) != 0 {
panic(errors.BpTreeError("b was not empty"))
}
if !a.Full() {
panic(errors.BpTreeError("a was not full", a))
}
if cap(a.keys) != cap(b.keys) {
panic(errors.BpTreeError("cap(a.keys) != cap(b.keys)"))
}
if cap(a.values) != cap(b.values) {
panic(errors.BpTreeError("cap(a.values) != cap(b.values)"))
}
if cap(a.pointers) != cap(b.pointers) {
panic(errors.BpTreeError("cap(a.pointers) != cap(b.pointers)"))
}
m := len(a.keys) / 2
for m < len(a.keys) && a.keys[m-1].Equals(a.keys[m]) {
m++
}
if m == len(a.keys) {
m--
for m > 0 && a.keys[m-1].Equals(a.keys[m]) {
m--
}
}
var lim int = len(a.keys) - m
b.keys = b.keys[:lim]
if cap(a.values) > 0 {
if cap(a.values) != cap(a.keys) {
panic(errors.BpTreeError("cap(a.values) != cap(a.keys)"))
}
b.values = b.values[:lim]
}
if cap(a.pointers) > 0 {
if cap(a.pointers) != cap(a.keys) {
panic(errors.BpTreeError("cap(a.pointers) != cap(a.keys)"))
}
b.pointers = b.pointers[:lim]
}
for i := 0; i < lim; i++ {
j := m + i
b.keys[i] = a.keys[j]
if cap(a.values) > 0 {
b.values[i] = a.values[j]
}
if cap(a.pointers) > 0 {
b.pointers[i] = a.pointers[j]
}
}
a.keys = a.keys[:m]
if cap(a.values) > 0 {
a.values = a.values[:m]
}
if cap(a.pointers) > 0 {
a.pointers = a.pointers[:m]
}
}
func (self *BpNode) put_key_at(i int, key types.Sortable) error {
if self.Full() {
return errors.BpTreeError("Block is full.")
}
self.keys = self.keys[:len(self.keys)+1]
for j := len(self.keys) - 1; j > i; j-- {
self.keys[j] = self.keys[j-1]
}
self.keys[i] = key
return nil
}
func (self *BpNode) put_kv(key types.Sortable, value interface{}) error {
if self.Full() {
return errors.BpTreeError("Block is full.")
}
if self.Internal() {
return errors.BpTreeError("Expected a leaf node")
}
i, _ := self.find(key)
if i < 0 {
panic(errors.BpTreeError("find returned a negative int"))
} else if i >= cap(self.keys) {
panic(errors.BpTreeError("find returned a int > than cap(keys)"))
}
if err := self.put_key_at(i, key); err != nil {
return err
}
if err := self.put_value_at(i, value); err != nil {
return err
}
return nil
}
/* On split
* - first assert that the key to be inserted is not already in the block.
* - Make a new block
* - balance the two blocks.
* - insert the new key/pointer combo into the correct block
*/
func (self *BpNode) internal_split(key types.Sortable, ptr *BpNode) (a, b *BpNode, err error) {
if !self.Internal() {
return nil, nil, errors.BpTreeError("Expected a internal node")
}
if self.has(key) {
return nil, nil, errors.BpTreeError("Tried to split an internal block on duplicate key")
}
a = self
b = NewInternal(self.NodeSize())
balance_nodes(a, b)
if key.Less(b.keys[0]) {
if err := a.put_kp(key, ptr); err != nil {
return nil, nil, err
}
} else {
if err := b.put_kp(key, ptr); err != nil {
return nil, nil, err
}
}
return a, b, nil
}
func insert_linked_list_node(n, prev, next *BpNode) {
if (prev != nil && prev.next != next) || (next != nil && next.prev != prev) {
panic(errors.BpTreeError("prev and next not hooked up"))
}
n.prev = prev
n.next = next
if prev != nil {
prev.next = n
}
if next != nil {
next.prev = n
}
}
func (self *BpNode) internal_get_start(key types.Sortable) (i int, leaf *BpNode) {
if !self.Internal() {
panic(errors.BpTreeError("Expected a internal node"))
}
i, has := self.find(key)
if !has && i > 0 {
// if it doesn't have it and the index > 0 then we have the next block
// so we have to subtract one from the index.
i--
}
child := self.pointers[i]
return child.get_start(key)
}
func (self *BpNode) put_kp(key types.Sortable, ptr *BpNode) error {
if self.Full() {
return errors.BpTreeError("Block is full.")
}
if !self.Internal() {
return errors.BpTreeError("Expected a internal node")
}
i, has := self.find(key)
if has {
return errors.BpTreeError("Tried to insert a duplicate key into an internal node")
} else if i < 0 {
panic(errors.BpTreeError("find returned a negative int"))
} else if i >= cap(self.keys) {
panic(errors.BpTreeError("find returned a int > than cap(keys)"))
}
if err := self.put_key_at(i, key); err != nil {
return err
}
if err := self.put_pointer_at(i, ptr); err != nil {
return err
}
return nil
}
func (self *BpNode) internal_remove(key types.Sortable, sibling *BpNode, where types.WhereFunc) (a *BpNode, err error) {
if !self.Internal() {
panic(errors.BpTreeError("Expected a internal node"))
}
i, has := self.find(key)
if !has && i > 0 {
// if it doesn't have it and the index > 0 then we have the next block
// so we have to subtract one from the index.
i--
}
if i+1 < len(self.keys) {
sibling = self.pointers[i+1]
} else if sibling != nil {
sibling = sibling.left_most_leaf()
}
child := self.pointers[i]
if child.Internal() {
child, err = child.internal_remove(key, sibling, where)
} else {
if sibling == nil {
child, err = child.leaf_remove(key, nil, where)
} else {
child, err = child.leaf_remove(key, sibling.keys[0], where)
}
}
if err != nil {
return nil, err
}
if child == nil {
if err := self.remove_key_at(i); err != nil {
return nil, err
}
if err := self.remove_ptr_at(i); err != nil {
return nil, err
}
} else {
self.keys[i] = child.keys[0]
self.pointers[i] = child
}
if len(self.keys) == 0 {
return nil, nil
}
return self, nil
}
/* if the leaf is full then it will defer to a leaf_split
* (but in one case that will not actually split in the case of a insert into
* a pure block with a matching key)
* else this leaf will get a new entry.
*/
func (self *BpNode) leaf_insert(key types.Sortable, value interface{}) (a, b *BpNode, err error) {
if self.Internal() {
return nil, nil, errors.BpTreeError("Expected a leaf node")
}
if self.no_dup {
i, has := self.find(key)
if has {
self.values[i] = value
return self, nil, nil
}
}
if self.Full() {
return self.leaf_split(key, value)
} else {
if err := self.put_kv(key, value); err != nil {
return nil, nil, err
}
return self, nil, nil
}
}
/* on leaf split if the block is pure then it will defer to pure_leaf_split
* else
* - a new block will be made and inserted after this one
* - the two blocks will be balanced with balanced_nodes
* - if the key is less than b.keys[0] it will go in a else b
*/
func (self *BpNode) leaf_split(key types.Sortable, value interface{}) (a, b *BpNode, err error) {
if self.Internal() {
return nil, nil, errors.BpTreeError("Expected a leaf node")
}
if self.Pure() {
return self.pure_leaf_split(key, value)
}
a = self
b = NewLeaf(self.NodeSize(), self.no_dup)
insert_linked_list_node(b, a, a.next)
balance_nodes(a, b)
if key.Less(b.keys[0]) {
if err := a.put_kv(key, value); err != nil {
return nil, nil, err
}
} else {
if err := b.put_kv(key, value); err != nil {
return nil, nil, err
}
}
return a, b, nil
}
