fixed btree tests. delete seems to work

Author: Mason Chang

src/coffeedb/CoffeeDB.java

@@ -170,7 +170,7 @@ private void btreeTests() {
 
 		System.out.println(btree.toString());
 
-		for (int i = 0; i < 1; i++) {
+		for (int i = 0; i < 5; i++) {
 			Tuple tuple = Tuple.createTupleAndSchema(i, "test");
 			System.out.println("Deleting tuple: " + tuple);
 			btree.deleteKey(tuple.getValue(0));

src/coffeedb/core/Btree.java

@@ -17,13 +17,17 @@ public Btree(int branchFactor) {
 
 	public BtreeNode findBucket(BtreeNode node, Value key) {
 		if (node.isLeaf()) {
-			return (BtreeLeafNode) node;
+			return node;
 		}
 
 		BtreeInternalNode internalNode = (BtreeInternalNode) node;
 		return internalNode.getChild(key);
 	}
 
+	public BtreeLeafNode findLeaf(Value key) {
+		return (BtreeLeafNode) findBucket(_root, key);
+	}
+	
 	private boolean isRoot(BtreeNode node) {
 		return _root == node;
 	}
@@ -55,11 +59,15 @@ public void addKey(Value key, Tuple tuple) {
 		}
 	}
 
+	public boolean isEmpty() {
+		return _root.isEmpty();
+	}
+	
 	public void deleteKey(Value key) {
 		BtreeLeafNode leaf = (BtreeLeafNode) findBucket(_root, key);
 		leaf.deleteKey(key);
 
-		if (leaf.needsMerge()) {
+		if (!isRoot(leaf) && leaf.needsMerge()) {
 			mergeNode(leaf);
 		}
 	}
@@ -332,6 +340,34 @@ public String toString() {
 		}
 
 		return buffer.toString();
+	}
+	
+	public int getBranchFactor() {
+		return _branchFactor;
+	}
+	
+	public BtreeNode getRoot() {
+		assert (_root != null);
+		return _root;
+	}
+	
+	public int getNumberOfNodes() {
+		LinkedList<BtreeNode> queue = new LinkedList<BtreeNode>();
+		queue.add(_root);
+		int count = 0;
+		
+		while (!queue.isEmpty()) {
+			BtreeNode node = queue.removeFirst();
+			count++;
+			
+			if (node.isLeaf()) continue;
+			
+			BtreeInternalNode internalNode = (BtreeInternalNode) node;
+			for (BtreeNode child : internalNode.getChildren()) {
+				queue.add(child);
+			}
+		}
 
+		return count;
 	}
 }

src/coffeedb/core/BtreeLeafNode.java

@@ -115,6 +115,10 @@ public boolean isEmpty() {
 
 		return false;
 	}
+	
+	public boolean hasNext() {
+		return _next != null;
+	}
 
 	public BtreeLeafNode getNext() {
 		return _next;
@@ -154,4 +158,12 @@ public void clean() {
 	public Value getTupleKey(Tuple tuple) {
 		return tuple.getValue(KEY_INDEX);
 	}
+	
+	public boolean containsTuple(Tuple tuple) {
+		for (Tuple t : _tuples) {
+			if (tuple.equals(t)) return true;
+		}
+		
+		return false;
+	}
 }

test/coffeedb/test/core/BtreeTests.java

@@ -15,6 +15,7 @@
 import coffeedb.Tuple;
 import coffeedb.Value;
 import coffeedb.core.Btree;
+import coffeedb.core.BtreeInternalNode;
 import coffeedb.core.BtreeLeafNode;
 import coffeedb.core.BtreeNode;
 
@@ -37,27 +38,29 @@ public void setUp() throws Exception {
 	@After
 	public void tearDown() throws Exception {
 	}
-	/*
+	
 	private void leavesHaveTuplesInOrder(List<Tuple> tuples) {
 		assert (!tuples.isEmpty());
 		Tuple first = tuples.get(0);
 		Value firstKey = first.getValue(0);
 
 		BtreeLeafNode bucket = _instance.findLeaf(firstKey);
-		for (int i = 0; i < tuples.size(); i++) {
-			if (((i % Btree.BRANCH_FACTOR) == 0) && (i != 0)) {
-				if (bucket.hasNextLeaf()) {
-					bucket = bucket.getNextLeaf();
-					assert (bucket != null);
-				}
+		for (int i = 0; i < tuples.size(); ) {
+			List<Tuple> bucketTuples = bucket.getTuples();
+			
+			for (int j = 0; j < bucketTuples.size(); j++) {
+				Tuple bucketTuple = bucketTuples.get(j);
+				Tuple listTuple = tuples.get(i);
+				assertTrue(bucketTuple.equals(listTuple));
+				i++;
 			}
 
-			Tuple tuple = tuples.get(i);
-			assertTrue(bucket.containsTuple(tuple));
+			if (bucket.hasNext()) {
+				bucket = bucket.getNext();
+			}
 		}
 	}
 
-	/*
 	private boolean tuplesExist(List<Tuple> tuples) {
 		for (Tuple t : tuples) {
 			Value key = t.getValue(0);
@@ -84,15 +87,16 @@ public void insertTest() {
 	public void splitLeafTest() {
 		HashMap<Value, Tuple> insertions = new HashMap<Value, Tuple>();
 		// Force one split
-		for (int i = 0; i <= Btree.BRANCH_FACTOR; i++) {
+		for (int i = 0; i <= _instance.getBranchFactor(); i++) {
 			Tuple tuple = Tuple.createTupleAndSchema(i, "key");
 			Value key = tuple.getValue(0);
 			_instance.addKey(key, tuple);
 			insertions.put(key,  tuple);
 		}
 
-		BtreeNode root = _instance.getRoot();
-		assertTrue(_instance.getTreeSize() == 3);
+		BtreeInternalNode root = (BtreeInternalNode) _instance.getRoot();
+		assertTrue(_instance.getNumberOfNodes() == 3); 
+		
 		assertTrue(root.getChildren().size() == 2);
 
 		for (BtreeNode child : root.getChildren()) {
@@ -166,5 +170,17 @@ public void testSingleDelete() {
 		deleteTuples(insertedTuples);
 		assertFalse(tuplesExist(insertedTuples));
 	}
-	*/
+	
+	@Test
+	public void deleteAllTuples() {
+		int records[] = { 1, 4, 47, 49 };
+		List<Tuple> insertedTuples = insertTuples(records);
+		assertTrue(tuplesExist(insertedTuples));
+		
+		deleteTuples(insertedTuples);
+		assertFalse(tuplesExist(insertedTuples));
+		
+		int numberOfNodes = _instance.getNumberOfNodes();
+		assertTrue(numberOfNodes == 1);
+	}
 }