Now handle duplicates properly by doing a right shift.

Author: dustinhiatt-wf

rtree/hilbert/action.go

@@ -62,7 +62,7 @@ func (ga *getAction) nodes() []*node {
 }
 
 func (ga *getAction) rects() []*hilbertBundle {
-	return nil
+	return []*hilbertBundle{&hilbertBundle{}}
 }
 
 func newGetAction(rect rtree.Rectangle) *getAction {

rtree/hilbert/node.go

@@ -17,22 +17,51 @@ limitations under the License.
 package hilbert
 
 import (
+	"log"
 	"sort"
 
 	"github.com/Workiva/go-datastructures/rtree"
 )
 
+func init() {
+	log.Printf(`I HATE THIS.`)
+}
+
 type hilbert int64
 
 type hilberts []hilbert
 
-func getParent(parent *node, key hilbert) *node {
+func getParent(parent *node, key hilbert, r1 rtree.Rectangle) *node {
 	var n *node
 	for parent != nil && !parent.isLeaf {
 		n = parent.searchNode(key)
 		parent = n
 	}
 
+	if parent != nil && r1 != nil { // must be leaf and we need exact match
+		// we are safe to travel to the right
+		i := parent.search(key)
+		for parent.keys.byPosition(i) == key {
+			if equal(parent.nodes.list[i], r1) {
+				break
+			}
+
+			i++
+			if i == parent.keys.len() {
+				if parent.right == nil { // we are far to the right
+					break
+				}
+
+				if parent.right.keys.byPosition(0) != key {
+					break
+				}
+
+				parent = parent.right
+				i = 0
+			}
+		}
+	}
+
 	return parent
 }
 
@@ -195,8 +224,8 @@ type node struct {
 
 func (n *node) insert(kb *keyBundle) rtree.Rectangle {
 	i := n.keys.search(kb.key)
-	if n.isLeaf && i != n.keys.len() { // we can have multiple keys with the same hilbert number
-		for n.keys.list[i] == kb.key {
+	if n.isLeaf { // we can have multiple keys with the same hilbert number
+		for i < n.keys.len() && n.keys.list[i] == kb.key {
 			if equal(n.nodes.list[i], kb.left) {
 				old := n.nodes.list[i]
 				n.nodes.list[i] = kb.left

rtree/hilbert/tree.go

@@ -57,15 +57,15 @@ type keyBundle struct {
 
 type tree struct {
 	root            *node
-	_padding0       [8]uint64
+	_               [8]uint64
 	number          uint64
-	_padding1       [8]uint64
+	_               [8]uint64
 	ary, bufferSize uint64
 	actions         *queue.RingBuffer
 	cache           []interface{}
-	buffer0         [8]uint64
+	_               [8]uint64
 	disposed        uint64
-	buffer1         [8]uint64
+	_               [8]uint64
 	running         uint64
 }
 
@@ -169,7 +169,7 @@ func (tree *tree) fetchKeysInSerial(xns interfaces) {
 		switch action.operation() {
 		case add, remove:
 			for i, key := range action.rects() {
-				n := getParent(tree.root, key.hilbert)
+				n := getParent(tree.root, key.hilbert, key.rect)
 				action.addNode(int64(i), n)
 			}
 		case get:
@@ -217,16 +217,17 @@ func (tree *tree) fetchKeysInParallel(xns []interface{}) {
 				action := xns[index].(action)
 
 				j := atomic.AddInt64(&forCache.js[index], 1)
-				if j > int64(len(action.keys())) { // someone else is updating i
+				if j > int64(len(action.rects())) { // someone else is updating i
 					continue
-				} else if j == int64(len(action.keys())) {
+				} else if j == int64(len(action.rects())) {
 					atomic.StoreInt64(&forCache.i, index+1)
 					continue
 				}
 
 				switch action.operation() {
 				case add, remove:
-					n := getParent(tree.root, action.keys()[j])
+					hb := action.rects()[j]
+					n := getParent(tree.root, hb.hilbert, hb.rect)
 					action.addNode(j, n)
 				case get:
 					ga := action.(*getAction)

rtree/hilbert/tree_test.go

@@ -121,7 +121,7 @@ func TestDeleteIdenticalHilbergNumber(t *testing.T) {
 }
 
 func TestDeleteAll(t *testing.T) {
-	points := constructRandomMockPoints(5)
+	points := constructRandomMockPoints(3)
 	tree := newTree(3, 3)
 	tree.Insert(points...)
 	assert.Equal(t, uint64(len(points)), tree.Len())
@@ -346,6 +346,56 @@ func TestMultipleInsertsCauseInternalSplitEvenAryRandomOrder(t *testing.T) {
 	}
 }
 
+func TestInsertDuplicateHilbert(t *testing.T) {
+	r1 := newMockRectangle(0, 0, 20, 20)
+	r2 := newMockRectangle(1, 1, 19, 19)
+	r3 := newMockRectangle(2, 2, 18, 18)
+	r4 := newMockRectangle(3, 3, 17, 17)
+	tree := newTree(3, 3)
+	tree.Insert(r1)
+	tree.Insert(r2)
+	tree.Insert(r3)
+	tree.Insert(r4)
+
+	assert.Equal(t, uint64(4), tree.Len())
+	q := newMockRectangle(0, 0, 30, 30)
+	result := tree.Search(q)
+	assert.Len(t, result, 4)
+	assert.Contains(t, result, r1)
+	assert.Contains(t, result, r2)
+	assert.Contains(t, result, r3)
+	assert.Contains(t, result, r4)
+}
+
+func TestDeleteAllDuplicateHilbert(t *testing.T) {
+	r1 := newMockRectangle(0, 0, 20, 20)
+	r2 := newMockRectangle(1, 1, 19, 19)
+	r3 := newMockRectangle(2, 2, 18, 18)
+	r4 := newMockRectangle(3, 3, 17, 17)
+	tree := newTree(3, 3)
+	tree.Insert(r1)
+	tree.Insert(r2)
+	tree.Insert(r3)
+	tree.Insert(r4)
+
+	tree.Delete(r1, r2, r3, r4)
+	assert.Equal(t, uint64(0), tree.Len())
+	result := tree.Search(constructInfiniteRect())
+	assert.Len(t, result, 0)
+}
+
+func TestInsertDuplicateRect(t *testing.T) {
+	r1 := newMockRectangle(0, 0, 20, 20)
+	r2 := newMockRectangle(0, 0, 20, 20)
+	tree := newTree(3, 3)
+	tree.Insert(r1)
+	tree.Insert(r2)
+
+	assert.Equal(t, uint64(1), tree.Len())
+	result := tree.Search(constructInfiniteRect())
+	assert.Equal(t, rtree.Rectangles{r2}, result)
+}
+
 func BenchmarkBulkAddPoints(b *testing.B) {
 	numItems := 1000
 	points := constructMockPoints(numItems)
@@ -408,3 +458,16 @@ func BenchmarkQueryBulkPoints(b *testing.B) {
 		tree.Search(newMockRectangle(i, i, int32(numItems), int32(numItems)))
 	}
 }
+
+func BenchmarkDelete(b *testing.B) {
+	numItems := b.N
+	points := constructMockPoints(numItems)
+	tree := newTree(8, 8)
+	tree.Insert(points...)
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		tree.Delete(points[i%numItems])
+	}
+}