Add Insert function for schema_table

Author: Chaitya62

buffer/buffer_pool_manager.go

@@ -8,11 +8,12 @@ import (
 )
 
 type BufferPoolManager struct {
-	pages      []page.Page
-	dmi        diskio.DiskManager
-	free_list  *list.List
-	page_table *PageTable
-	replacer   Replacer
+	pages       []page.Page
+	dmi         diskio.DiskManager
+	free_list   *list.List
+	page_table  *PageTable
+	replacer    Replacer
+	buffer_size int
 }
 
 func GetNewBufferPoolManager(buffer_size int, dmi diskio.DiskManager) *BufferPoolManager {
@@ -25,6 +26,7 @@ func (bpm *BufferPoolManager) Init(buffer_size int, dmi diskio.DiskManager) {
 	bpm.pages = make([]page.Page, buffer_size)
 	bpm.dmi = dmi
 	bpm.free_list = list.New()
+	bpm.buffer_size = buffer_size
 	bpm.replacer = NewClockReplacer(buffer_size)
 	for i := 0; i < buffer_size; i++ {
 		bpm.free_list.PushBack(i)
@@ -49,6 +51,23 @@ func (bpm *BufferPoolManager) UnPinPage(page_id uint32) bool {
 	return ok
 }
 
+func (bpm *BufferPoolManager) PersistAll() {
+	for i := 0; i < bpm.buffer_size; i++ {
+		if bpm.pages[i] != nil {
+			if bpm.pages[i].IsDirty() {
+				bpm.dmi.WritePage(bpm.pages[i].GetPageId(), bpm.pages[i])
+			}
+		}
+	}
+}
+
+func (bpm *BufferPoolManager) AllocatePage(page_id uint32) page.Page {
+	_page := bpm.GetPage(page_id) // this will written a page with invalid id
+	_page.SetPageId(page_id)
+	bpm.dmi.WritePage(page_id, _page)
+	return _page
+}
+
 // not thread safe
 func (bpm *BufferPoolManager) GetPage(page_id uint32) page.Page {
 	// if page is not there
@@ -69,7 +88,15 @@ func (bpm *BufferPoolManager) GetPage(page_id uint32) page.Page {
 		frame_i, ok := bpm.replacer.GetNextVictim()
 		if ok {
 			free_frame_i = frame_i
-			// add logic to if page is dirty write it to disk
+
+			// delete entry from PageTable
+			bpm.page_table.Delete(bpm.pages[frame_i].GetPageId())
+
+			// persist dirty page to disk
+			if bpm.pages[frame_i].IsDirty() {
+				bpm.dmi.WritePage(bpm.pages[frame_i].GetPageId(), bpm.pages[frame_i])
+			}
+
 		} else {
 			fmt.Println("Couldn't find a page")
 		}

buffer/page_table.go

@@ -1,7 +1,7 @@
 package buffer
 
 import (
-	"fmt"
+	//	"fmt"
 	"sync"
 )
 
@@ -23,8 +23,14 @@ func (pt *PageTable) InsertOrUpdate(key uint32, val int) {
 	pt.index[key] = val
 }
 
+func (pt *PageTable) Delete(key uint32) {
+	pt._lock.Lock()
+	defer pt._lock.Unlock()
+	delete(pt.index, key)
+}
+
 func (pt *PageTable) Get(key uint32) (int, bool) {
-	fmt.Println("Getting Page", key)
+	//	fmt.Println("Getting Page", key)
 	pt._lock.RLock()
 	defer pt._lock.RUnlock()
 	if val, ok := pt.index[key]; ok {

main.go

@@ -95,5 +95,17 @@ func main() {
 	schema_table := new(schema.SchemaTable)
 	schema_table.Init()
 
+	//for i := 0; i < 1000; i++ {
+	//	tuple := schema_table.GetDefaultRow()
+	//	tuple.SetValueFor(schema.SCHEMA_ID, int64(i))
+	//	tuple.SetValueFor(schema.SCHEMA_TABLE_ID, int64(0i))
+	//	tuple.SetValueFor(schema.SCHEMA_TABLE_NAME, "first_table")
+	//	tuple.SetValueFor(schema.SCHEMA_COLUMN_NAME, "id")
+	//	tuple.SetValueFor(schema.SCHEMA_COLUMN_POSITION, int64(1))
+	//	tuple.SetValueFor(schema.SCHEMA_COLUMN_TYPE, "INTEGER")
+	//	schema_table.Insert(tuple)
+	//}
+
+	schema_table.Close()
 	schema_table.Iterator()
 }

schema/schema_table.go

@@ -6,11 +6,21 @@ package schema
 // Each table is a new file
 
 import (
+	//	"fmt"
 	"github.com/chaitya62/noobdb/buffer"
 	"github.com/chaitya62/noobdb/storage/disk"
 	"github.com/chaitya62/noobdb/storage/page"
 )
 
+const (
+	SCHEMA_ID = iota
+	SCHEMA_TABLE_ID
+	SCHEMA_TABLE_NAME
+	SCHEMA_COLUMN_POSITION
+	SCHEMA_COLUMN_NAME
+	SCHEMA_COLUMN_TYPE
+)
+
 const schema_file = "schema.txt"
 
 type SchemaTable struct {
@@ -26,6 +36,55 @@ func (st *SchemaTable) Init() {
 	st.bpm = buffer.GetNewBufferPoolManager(3, st.dmi)
 }
 
+func (st *SchemaTable) GetDefaultRow() page.Tuple {
+	tuple := new(page.TupleImpl)
+	tuple.Init(st._schema[:])
+	return tuple
+}
+
+func (st *SchemaTable) Insert(tuple page.Tuple) error {
+	no_of_pages := st.dmi.GetNumberOfPages()
+	var page_id uint32
+	var _schemaPage *page.SchemaPage
+	if no_of_pages == 0 {
+		// create a new page
+		// when schema table is empty
+		page_id = uint32(0)
+		_page := st.bpm.AllocatePage(page_id)
+		_pageImpl := _page.(*page.PageImpl)
+		_schemaPage = &page.SchemaPage{PageImpl: *_pageImpl}
+		_schemaPage.Init()
+	} else {
+		page_id = uint32(no_of_pages - 1)
+		_page := st.bpm.GetPage(page_id)
+		_pageImpl := _page.(*page.PageImpl)
+		_schemaPage = &page.SchemaPage{PageImpl: *_pageImpl}
+	}
+
+	st.bpm.PinPage(page_id)
+	err := _schemaPage.InsertTuple(tuple)
+	st.bpm.UnPinPage(page_id)
+
+	// page is full
+	// allocate new page
+	if err != nil {
+		page_id = uint32(page_id + 1)
+		_page := st.bpm.AllocatePage(page_id)
+		_pageImpl := _page.(*page.PageImpl)
+		_schemaPage = &page.SchemaPage{PageImpl: *_pageImpl}
+		_schemaPage.Init()
+
+		// we assume each tuple can fit in a page of size 4096 bytes
+		st.bpm.PinPage(page_id)
+		err = _schemaPage.InsertTuple(tuple)
+		st.bpm.UnPinPage(page_id)
+
+	}
+
+	return nil
+
+}
+
 //TODO: Convert this to an iterator design pattern
 // https://ewencp.org/blog/golang-iterators/index.html
 func (st *SchemaTable) Iterator() {
@@ -46,3 +105,8 @@ func (st *SchemaTable) Iterator() {
 		}
 	}
 }
+
+// sanatize and persist everything to disk
+func (st *SchemaTable) Close() {
+	st.bpm.PersistAll()
+}

storage/page/page.go

@@ -1,26 +1,40 @@
 package page
 
-import "errors"
+import (
+	"errors"
+	"fmt"
+)
 
 const PAGE_SIZE = 4096
 const INVALID_PAGE_ID = 4294967295
 
 type Page interface {
+	Init()
 	GetData() []byte
 	GetPageId() uint32
 	SetData([]byte) error
 	SetPageId(page_id uint32)
+	IsDirty() bool
+	SetDirtyBit(val bool)
 }
 
 type PageImpl struct {
-	_data      [PAGE_SIZE]byte
+	_data      []byte
 	_page_id   uint32
 	_dirty     bool
 	_pin_count uint64
 }
 
+func (p *PageImpl) IsDirty() bool {
+	return p._dirty
+}
+
+func (p *PageImpl) SetDirtyBit(val bool) {
+	p._dirty = val
+}
+
 func (p *PageImpl) GetData() []byte {
-	return p._data[:]
+	return p._data
 }
 
 func (p *PageImpl) GetPageId() uint32 {
@@ -31,28 +45,35 @@ func (p *PageImpl) SetData(d []byte) error {
 	if len(d) != PAGE_SIZE {
 		return errors.New("Invalid Data slice")
 	}
-	copy(p._data[:], d)
+	p._data = d
 	p._page_id = (uint32(d[0]) | (uint32(d[1]) << 8) | (uint32(d[2]) << 16) | (uint32(d[3]) << 24))
 	p._dirty = true
 	return nil
 }
 
-func (p *PageImpl) ResetMemory() error {
-	copy(p._data[:], make([]byte, PAGE_SIZE))
+func (p *PageImpl) Init() {
+	p._data = make([]byte, PAGE_SIZE)
 	p._page_id = 0
+	p._dirty = false
+}
+
+func (p *PageImpl) ResetMemory() error {
+	p.Init()
 	return nil
 }
 
 func (p *PageImpl) SetPageId(page_id uint32) {
 	p._page_id = page_id
+	fmt.Println("page_id", page_id)
 	p._data[0] = byte(page_id)
 	p._data[1] = byte(page_id >> 8)
 	p._data[2] = byte(page_id >> 16)
 	p._data[3] = byte(page_id >> 24)
 	p._dirty = true
+
 }
 
 func InvalidPage() Page {
 	// the first four bits are not equal to page_id
-	return &PageImpl{[PAGE_SIZE]byte{}, INVALID_PAGE_ID, false, 0}
+	return &PageImpl{make([]byte, PAGE_SIZE), INVALID_PAGE_ID, false, 0}
 }

storage/page/schema_page.go

@@ -5,6 +5,7 @@ package page
 // slots and tuples
 
 import (
+	"errors"
 	"fmt"
 	//"github.com/chaitya62/noobdb/type"
 )
@@ -24,6 +25,10 @@ func (sp *SchemaPage) Init() {
 	sp.SetFreeSpacePointer(4096)
 }
 
+func (sp *SchemaPage) shallowCopy(_page Page) {
+	sp._data = _page.GetData()
+}
+
 func (sp *SchemaPage) GetHeader() []byte {
 	// returning a slice returns the address space and not the copy
 	// will have to re-think later if this is causes any unexpect behaviour
@@ -83,17 +88,18 @@ func (sp *SchemaPage) InsertTuple(tp Tuple) error {
 
 	if uint64(space_left) < tp_size {
 		//TODO: ADD CUSTOM STANDARD ERROR TYPES TO DATABASE
-		return nil
+		fmt.Println("PAGE is FULL")
+		return errors.New("Page is full")
 	}
 
 	// assuming all tuples fit in one page
 	//TODO: Implement handling for Tuple OVERFLOW
 	start_at := fp - uint16(tp_size)
 
 	//TODO: Error handling
-	fmt.Println("HERE")
 	// intert tupple
 	copy(sp._data[start_at:fp], tp.GetData())
+	sp._dirty = true
 
 	// insert slot
 	//TODO: SLOT STRUCT ?

storage/page/tuple.go

@@ -5,21 +5,13 @@ import (
 	"github.com/chaitya62/noobdb/type"
 )
 
-const (
-	SCHEMA_ID = iota
-	SCHEMA_TABLE_ID
-	SCHEMA_TABLE_NAME
-	SCHEMA_COLUMN_POSITION
-	SCHEMA_COLUMN_NAME
-	SCHEMA_COLUMN_TYPE
-)
-
 type Tuple interface {
 	ReadTuple(data_ []byte)
 	SetValueFor(column_i uint64, val interface{})
 	GetValueFor(column_i uint64) interface{}
 	GetSize() uint64
 	GetData() []byte
+	PrintTuple()
 }
 
 type TupleImpl struct {

tests/storage/disk/disk_test.go

@@ -54,6 +54,7 @@ func TestDiskManagerImpl(t *testing.T) {
 			}
 
 			dummy_page := &page.PageImpl{}
+			dummy_page.Init()
 
 			ok := dmi.WritePage(dummy_page.GetPageId(), dummy_page)
 			if ok != nil {

tests/storage/page/page_test.go

@@ -20,6 +20,7 @@ func TestPageImpl(t *testing.T) {
 
 		t.Run("SetData - page_id and data", func(t *testing.T) {
 			pageImpl := &page.PageImpl{}
+			pageImpl.Init()
 			data_slice := make([]byte, page.PAGE_SIZE)
 
 			expected_page_id := uint32(12)
@@ -39,6 +40,7 @@ func TestPageImpl(t *testing.T) {
 
 		t.Run("SetData - invalid slice", func(t *testing.T) {
 			pageImpl := &page.PageImpl{}
+			pageImpl.Init()
 
 			invalid_page_size := 1235
 			data_slice := make([]byte, invalid_page_size)
@@ -77,6 +79,8 @@ func TestPageImpl(t *testing.T) {
 
 	t.Run("SetPageId", func(t *testing.T) {
 		pageImpl := &page.PageImpl{}
+		pageImpl.Init()
+
 		data_slice := make([]byte, page.PAGE_SIZE)
 
 		expected_page_id := uint32(12)