simpledb

Class BPlusTreeFile

java.lang.Object

simpledb.BPlusTreeFile

All Implemented Interfaces:

DbFile

public class BPlusTreeFile
extends java.lang.Object
implements DbFile

BPlusTreeFile is an implementation of a DbFile that stores a B+ tree. Specifically, it stores a pointer to a root page, a set of internal pages, and a set of leaf pages, which contain a collection of tuples in sorted order. BPlusTreeFile works closely with BPlusTreeLeafPage, BPlusTreeInternalPage, and BPlusTreeRootPtrPage. The format of these pages is described in their constructors.

Author:

Becca Taft

See Also:

BPlusTreeLeafPage.BPlusTreeLeafPage(simpledb.BPlusTreePageId, byte[], int), BPlusTreeInternalPage.BPlusTreeInternalPage(simpledb.BPlusTreePageId, byte[], int), BPlusTreeRootPtrPage.BPlusTreeRootPtrPage(simpledb.BPlusTreePageId, byte[])

Field Summary

Fields

Modifier and Type	Field and Description
private java.io.File	f
private int	keyField
private int	tableid
private TupleDesc	td

Constructor Summary

Constructors

Constructor and Description
BPlusTreeFile(java.io.File f, int key, TupleDesc td) Constructs a B+ tree file backed by the specified file.

Method Summary

Methods

Modifier and Type	Method and Description
java.util.ArrayList<Page>	deleteTuple(TransactionId tid, Tuple t) Delete a tuple from this BPlusTreeFile.
(package private) BPlusTreeLeafPage	findLeafPage(TransactionId tid, Field f, BPlusTreePageId pid, Permissions perm) Recursive function which finds and locks the leaf page in the B+ tree corresponding to the left-most page possibly containing the key field f.
private int	getEmptyPage(TransactionId tid, java.util.HashSet<Page> dirtypages) Get the page number of the first empty page in this BPlusTreeFile.
java.io.File	getFile() Returns the File backing this BPlusTreeFile on disk.
int	getId() Returns an ID uniquely identifying this BPlusTreeFile.
private BPlusTreeRootPtrPage	getRootPtrPage(TransactionId tid) Get a read lock on the root pointer page.
TupleDesc	getTupleDesc() Returns the TupleDesc of the table stored in this DbFile.
private void	handleMinOccupancyInternalPage(TransactionId tid, BPlusTreeInternalPage page, java.util.HashSet<Page> dirtypages) Handle the case when an internal page becomes less than half full due to deletions.
private void	handleMinOccupancyLeafPage(TransactionId tid, BPlusTreeLeafPage page, java.util.HashSet<Page> dirtypages) Handle the case when a leaf page becomes less than half full due to deletions.
DbFileIterator	indexIterator(TransactionId tid, IndexPredicate ipred) get the specified tuples from the file based on its IndexPredicate value on behalf of the specified transaction.
java.util.ArrayList<Page>	insertTuple(TransactionId tid, Tuple t) Insert a tuple into this BPlusTreeFile, keeping the tuples in sorted order.
DbFileIterator	iterator(TransactionId tid) Get an iterator for all tuples in this B+ tree file in sorted order.
int	keyField() Returns the index of the field that this B+ tree is keyed on
private void	mergeInternalPages(TransactionId tid, BPlusTreeInternalPage leftPage, BPlusTreeInternalPage rightPage, BPlusTreeInternalPage parent, BPlusTreeEntry parentEntry, java.util.HashSet<Page> dirtypages) Merge two internal pages by moving all entries from the right page to the left page.
private void	mergeLeafPages(TransactionId tid, BPlusTreeLeafPage leftPage, BPlusTreeLeafPage rightPage, BPlusTreeInternalPage parent, BPlusTreeEntry parentEntry, java.util.HashSet<Page> dirtypages) Merge two leaf pages by moving all tuples from the right page to the left page.
int	numPages() Returns the number of pages in this BPlusTreeFile.
Page	readPage(PageId pid) Read a page from the file on disk.
private void	setEmptyPage(TransactionId tid, java.util.HashSet<Page> dirtypages, int emptyPageNo) Mark a page in this BPlusTreeFile as empty.
private BPlusTreeInternalPage	splitInternalPage(BPlusTreeInternalPage page, TransactionId tid, java.util.HashSet<Page> dirtypages, Field field) Recursively split internal pages as needed to make room for new entries.
private BPlusTreeLeafPage	splitLeafPage(BPlusTreeLeafPage page, TransactionId tid, java.util.HashSet<Page> dirtypages, Field field) Split a leaf page to make room for new tuples and recursively split the parent node as needed.
private void	updateParentPointer(TransactionId tid, BPlusTreePageId pid, BPlusTreePageId child, java.util.HashSet<Page> dirtypages) Helper function to update the parent pointer of a node.
private void	updateParentPointers(TransactionId tid, BPlusTreeInternalPage page, java.util.HashSet<Page> dirtypages) Update the parent pointer of every child of the given page
void	writePage(Page page) Write a page to disk.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

