Class which represents a fixed-size database page containing records. More...

#include <page.h>

Public Member Functions
	Page ()

RecordId	insertRecord (const std::string &record_data)

std::string	getRecord (const RecordId &record_id) const

void	updateRecord (const RecordId &record_id, const std::string &record_data)

void	deleteRecord (const RecordId &record_id)

bool	hasSpaceForRecord (const std::string &record_data) const

std::uint16_t	getFreeSpace () const

PageId	page_number () const

PageId	next_page_number () const

PageIterator	begin ()

PageIterator	end ()

Static Public Attributes
static const std::size_t	SIZE = 8192

static const std::size_t	DATA_SIZE = SIZE - sizeof(PageHeader)

static const PageId	INVALID_NUMBER = 0

static const SlotId	INVALID_SLOT = 0

Friends
class	File

class	PageFile

class	BlobFile

class	PageIterator

Detailed Description

Class which represents a fixed-size database page containing records.

A page is a fixed-size unit of data storage. Each page holds zero or more records, which consist of arbitrary binary data. Records are placed into slots and identified by a RecordId. Although a record's actual contents may be moved on the page, accessing a record by its slot is consistent.

Warning: This class is not threadsafe.

Definition at line 108 of file page.h.

Constructor & Destructor Documentation

badgerdb::Page::Page ( )

Constructs a new, uninitialized page.

Definition at line 21 of file page.cpp.

            {
   initialize();
 }

Member Function Documentation

PageIterator badgerdb::Page::begin ( )

Returns an iterator at the first record in the page.

Returns: Iterator at first record of page.

Definition at line 211 of file page.cpp.

                          {
   return PageIterator(this);
 }

void badgerdb::Page::deleteRecord ( const RecordId & record_id )

Deletes the record with the given ID. Page is compacted upon delete to ensure that data of all records is contiguous. Slot array is compacted if the slot deleted is at the end of the slot array.

Parameters

record_id ID of the record to delete.

Definition at line 71 of file page.cpp.

                                                  {
   deleteRecord(record_id, true /* allow_slot_compaction */);
 }

PageIterator badgerdb::Page::end ( )

Returns an iterator representing the record after the last record in the page. This iterator should not be dereferenced.

Returns: Iterator representing record after the last record in the page.

Definition at line 215 of file page.cpp.

                        {
   const RecordId& end_record_id = {page_number(), Page::INVALID_SLOT};
   return PageIterator(this, end_record_id);
 }

std::uint16_t badgerdb::Page::getFreeSpace ( ) const

inline

Returns this page's free space in bytes.

Returns: Free space in bytes.

Definition at line 186 of file page.h.

186 { return header_.free_space_upper_bound -

187 header_.free_space_lower_bound; }

badgerdb::PageHeader::free_space_upper_bound

std::uint16_t free_space_upper_bound

Definition: page.h:37

badgerdb::PageHeader::free_space_lower_bound

std::uint16_t free_space_lower_bound

Definition: page.h:31

std::string badgerdb::Page::getRecord ( const RecordId & record_id ) const

Returns the record with the given ID. Returned data is a copy of what is stored on the page; use updateRecord to change it.

See Also: updateRecord

Parameters

record_id ID of the record to return.

Returns: The record.

Definition at line 46 of file page.cpp.

                                                          {
   validateRecordId(record_id);
   const PageSlot& slot = getSlot(record_id.slot_number);
   std::string retStr = std::string(data_, DATA_SIZE).substr(slot.item_offset, slot.item_length);
 
   return retStr;
 }

bool badgerdb::Page::hasSpaceForRecord ( const std::string & record_data ) const

Returns true if the page has enough free space to hold the given data.

Parameters

record_data Bytes that compose the record.

Returns: Whether the page can hold the data.

Definition at line 138 of file page.cpp.

                                                                {
   std::size_t record_size = record_data.length();
   if (header_.num_free_slots == 0) {
     record_size += sizeof(PageSlot);
   }
   return record_size <= getFreeSpace();
 }

RecordId badgerdb::Page::insertRecord ( const std::string & record_data )

Inserts a new record into the page.

Parameters

record_data Bytes that compose the record.

Returns: ID of the newly inserted record.

Definition at line 36 of file page.cpp.

                                                         {
   if (!hasSpaceForRecord(record_data)) {
     throw InsufficientSpaceException(
         page_number(), record_data.length(), getFreeSpace());
   }
   const SlotId slot_number = getAvailableSlot();
   insertRecordInSlot(slot_number, record_data);
   return {page_number(), slot_number};
 }

PageId badgerdb::Page::next_page_number ( ) const

inline

Returns the number of the next used page this page in its file.

Returns: Page number of next used page in file.

Definition at line 201 of file page.h.

201 { return header_.next_page_number; }

badgerdb::PageHeader::next_page_number

PageId next_page_number

Definition: page.h:59

PageId badgerdb::Page::page_number ( ) const

inline

Returns this page's number in its file.

Returns: Page number.

Definition at line 194 of file page.h.

194 { return header_.current_page_number; }

badgerdb::PageHeader::current_page_number

PageId current_page_number

Definition: page.h:54

void badgerdb::Page::updateRecord	(	const RecordId &	record_id,
		const std::string &	record_data
	)

Updates the record with the given ID, replacing its data with a new version. This is equivalent to deleting the old record and inserting a new one, with the exception that the record ID will not change.

Parameters

record_id	ID of record to update.
record_data	Updated bytes that compose the record.

Definition at line 54 of file page.cpp.

                                                       {
   validateRecordId(record_id);
   const PageSlot* slot = getSlot(record_id.slot_number);
   const std::size_t free_space_after_delete =
       getFreeSpace() + slot->item_length;
   if (record_data.length() > free_space_after_delete) {
     throw InsufficientSpaceException(
         page_number(), record_data.length(), free_space_after_delete);
   }
   // We have to disallow slot compaction here because we're going to place the
   // record data in the same slot, and compaction might delete the slot if we
   // permit it.
   deleteRecord(record_id, false /* allow_slot_compaction */);
   insertRecordInSlot(record_id.slot_number, record_data);
 }

Member Data Documentation

const std::size_t badgerdb::Page::DATA_SIZE = SIZE - sizeof(PageHeader)

static

Size of page free space area in bytes.

Definition at line 119 of file page.h.

const PageId badgerdb::Page::INVALID_NUMBER = 0

static

Number of page indicating that it's invalid.

Definition at line 124 of file page.h.

const SlotId badgerdb::Page::INVALID_SLOT = 0

static

Number of slot indicating that it's invalid.

Definition at line 129 of file page.h.

const std::size_t badgerdb::Page::SIZE = 8192

static

Page size in bytes. If this is changed, database files created with a different page size value will be unreadable by the resulting binaries.

Definition at line 114 of file page.h.

The documentation for this class was generated from the following files:

/afs/cs.wisc.edu/u/h/a/haiyun/private/cs564-spr17/projects/p3/Btree/src/page.h
/afs/cs.wisc.edu/u/h/a/haiyun/private/cs564-spr17/projects/p3/Btree/src/page.cpp

Public Member Functions

Static Public Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation