Create server

Author: CodeHariK

.tool-versions

@@ -1,3 +1,4 @@
 golang 1.23.1
 zig 0.13.0
 bun 1.2.2
+buf 1.50.0

secretary/btree.go

@@ -1,6 +1,7 @@
 package secretary
 
 import (
+	"bytes"
 	"fmt"
 
 	"github.com/codeharik/secretary/utils"
@@ -27,7 +28,7 @@ func NewBTree(
 
 	safeCollectionName := utils.SafeCollectionString(collectionName)
 	if len(safeCollectionName) < 5 || len(safeCollectionName) > MAX_COLLECTION_NAME_LENGTH {
-		return nil, ErrorInvalidCollectionName()
+		return nil, ErrorInvalidCollectionName
 	}
 
 	if err := utils.EnsureDir(fmt.Sprintf("%s/%s", SECRETARY, safeCollectionName)); err != nil {
@@ -107,3 +108,48 @@ func (tree *BTree) SaveHeader() error {
 
 	return tree.nodeBatchStore.WriteAt(0, header)
 }
+
+func NewBTreeReadHeader(collectionName string) (*BTree, error) {
+	temp, err := NewBTree(collectionName,
+		10,
+		0,
+		0,
+		125,
+		0,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	diskData, err := temp.nodeBatchStore.ReadAt(0, SECRETARY_HEADER_LENGTH)
+	if err != nil {
+		return nil, err
+	}
+
+	data := bytes.Trim(diskData, "-")[len(SECRETARY):]
+	var deserializedTree BTree
+	err = binstruct.Deserialize(data, &deserializedTree)
+	if err != nil {
+		return nil, err
+	}
+
+	return &deserializedTree, nil
+}
+
+func (t *BTree) Height() int {
+	if t.root == nil {
+		return 0
+	}
+
+	height := 0
+	node := t.root
+	for node != nil {
+		height++
+		if len(node.children) == 0 { // Leaf node reached
+			break
+		}
+		node = node.children[0] // Move to the first child
+	}
+
+	return height
+}

secretary/btree_test.go

@@ -74,7 +74,7 @@ func TestBtreeInvalid(t *testing.T) {
 	}
 }
 
-func TestSaveHeader(t *testing.T) {
+func TestSaveReadHeader(t *testing.T) {
 	tree, err := NewBTree(
 		"TestSaveHeader",
 		10,
@@ -87,210 +87,61 @@ func TestSaveHeader(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	// Save header
 	err = tree.SaveHeader()
 	if err != nil {
 		t.Fatalf("SaveHeader failed: %v", err)
 	}
 
-	// Retrieve data from mock store
-	savedData, err := tree.nodeBatchStore.ReadAt(0, SECRETARY_HEADER_LENGTH)
+	deserializedTree, err := NewBTreeReadHeader(tree.CollectionName)
 	if err != nil {
-		t.Fatalf("Failed to read written data: %v", err)
-	}
-
-	// Serialize again for comparison
-	expectedData, err := tree.createHeader()
-	if err != nil {
-		t.Fatalf("Failed to serialize expected data: %v", err)
+		t.Fatal(err)
 	}
 
-	if len(savedData) != SECRETARY_HEADER_LENGTH {
-		t.Fatalf("Expected serialized data to be %d bytes, got %d", SECRETARY_HEADER_LENGTH, len(expectedData))
+	eq, err := binstruct.Compare(*tree, *deserializedTree)
+	if !eq || err != nil {
+		t.Fatalf("\nShould be Equal\n")
 	}
 
-	// Compare written data with expected serialized header
-	if !bytes.Equal(savedData, expectedData) {
-		t.Errorf("Saved header does not match expected serialized data")
+	tJson, tErr := binstruct.MarshalJSON(*tree)
+	dJson, dErr := binstruct.MarshalJSON(deserializedTree)
+	if dErr != nil || tErr != nil || bytes.Compare(tJson, dJson) != 0 {
+		t.Log("\n", string(tJson), "\n", string(dJson))
 	}
 }
 
-// func TestSearchOperations(t *testing.T) {
-// 	tree, _ := NewBPlusTree(4)
-// 	keys := []int{10, 5, 15, 20, 25, 30, 35}
-
-// 	// Test search on empty tree
-// 	if tree.Search(10) {
-// 		t.Error("Search should return false on empty tree")
-// 	}
-
-// 	// Insert keys and verify existence
-// 	for _, key := range keys {
-// 		tree.Insert(key)
-// 		if !tree.Search(key) {
-// 			t.Errorf("Key %d should exist after insertion", key)
-// 		}
-// 	}
-
-// 	// Test non-existent keys
-// 	nonExistent := []int{-5, 7, 33, 100}
-// 	for _, key := range nonExistent {
-// 		if tree.Search(key) {
-// 			t.Errorf("Key %d should not exist", key)
-// 		}
-// 	}
-
-// 	// Test after deletions
-// 	tree.Delete(15)
-// 	if tree.Search(15) {
-// 		t.Error("Deleted key 15 should not exist")
-// 	}
-// }
-
-// func TestInsertAndSearch(t *testing.T) {
-// 	tree, _ := NewBPlusTree(4)
-// 	keys := []int{10, 5, 15, 20, 25, 30, 35}
-
-// 	for _, key := range keys {
-// 		tree.Insert(key)
-// 	}
-
-// 	// Test existing keys
-// 	for _, key := range keys {
-// 		if !tree.Search(key) {
-// 			t.Errorf("Key %d should exist", key)
-// 		}
-// 	}
-
-// 	// Test non-existent keys
-// 	nonExistent := []int{-5, 7, 33, 100}
-// 	for _, key := range nonExistent {
-// 		if tree.Search(key) {
-// 			t.Errorf("Key %d should not exist", key)
-// 		}
-// 	}
-// }
-
-// func TestLeafNodeOperations(t *testing.T) {
-// 	tree, _ := NewBPlusTree(4)
-
-// 	// Test single node insertion
-// 	tree.Insert(10)
-// 	if !tree.root.leaf || tree.root.numKeys != 1 {
-// 		t.Error("Root should be single-key leaf node")
-// 	}
-
-// 	// Test leaf node split
-// 	keys := []int{20, 30, 40} // Fill root leaf node
-// 	for _, key := range keys {
-// 		tree.Insert(key)
-// 	}
-
-// 	// After inserting 40, the leaf should split
-// 	if tree.root.leaf {
-// 		t.Error("Root should be internal node after split")
-// 	}
-// 	if tree.root.numKeys != 1 {
-// 		t.Error("Root should have one key after first split")
-// 	}
-// }
-
-// func TestDeleteOperations(t *testing.T) {
-// 	tree, _ := NewBPlusTree(4)
-// 	keys := []int{5, 10, 15, 20, 25, 30, 35, 40}
-// 	for _, key := range keys {
-// 		tree.Insert(key)
-// 	}
-
-// 	// Test simple deletion
-// 	tree.Delete(15)
-// 	if tree.Search(15) {
-// 		t.Error("Deleted key 15 should not exist")
-// 	}
-
-// 	// Test deletion causing rebalance
-// 	tree.Delete(5)
-// 	tree.Delete(10)
-// 	tree.Delete(20)
-
-// 	remaining := []int{25, 30, 35, 40}
-// 	for _, key := range remaining {
-// 		if !tree.Search(key) {
-// 			t.Errorf("Key %d should exist after deletions", key)
-// 		}
-// 	}
-// }
+// func TestBTreeHeight(t *testing.T) {
+// 	tree := &BTree{}
 
-// func TestRangeQueries(t *testing.T) {
-// 	tree, _ := NewBPlusTree(4)
-// 	for i := 0; i < 20; i++ {
-// 		tree.Insert(i * 5) // 0, 5, 10, ..., 95
+// 	// Insert first key-value pair (root node only)
+// 	key1 := []byte(utils.GenerateRandomString(16))
+// 	value1 := []byte("Hello world!")
+// 	err := tree.Insert(key1, value1)
+// 	if err != nil {
+// 		t.Errorf("Insert failed: %s", err)
 // 	}
-
-// 	testCases := []struct {
-// 		start, end int
-// 		expected   []int
-// 	}{
-// 		{0, 100, generateSequence(0, 95, 5)},
-// 		{25, 50, generateSequence(25, 50, 5)},
-// 		{12, 18, []int{15}},
-// 		{100, 200, []int{}},
-// 		{0, 0, []int{0}},
+// 	if tree.Height() != 1 {
+// 		t.Errorf("Expected height 1, got %d", tree.Height())
 // 	}
 
-// 	for _, tc := range testCases {
-// 		result := tree.FindRange(tc.start, tc.end)
-// 		if !slices.Equal(result, tc.expected) {
-// 			t.Errorf("Range [%d-%d] expected %v, got %v",
-// 				tc.start, tc.end, tc.expected, result)
+// 	// Insert more keys to increase height
+// 	for i := 0; i < 3; i++ {
+// 		key := []byte(utils.GenerateRandomString(16))
+// 		value := []byte(fmt.Sprintf("value : %d", i))
+// 		err = tree.Insert(key, value)
+// 		if err != nil {
+// 			t.Errorf("Insert failed: %s", err)
 // 		}
 // 	}
-// }
-
-// func TestLeafLinkage(t *testing.T) {
-// 	tree, _ := NewBPlusTree(4)
-// 	keys := []int{5, 10, 15, 20, 25, 30, 35, 40}
-// 	for _, key := range keys {
-// 		tree.Insert(key)
-// 	}
 
-// 	// Verify leaf order
-// 	expected := []int{5, 10, 15, 20, 25, 30, 35, 40}
-// 	var leaves []int
-// 	current := tree.findLeaf(-1)
-// 	for current != nil {
-// 		leaves = append(leaves, current.keys[:current.numKeys]...)
-// 		current = current.next
+// 	// Check if the height increased after multiple insertions
+// 	if tree.Height() != 3 {
+// 		t.Errorf("Expected height %d", tree.Height())
 // 	}
 
-// 	if !slices.Equal(leaves, expected) {
-// 		t.Errorf("Leaf traversal order incorrect, got %v", leaves)
-// 	}
-// }
-
-// func TestInternalNodeOperations(t *testing.T) {
-// 	tree, _ := NewBPlusTree(4)
-
-// 	// Insert enough keys to create multiple levels
-// 	for i := 100; i > 0; i-- {
-// 		tree.Insert(i)
-// 	}
-
-// 	// Verify root properties
-// 	if tree.root.leaf || tree.root.numKeys < 1 {
-// 		t.Error("Root should be internal node with multiple keys")
-// 	}
-
-// 	// Verify search in deep tree
-// 	if !tree.Search(42) || tree.Search(101) {
-// 		t.Error("Search in deep tree failed")
-// 	}
-// }
-
-// func generateSequence(start, end, step int) []int {
-// 	var seq []int
-// 	for i := start; i <= end; i += step {
-// 		seq = append(seq, i)
+// 	jsonOutput, err := tree.ConvertBTreeToJSON()
+// 	if err != nil {
+// 		fmt.Println("Error:", err)
+// 		return
 // 	}
-// 	return seq
+// 	t.Log(tree.Order, jsonOutput)
 // }