f

private final java.io.File f

td

private final TupleDesc td

tableid

private final int tableid

keyField

private int keyField

Constructor Detail

BPlusTreeFile

public BPlusTreeFile(java.io.File f,
             int key,
             TupleDesc td)

Constructs a B+ tree file backed by the specified file.

Parameters:

f - - the file that stores the on-disk backing store for this B+ tree file.

key - - the field which index is keyed on

td - - the tuple descriptor of tuples in the file

Method Detail

getFile

public java.io.File getFile()

Returns the File backing this BPlusTreeFile on disk.

Returns:

the File backing this BPlusTreeFile on disk.

getId

public int getId()

Returns an ID uniquely identifying this BPlusTreeFile. Implementation note: you will need to generate this tableid somewhere ensure that each BPlusTreeFile has a "unique id," and that you always return the same value for a particular BPlusTreeFile. We suggest hashing the absolute file name of the file underlying the BPlusTreeFile, i.e. f.getAbsoluteFile().hashCode().

Specified by:

getId in interface DbFile

Returns:

an ID uniquely identifying this BPlusTreeFile.

getTupleDesc

public TupleDesc getTupleDesc()

Returns the TupleDesc of the table stored in this DbFile.

Specified by:

getTupleDesc in interface DbFile

Returns:

TupleDesc of this DbFile.

readPage

public Page readPage(PageId pid)

Read a page from the file on disk. This should not be called directly but should be called from the BufferPool via getPage()

Specified by:

readPage in interface DbFile

Parameters:

pid - - the id of the page to read from disk

writePage

public void writePage(Page page)
               throws java.io.IOException

Write a page to disk. This should not be called directly but should be called from the BufferPool when pages are flushed to disk

Specified by:

writePage in interface DbFile

Parameters:

page - - the page to write to disk

Throws:

java.io.IOException - if the write fails

numPages

public int numPages()

Returns the number of pages in this BPlusTreeFile.

keyField

public int keyField()

Returns the index of the field that this B+ tree is keyed on

findLeafPage

BPlusTreeLeafPage findLeafPage(TransactionId tid,
                             Field f,
                             BPlusTreePageId pid,
                             Permissions perm)
                         throws DbException,
                                TransactionAbortedException

Recursive function which finds and locks the leaf page in the B+ tree corresponding to the left-most page possibly containing the key field f. It locks all internal nodes along the path to the leaf node with READ_ONLY permission, and locks the leaf node with permission perm. If f is null, it finds the left-most leaf page -- used for the iterator

Parameters:

tid - - the transaction id

f - - the field to search for

pid - - the current page being searched

perm - - the permissions with which to lock the leaf page

Returns:

the left-most leaf page possibly containing the key field f

Throws:

DbException

TransactionAbortedException

splitLeafPage

private BPlusTreeLeafPage splitLeafPage(BPlusTreeLeafPage page,
                              TransactionId tid,
                              java.util.HashSet<Page> dirtypages,
                              Field field)
                                 throws DbException,
                                        java.io.IOException,
                                        TransactionAbortedException

Split a leaf page to make room for new tuples and recursively split the parent node as needed. Update all pointers as needed.

Parameters:

page - - the leaf page to split

tid - - the transaction id

dirtypages - - the list of dirty pages which should be updated with all new dirty pages

field - - the key field of the tuple to be inserted after the split is complete. Necessary to know which of the two pages to return.

Returns:

the leaf page into which the new tuple should be inserted

Throws:

DbException

java.io.IOException

TransactionAbortedException

splitInternalPage

