Esempio n. 1
0
func (self *BpTree) insert(block *KeyBlock, rec *tmprec, height int, dirty *dirty.DirtyBlocks) (*KeyBlock, *tmprec, bool) {
	var findlastblock func(*KeyBlock, ByteSlice) *KeyBlock
	findlastblock = func(block *KeyBlock, key ByteSlice) *KeyBlock {
		p, _ := block.GetExtraPtr()
		if p.Eq(ByteSlice64(0)) {
			return block
		}
		next := self.getblock(p)
		if r, _, _, ok := next.Get(0); !ok {
			return block
		} else {
			if r.GetKey().Eq(key) {
				return findlastblock(next, key)
			}
		}
		return block
	}

	// function to take a tmprec and turn it into the appropriate type of *Record
	_convert := func(rec *tmprec) *Record {
		if block.Mode() == self.external.Mode {
			return rec.external()
		}
		return rec.internal()
	}
	r := _convert(rec)

	//     fmt.Println("INSERTING ", r, block, "\n\n\n")

	// nextb is the block to be passed up the the caller in the case of a split at this level.
	var nextb *KeyBlock

	if height > 0 {
		// internal node
		// first we will need to find the next block to traverse down to
		var pos ByteSlice
		{
			// we find where in the block this key would be inserted
			i, _, _, _, ok := block.Find(rec.key)

			if i == 0 {
				// if that spot is zero it means that it is less than the smallest key the block
				// so we adjust the block appropriately
				if r, p, _, ok := block.Get(i); ok {
					dirty.Insert(block)
					r.SetKey(rec.key)
					pos = p
				} else {
					msg := fmt.Sprintf(
						"227 Error could not get record %v from block %v", i, block)
					panic(msg)
				}
			} else if ok {
				if _, p, _, ok := block.Get(i); ok {
					pos = p
				} else {
					msg := fmt.Sprintf(
						"235 Error could not get record %v from block %v", i, block)
					panic(msg)
				}
			} else {
				// else this spot is one to many so we get the previous spot
				i--
				if _, p, _, ok := block.Get(i); ok {
					pos = p
				} else {
					msg := fmt.Sprintf(
						"235 Error could not get record %v from block %v", i, block)
					panic(msg)
				}
			}
		}

		// if pos is nil we have a serious problem
		if pos == nil {
			panic("242 Nil Pointer")
		}

		// after we have found the position we get the block
		// then make a recursive call to insert to insert the record into the next block
		if b, srec, s := self.insert(self.getblock(pos), rec, height-1, dirty); s {
			// if the next block split we will insert the key passed up the chain.
			nextb = b
			r = _convert(srec)
			rec = srec
		} else {
			return nil, nil, false
		}
	} else {
		//         c := block.Count(rec.key)
		//         ratio := float(c) / float(block.MaxRecordCount())
		if block.Full() {
			firstr, _, _, _ := block.Get(0)
			if block.Count(firstr.GetKey()) == int(block.MaxRecordCount()) {
				if !r.GetKey().Lt(firstr.GetKey()) {
					block := findlastblock(block, firstr.GetKey())
					dirty.Insert(block)
					//                     fmt.Println("Magic Heres Abouts", r, "\n", block)
					if block.Full() || !r.GetKey().Eq(firstr.GetKey()) {
						newblock := self.allocate(self.external)
						dirty.Insert(newblock)
						p, _ := block.GetExtraPtr()
						newblock.SetExtraPtr(p)
						block.SetExtraPtr(newblock.Position())
						if _, ok := newblock.Add(r); !ok {
							panic("347 could not add to empty block")
						}
						if r.GetKey().Eq(firstr.GetKey()) {
							return nil, nil, false
						} else {
							//                         return newblock, rec_to_tmp(self, self.internal.NewRecord(firstr.GetKey().Inc())), true
							return newblock, rec_to_tmp(self, r), true
						}
					} else {
						block.Add(r)
						return nil, nil, false
					}
				} else {
					//                     fmt.Println("more magic", r, firstr)
					newblock := self.allocate(self.external)
					dirty.Insert(block)
					dirty.Insert(newblock)
					p, _ := block.GetExtraPtr()
					newblock.SetExtraPtr(p)
					block.SetExtraPtr(newblock.Position())
					self.mv(block, newblock)
					if _, ok := block.Add(r); !ok {
						panic("366 could not add to empty block")
					}
					return newblock, rec_to_tmp(self, firstr), true
				}
			}
		}
	}
	// this block is changed
	dirty.Insert(block)
	if i, ok := block.Add(r); ok {
		// Block isn't full record inserted, now insert pointer (if one exists)
		// return to parent saying it has nothing to do
		if block.Mode()&POINTERS == POINTERS && nextb != nil {
			if ok := block.InsertPointer(i, nextb.Position()); !ok {
				panic("pointer insert failed")
			}
		} else if block.Mode()&POINTERS == 0 && nextb != nil {
			panic("tried to set a pointer on a block with no pointers")
		}
		return nil, nil, false
	} else if i == -2 {
		// Dotty("error.dot", self)
		dirty.Sync()
		// Dotty("error2.dot", self)
		msg := fmt.Sprint(
			"tried to insert a duplicate key into a block which does not allow that.\n", r, "\n", block)
		panic(msg)
	}
	// Block is full split the block
	return self.split(block, rec, nextb, dirty)
}
Esempio n. 2
0
/*
   split takes a block figures out how to split it and splits it between the two blocks, it passes back
   the splitting record, and a pointer new block, and whether or not it succeeded
   nextb is the block that will be pointed at by one of the blocks
        ie. it was a block that was allocated by the previous split, normally a pointer to it would have
            been inserted into the block that is being split, but as that block is full it needs to go into
            one of the blocks here
        the function should always return a valid btree if the record it returns becomes the record at the root
        level.
*/
func (self *BTree) split(block *KeyBlock, rec *Record, nextb *KeyBlock, dirty *dirty.DirtyBlocks) (*KeyBlock, *Record, bool) {
	var split_rec *Record
	new_block := self.allocate()
	dirty.Insert(new_block)
	i, _, _, _, _ := block.Find(rec.GetKey())
	m := self.node.KeysPerBlock() >> 1
	//     fmt.Println("m=", m)
	if m > i {
		split_rec, _, _, _ = block.Get(m - 1)
		block.RemoveAtIndex(m - 1)
		if _, ok := block.Add(rec); !ok {
			fmt.Println("Inserting record into block failed PANIC")
			os.Exit(3)
		}
	} else if m < i {
		split_rec, _, _, _ = block.Get(m)
		block.RemoveAtIndex(m)
		if _, ok := block.Add(rec); !ok {
			fmt.Println("Inserting record into block failed PANIC")
			os.Exit(3)
		}
	} else {
		split_rec = rec
	}
	self.balance_blocks(block, new_block)
	dirty.Sync() // figure out how to remove
	if nextb != nil {
		//         fmt.Println("NEXTB: ", nextb)
		nextr, _, _, _ := nextb.Get(0)
		if i, _, _, _, ok := block.Find(rec.GetKey()); ok {
			// if this pointer is going into the old block that means there will be too many pointers in this block
			// so we must move the last one over to the new block

			if p, ok := block.GetPointer(m); ok {
				new_block.InsertPointer(0, p)
			}
			block.RemovePointer(m)

			_, left, _, _ := block.Get(i)
			//             fmt.Println("left=", left)
			lblock := self.getblock(left)
			r, _, _, _ := lblock.Get(0)
			//             fmt.Println("empty")
			//             fmt.Printf("nextr %v > %v r, %v\n", nextr.GetKey(), r.GetKey(), nextr.GetKey().Gt(r.GetKey()))
			if nextr.GetKey().Gt(r.GetKey()) {
				//                 fmt.Println("i=", i, "+1")
				block.InsertPointer(i+1, nextb.Position())
			} else {
				//                 fmt.Println("i=", i)
				block.InsertPointer(i, nextb.Position())
			}
		} else {
			i, _, _, _, _ := new_block.Find(rec.GetKey())
			_, left, _, _ := new_block.Get(i)
			//             fmt.Println("left=", left)
			lblock := self.getblock(left)
			r, _, _, _ := lblock.Get(0)
			//             fmt.Println("empty")
			//             fmt.Printf("nextr %v > %v r, %v\n", nextr.GetKey(), r.GetKey(), nextr.GetKey().Gt(r.GetKey()))
			if nextr.GetKey().Gt(r.GetKey()) {
				//                 fmt.Println("i=", i, "+1")
				new_block.InsertPointer(i+1, nextb.Position())
			} else {
				//                 fmt.Println("i=", i)
				new_block.InsertPointer(i, nextb.Position())
			}
		}
	}
	//     j, _, _, _, _ := new_block.Find(split_rec.GetKey())
	//     fmt.Println("split .... ", j)
	//     fmt.Println(new_block.Position(), split_rec, true)
	return new_block, split_rec, true
}