// see DbFile.java for javadocs
public Page readPage(PageId pid) {
int offset = BufferPool.PAGE_SIZE * pid.pageNumber();
byte[] b = new byte[BufferPool.PAGE_SIZE];
try {
InputStream is = new FileInputStream(m_file);
is.skip(offset);
is.read(b, 0, BufferPool.PAGE_SIZE);
is.close();
return new HeapPage((HeapPageId) pid, b);
} catch (IOException ioe) {
ioe.printStackTrace();
return null;
}
}
// see DbFile.java for javadocs
public Page readPage(PageId pid) {
// some code goes here
if (pid.pageNumber() >= numPages()) {
throw new IllegalArgumentException("page not in file");
}
Page returnme = null;
byte[] data = HeapPage.createEmptyPageData();
long offset = (long) BufferPool.PAGE_SIZE * pid.pageNumber();
try {
raf.seek(offset);
for (int i = 0; i < data.length; i++) {
data[i] = raf.readByte();
}
returnme = new HeapPage((HeapPageId) pid, data);
} catch (EOFException eofe) {
eofe.printStackTrace();
} catch (IOException ioe) {
ioe.printStackTrace();
}
return returnme;
}
/**
* Retrieve the specified page with the associated permissions. Will acquire a lock and may block
* if that lock is held by another transaction.
*
* <p>The retrieved page should be looked up in the buffer pool. If it is present, it should be
* returned. If it is not present, it should be added to the buffer pool and returned. If there is
* insufficient space in the buffer pool, an page should be evicted and the new page should be
* added in its place.
*
* @param tid the ID of the transaction requesting the page
* @param pid the ID of the requested page
* @param perm the requested permissions on the page
* @throws IOException
* @throws NoSuchElementException
*/
public Page getPage(TransactionId tid, PageId pid, Permissions perm)
throws TransactionAbortedException, DbException, NoSuchElementException, IOException {
if (this.deadPool.containsKey(pid)) {
return this.deadPool.get(pid);
} else {
if (this.deadPool.size() >= this.numPages) {
throw new DbException("Too many pages!");
} else {
this.deadPool.put(
pid, Database.getCatalog().getDatabaseFile(pid.getTableId()).readPage(pid));
return this.deadPool.get(pid);
}
}
}
// see DbFile.java for javadocs
public Page readPage(PageId pid) {
// some code goes here
try {
RandomAccessFile rAf = new RandomAccessFile(f, "r");
int offset = pid.pageNumber() * BufferPool.PAGE_SIZE;
byte[] b = new byte[BufferPool.PAGE_SIZE];
rAf.seek(offset);
rAf.read(b, 0, BufferPool.PAGE_SIZE);
HeapPageId hpid = (HeapPageId) pid;
rAf.close();
return new HeapPage(hpid, b);
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* overrides the test2 function in TestDriver. It tests whether illeagal operation can be caught.
*
* @return whether test2 has passed
*/
protected boolean test2() {
System.out.print("\n Test 2 exercises some illegal buffer " + "manager operations:\n");
// We choose this number to ensure that pinning this number of buffers
// should fail.
int numPages = SystemDefs.JavabaseBM.getNumUnpinnedBuffers() + 1;
Page pg = new Page();
PageId pid, lastPid;
PageId firstPid = new PageId();
boolean status = OK;
System.out.print(" - Try to pin more pages than there are frames\n");
try {
firstPid = SystemDefs.JavabaseBM.newPage(pg, numPages);
} catch (Exception e) {
System.err.print("*** Could not allocate " + numPages);
System.err.print(" new pages in the database.\n");
e.printStackTrace();
return false;
}
pid = new PageId();
lastPid = new PageId();
// First pin enough pages that there is no more room.
for (pid.pid = firstPid.pid + 1, lastPid.pid = firstPid.pid + numPages - 1;
status == OK && pid.pid < lastPid.pid;
pid.pid = pid.pid + 1) {
try {
SystemDefs.JavabaseBM.pinPage(pid, pg, /*emptyPage:*/ true);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not pin new page " + pid.pid + "\n");
e.printStackTrace();
}
}
// Make sure the buffer manager thinks there's no more room.
if (status == OK && SystemDefs.JavabaseBM.getNumUnpinnedBuffers() != 0) {
status = FAIL;
System.err.print(
"*** The buffer manager thinks it has "
+ SystemDefs.JavabaseBM.getNumUnpinnedBuffers()
+ " available frames,\n"
+ " but it should have none.\n");
}
// Now pin that last page, and make sure it fails.
if (status == OK) {
try {
SystemDefs.JavabaseBM.pinPage(lastPid, pg, /*emptyPage:*/ true);
} catch (ChainException e) {
status = checkException(e, "bufmgr.BufferPoolExceededException");
if (status == FAIL) {
System.err.print("*** Pinning too many pages\n");
System.out.println(" --> Failed as expected \n");
}
} catch (Exception e) {
e.printStackTrace();
}
if (status == OK) {
status = FAIL;
System.err.print("The expected exception was not thrown\n");
} else {
status = OK;
}
}
if (status == OK) {
try {
SystemDefs.JavabaseBM.pinPage(firstPid, pg, /*emptyPage:*/ true);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not acquire a second pin on a page\n");
e.printStackTrace();
}
if (status == OK) {
System.out.print(" - Try to free a doubly-pinned page\n");
try {
SystemDefs.JavabaseBM.freePage(firstPid);
} catch (ChainException e) {
status = checkException(e, "bufmgr.PagePinnedException");
if (status == FAIL) {
System.err.print("*** Freeing a pinned page\n");
System.out.println(" --> Failed as expected \n");
}
} catch (Exception e) {
e.printStackTrace();
}
if (status == OK) {
status = FAIL;
System.err.print("The expected exception was not thrown\n");
} else {
status = OK;
}
}
if (status == OK) {
try {
SystemDefs.JavabaseBM.unpinPage(firstPid, false);
} catch (Exception e) {
status = FAIL;
e.printStackTrace();
}
}
}
if (status == OK) {
System.out.print(" - Try to unpin a page not in the buffer pool\n");
try {
SystemDefs.JavabaseBM.unpinPage(lastPid, false);
} catch (ChainException e) {
status = checkException(e, "bufmgr.HashEntryNotFoundException");
if (status == FAIL) {
System.err.print("*** Unpinning a page not in the buffer pool\n");
System.out.println(" --> Failed as expected \n");
}
} catch (Exception e) {
e.printStackTrace();
}
if (status == OK) {
status = FAIL;
System.err.print("The expected exception was not thrown\n");
} else {
status = OK;
}
}
for (pid.pid = firstPid.pid; pid.pid <= lastPid.pid; pid.pid = pid.pid + 1) {
try {
SystemDefs.JavabaseBM.freePage(pid);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Error freeing page " + pid.pid + "\n");
e.printStackTrace();
}
}
if (status == OK) System.out.print(" Test 2 completed successfully.\n");
return status;
}
/**
* overrides the test1 function in TestDriver. It tests some simple normal buffer manager
* operations.
*
* @return whether test1 has passed
*/
protected boolean test1() {
System.out.print("\n Test 1 does a simple test of normal buffer ");
System.out.print("manager operations:\n");
// We choose this number to ensure that at least one page will have to be
// written during this test.
boolean status = OK;
int numPages = SystemDefs.JavabaseBM.getNumUnpinnedBuffers() + 1;
Page pg = new Page();
PageId pid;
PageId lastPid;
PageId firstPid = new PageId();
System.out.print(" - Allocate a bunch of new pages\n");
try {
firstPid = SystemDefs.JavabaseBM.newPage(pg, numPages);
} catch (Exception e) {
System.err.print("*** Could not allocate " + numPages);
System.err.print(" new pages in the database.\n");
e.printStackTrace();
return false;
}
// Unpin that first page... to simplify our loop.
try {
SystemDefs.JavabaseBM.unpinPage(firstPid, false /*not dirty*/);
} catch (Exception e) {
System.err.print("*** Could not unpin the first new page.\n");
e.printStackTrace();
status = FAIL;
}
System.out.print(" - Write something on each one\n");
pid = new PageId();
lastPid = new PageId();
for (pid.pid = firstPid.pid, lastPid.pid = pid.pid + numPages;
status == OK && pid.pid < lastPid.pid;
pid.pid = pid.pid + 1) {
try {
SystemDefs.JavabaseBM.pinPage(pid, pg, /*emptyPage:*/ true);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not pin new page " + pid.pid + "\n");
e.printStackTrace();
}
if (status == OK) {
// Copy the page number + 99999 onto each page. It seems
// unlikely that this bit pattern would show up there by
// coincidence.
int data = pid.pid + 99999;
try {
Convert.setIntValue(data, 0, pg.getpage());
} catch (IOException e) {
System.err.print("*** Convert value failed\n");
status = FAIL;
}
if (status == OK) {
try {
SystemDefs.JavabaseBM.unpinPage(pid, /*dirty:*/ true);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not unpin dirty page " + pid.pid + "\n");
e.printStackTrace();
}
}
}
}
if (status == OK)
System.out.print(
" - Read that something back from each one\n"
+ " (because we're buffering, this is where "
+ "most of the writes happen)\n");
for (pid.pid = firstPid.pid; status == OK && pid.pid < lastPid.pid; pid.pid = pid.pid + 1) {
try {
SystemDefs.JavabaseBM.pinPage(pid, pg, /*emptyPage:*/ false);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not pin page " + pid.pid + "\n");
e.printStackTrace();
}
if (status == OK) {
int data = 0;
try {
data = Convert.getIntValue(0, pg.getpage());
} catch (IOException e) {
System.err.print("*** Convert value failed \n");
status = FAIL;
}
if (status == OK) {
if (data != (pid.pid) + 99999) {
status = FAIL;
System.err.print("*** Read wrong data back from page " + pid.pid + "\n");
}
}
if (status == OK) {
try {
SystemDefs.JavabaseBM.unpinPage(pid, /*dirty:*/ true);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not unpin page " + pid.pid + "\n");
e.printStackTrace();
}
}
}
}
if (status == OK) System.out.print(" - Free the pages again\n");
for (pid.pid = firstPid.pid; pid.pid < lastPid.pid; pid.pid = pid.pid + 1) {
try {
SystemDefs.JavabaseBM.freePage(pid);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Error freeing page " + pid.pid + "\n");
e.printStackTrace();
}
}
if (status == OK) System.out.print(" Test 1 completed successfully.\n");
return status;
}