private BPlusTreeInternalPage splitInternalPage(BPlusTreeInternalPage page,
                                      TransactionId tid,
                                      java.util.HashSet<Page> dirtypages,
                                      Field field)
                                         throws DbException,
                                                java.io.IOException,
                                                TransactionAbortedException

Recursively split internal pages as needed to make room for new entries. Update all pointers as needed.

Parameters:

page - - the internal page to split

tid - - transaction id

dirtypages - - the list of dirty pages which should be updated with all new dirty pages

field - - the key field of the entry to be inserted after the split is complete. Necessary to know which of the two pages to return.

Returns:

the internal page into which the new entry should be inserted

Throws:

DbException

java.io.IOException

TransactionAbortedException

updateParentPointer

private void updateParentPointer(TransactionId tid,
                       BPlusTreePageId pid,
                       BPlusTreePageId child,
                       java.util.HashSet<Page> dirtypages)
                          throws DbException,
                                 java.io.IOException,
                                 TransactionAbortedException

Helper function to update the parent pointer of a node.

Parameters:

tid - - transaction id

pid - - id of the parent node

child - - id of the child node to be updated with the parent pointer

dirtypages - - the list of dirty pages which should be updated with all new dirty pages

Throws:

DbException

java.io.IOException

TransactionAbortedException

updateParentPointers

private void updateParentPointers(TransactionId tid,
                        BPlusTreeInternalPage page,
                        java.util.HashSet<Page> dirtypages)
                           throws DbException,
                                  java.io.IOException,
                                  TransactionAbortedException

Update the parent pointer of every child of the given page

Parameters:

tid - - transaction id

page - - the parent page

dirtypages - - the list of dirty pages which should be updated with all new dirty pages

Throws:

DbException

java.io.IOException

TransactionAbortedException

insertTuple

public java.util.ArrayList<Page> insertTuple(TransactionId tid,
                                    Tuple t)
                                      throws DbException,
                                             java.io.IOException,
                                             TransactionAbortedException

Insert a tuple into this BPlusTreeFile, keeping the tuples in sorted order. May cause pages to split if the page where tuple t belongs is full.

Specified by:

insertTuple in interface DbFile

Parameters:

tid - - the transaction id

t - - the tuple to insert

Returns:

a list of all pages that were dirtied by this operation. Could include many pages since parent pointers will need to be updated when an internal node splits.

Throws:

DbException - if the tuple cannot be added

java.io.IOException - if the needed file can't be read/written

TransactionAbortedException

handleMinOccupancyLeafPage

private void handleMinOccupancyLeafPage(TransactionId tid,
                              BPlusTreeLeafPage page,
                              java.util.HashSet<Page> dirtypages)
                                 throws DbException,
                                        java.io.IOException,
                                        TransactionAbortedException

Handle the case when a leaf page becomes less than half full due to deletions. If one of its siblings has extra tuples, redistribute those tuples. Otherwise merge with one of the siblings. Update pointers as needed.

Parameters:

tid - - the transaction id

page - - the leaf page which is less than half full

dirtypages - - the list of dirty pages which should be updated with all new dirty pages

Throws:

DbException

java.io.IOException

TransactionAbortedException

handleMinOccupancyInternalPage

private void handleMinOccupancyInternalPage(TransactionId tid,
                                  BPlusTreeInternalPage page,
                                  java.util.HashSet<Page> dirtypages)
                                     throws DbException,
                                            java.io.IOException,
                                            TransactionAbortedException

Handle the case when an internal page becomes less than half full due to deletions. If one of its siblings has extra entries, redistribute those entries. Otherwise merge with one of the siblings. Update pointers as needed.

Parameters:

tid - - the transaction id

page - - the internal page which is less than half full

dirtypages - - the list of dirty pages which should be updated with all new dirty pages

Throws:

DbException

java.io.IOException

TransactionAbortedException

mergeLeafPages

private void mergeLeafPages(TransactionId tid,
                  BPlusTreeLeafPage leftPage,
                  BPlusTreeLeafPage rightPage,
                  BPlusTreeInternalPage parent,
                  BPlusTreeEntry parentEntry,
                  java.util.HashSet<Page> dirtypages)
                     throws DbException,
                            java.io.IOException,
                            TransactionAbortedException

Merge two leaf pages by moving all tuples from the right page to the left page. Recursively handle the case when the parent gets below minimum occupancy.

Parameters:

tid - - the transaction id

leftPage - - the left leaf page

rightPage - - the right leaf page

parent - - the parent of the two pages

parentEntry - - the entry in the parent corresponding to the leftPage and rightPage

dirtypages - - the list of dirty pages which should be updated with all new dirty pages

Throws:

DbException

java.io.IOException

TransactionAbortedException

mergeInternalPages

private void mergeInternalPages(TransactionId tid,
                      BPlusTreeInternalPage leftPage,
                      BPlusTreeInternalPage rightPage,
                      BPlusTreeInternalPage parent,
                      BPlusTreeEntry parentEntry,
                      java.util.HashSet<Page> dirtypages)
                         throws DbException,
                                java.io.IOException,
                                TransactionAbortedException

Merge two internal pages by moving all entries from the right page to the left page. Recursively handle the case when the parent gets below minimum occupancy.

Parameters:

tid - - the transaction id

leftPage - - the left internal page

rightPage - - the right internal page

parent - - the parent of the two pages

parentEntry - - the entry in the parent corresponding to the leftPage and rightPage

dirtypages - - the list of dirty pages which should be updated with all new dirty pages

Throws:

DbException

java.io.IOException

TransactionAbortedException

deleteTuple

public java.util.ArrayList<Page> deleteTuple(TransactionId tid,
                                    Tuple t)
                                      throws DbException,
                                             java.io.IOException,
                                             TransactionAbortedException

Delete a tuple from this BPlusTreeFile. May cause pages to merge or redistribute entries/tuples if the pages become less than half full.

Specified by:

deleteTuple in interface DbFile

Parameters:

tid - - the transaction id

t - - the tuple to delete

Returns:

a list of all pages that were dirtied by this operation. Could include many pages since parent pointers will need to be updated when an internal node merges.

Throws:

DbException - if the tuple cannot be deleted or is not a member of the file

java.io.IOException

TransactionAbortedException

getRootPtrPage

private BPlusTreeRootPtrPage getRootPtrPage(TransactionId tid)
                                     throws DbException,
                                            java.io.IOException,
                                            TransactionAbortedException

Get a read lock on the root pointer page. Create the root pointer page and root page if necessary.

Parameters:

tid - - transaction id

Returns:

the root pointer page

Throws:

DbException

java.io.IOException

TransactionAbortedException

getEmptyPage

private int getEmptyPage(TransactionId tid,
               java.util.HashSet<Page> dirtypages)
                  throws DbException,
                         java.io.IOException,
                         TransactionAbortedException

Get the page number of the first empty page in this BPlusTreeFile. Creates a new page if none of the existing pages are empty.

Parameters:

tid - - transaction id

dirtypages - - the list of dirty pages which should be updated with all new dirty pages

Returns:

the page number of the first empty page

Throws:

DbException

java.io.IOException

TransactionAbortedException

setEmptyPage

private void setEmptyPage(TransactionId tid,
                java.util.HashSet<Page> dirtypages,
                int emptyPageNo)
                   throws DbException,
                          java.io.IOException,
                          TransactionAbortedException

Mark a page in this BPlusTreeFile as empty. If this is the last page in the file, just truncate the file. Otherwise, find the corresponding header page (create it if needed), and mark the corresponding slot in the header page as empty.

Parameters:

tid - - transaction id

dirtypages - - the list of dirty pages which should be updated with all new dirty pages

emptyPageNo - - the page number of the empty page

Throws:

DbException

java.io.IOException

TransactionAbortedException

indexIterator

public DbFileIterator indexIterator(TransactionId tid,
                           IndexPredicate ipred)

get the specified tuples from the file based on its IndexPredicate value on behalf of the specified transaction. This method will acquire a read lock on the affected pages of the file, and may block until the lock can be acquired.

Parameters:

tid - - the transaction id

ipred - - the index predicate value to filter on

Returns:

an iterator for the filtered tuples

iterator

public DbFileIterator iterator(TransactionId tid)

Get an iterator for all tuples in this B+ tree file in sorted order. This method will acquire a read lock on the affected pages of the file, and may block until the lock can be acquired.

Specified by:

iterator in interface DbFile

Parameters:

tid - - the transaction id

Returns:

an iterator for all the tuples in this file