badgerdb::PageFile Class Reference

Inheritance diagram for badgerdb::PageFile:

Public Member Functions
	PageFile (const std::string &name, const bool create_new)
	PageFile (const PageFile &other)
PageFile &	operator= (const PageFile &rhs)
	~PageFile ()
Page	allocatePage (PageId &new_page_number)
Page	readPage (const PageId page_number) const
void	writePage (const PageId page_number, const Page &new_page)
void	deletePage (const PageId page_number)
FileIterator	begin ()
FileIterator	end ()
const std::string &	filename () const
PageId	getFirstPageNo ()

Static Public Member Functions
static PageFile	create (const std::string &filename)
static PageFile	open (const std::string &filename)
static void	remove (const std::string &filename)
static bool	isOpen (const std::string &filename)
static bool	exists (const std::string &filename)

Protected Types
typedef std::map< std::string, std::shared_ptr< std::fstream > >	StreamMap
typedef std::map< std::string, int >	CountMap

Protected Member Functions
void	openIfNeeded (const bool create_new)
void	close ()
FileHeader	readHeader () const
void	writeHeader (const FileHeader &header)

Static Protected Member Functions
static std::streampos	pagePosition (const PageId page_number)

Protected Attributes
std::string	filename_
std::shared_ptr< std::fstream >	stream_

Static Protected Attributes
static StreamMap	open_streams_
static CountMap	open_counts_

Friends
class	FileIterator

Detailed Description

Definition at line 239 of file file.h.

Constructor & Destructor Documentation

badgerdb::PageFile::PageFile	(	const std::string &	name,
		const bool	create_new
	)

Constructs a file object representing a file on the filesystem.

Parameters

name	Name of file.
create_new	Whether to create a new file.

Exceptions

FileExistsException	If the underlying file exists and create_new is true.
FileNotFoundException	If the underlying file doesn't exist and create_new is false.

Definition at line 143 of file file.cpp.

: File(name, create_new)
{
}

badgerdb::PageFile::PageFile

(

const PageFile &

other

)

Copy constructor.

Parameters

other

File object to copy.

Returns

A copy of the File object.

Definition at line 151 of file file.cpp.

: File(other.filename_, false /* create_new */)
{
}

badgerdb::PageFile::~PageFile

(

)

Destructor that automatically closes the underlying file if no other File objects are using it.

Definition at line 148 of file file.cpp.

                    {
}

Member Function Documentation

Page badgerdb::PageFile::allocatePage ( PageId &  new_page_number )

virtual

Allocates a new page in the file.

Returns

The new page.

Implements badgerdb::File.

Definition at line 165 of file file.cpp.

                                                   {
  FileHeader header = readHeader();
  Page new_page;
  Page existing_page;
  if (header.num_free_pages > 0) {
    new_page = readPage(header.first_free_page, true /* allow_free */);
    new_page.set_page_number(header.first_free_page);
    new_page_number = new_page.page_number();
    header.first_free_page = new_page.next_page_number();
    --header.num_free_pages;

    if (header.first_used_page == Page::INVALID_NUMBER ||
        header.first_used_page > new_page.page_number()) {
      // Either have no pages used or the head of the used list is a page later
      // than the one we just allocated, so add the new page to the head.
      if (header.first_used_page > new_page.page_number()) {
        new_page.set_next_page_number(header.first_used_page);
      }
      header.first_used_page = new_page.page_number();
    } else {
      // New page is reused from somewhere after the beginning, so we need to
      // find where in the used list to insert it.
      PageId next_page_number = Page::INVALID_NUMBER;
      for (FileIterator iter = begin(); iter != end(); ++iter) {
        next_page_number = (*iter).next_page_number();
        if (next_page_number > new_page.page_number() ||
            next_page_number == Page::INVALID_NUMBER) {
          existing_page = *iter;
          break;
        }
      }
      existing_page.set_next_page_number(new_page.page_number());
      new_page.set_next_page_number(next_page_number);
    }

    assert((header.num_free_pages == 0) ==
           (header.first_free_page == Page::INVALID_NUMBER));
  }
  else
  {
    new_page.set_page_number(header.num_pages);
    new_page_number = new_page.page_number();

    if (header.first_used_page == Page::INVALID_NUMBER)
    {
      header.first_used_page = new_page.page_number();
    }
    else
    {
      // If we have pages allocated, we need to add the new page to the tail
      // of the linked list.
      for (FileIterator iter = begin(); iter != end(); ++iter) {
        if ((*iter).next_page_number() == Page::INVALID_NUMBER) {
          existing_page = *iter;
          break;
        }
      }
      assert(existing_page.isUsed());
      existing_page.set_next_page_number(new_page.page_number());
    }
    ++header.num_pages;
  }
  writePage(new_page_number, new_page.header_, new_page);
  if (existing_page.page_number() != Page::INVALID_NUMBER) {
    // If we updated an existing page by inserting the new page into the
    // used list, we need to write it out.
    writePage(existing_page.page_number(), existing_page.header_, existing_page);
  }
  writeHeader(header);

  return new_page;
}

FileIterator badgerdb::PageFile::begin

(

)

Returns an iterator at the first page in the file.

Returns

Iterator at first page of file.

Definition at line 307 of file file.cpp.

                             {
  const FileHeader& header = readHeader();
  return FileIterator(this, header.first_used_page);
}

void badgerdb::File::close ( )

protectedinherited

Closes the underlying file stream in <stream_>. This method only closes the file if no other File objects exist that access the same file.

Definition at line 105 of file file.cpp.

                 {
  if(open_counts_[filename_] > 0)
    --open_counts_[filename_];

  stream_.reset();
  assert(open_counts_[filename_] >= 0);

  if (open_counts_[filename_] == 0) {
    open_streams_.erase(filename_);
    open_counts_.erase(filename_);
  }
}

PageFile badgerdb::PageFile::create ( const std::string &  filename )

static

Creates a new file.

Parameters

filename

Name of the file.

Exceptions

FileExistsException

If the requested file already exists.

Definition at line 135 of file file.cpp.

                                                   {
  return PageFile(filename, true /* create_new */);
}

void badgerdb::PageFile::deletePage ( const PageId  page_number )

virtual

Deletes a page from the file.

Parameters

page_number

Number of page to delete.

Implements badgerdb::File.

Definition at line 276 of file file.cpp.

                                                  {
  FileHeader header = readHeader();

  Page existing_page = readPage(page_number);
  Page previous_page;
  // If this page is the head of the used list, update the header to point to
  // the next page in line.
  if (page_number == header.first_used_page) {
    header.first_used_page = existing_page.next_page_number();
  } else {
    // Walk the used list so we can update the page that points to this one.
    for (FileIterator iter = begin(); iter != end(); ++iter) {
      previous_page = *iter;
      if (previous_page.next_page_number() == existing_page.page_number()) {
        previous_page.set_next_page_number(existing_page.next_page_number());
        break;
      }
    }
  }
  // Clear the page and add it to the head of the free list.
  existing_page.initialize();
  existing_page.set_next_page_number(header.first_free_page);
  header.first_free_page = page_number;
  ++header.num_free_pages;
  if (previous_page.isUsed()) {
    writePage(previous_page.page_number(), previous_page.header_, previous_page);
  }
  writePage(page_number, existing_page.header_, existing_page);
  writeHeader(header);
}

FileIterator badgerdb::PageFile::end

(

)

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

Returns

Iterator representing page after the last page in the file.

Definition at line 312 of file file.cpp.

                           {
  return FileIterator(this, Page::INVALID_NUMBER);
}

bool badgerdb::File::exists ( const std::string &  filename )

staticinherited

Returns true if the file exists and is open.

Parameters

filename

Name of the file.

Definition at line 46 of file file.cpp.

                                           {
  std::fstream file(filename);
  if(file)
  {
    file.close();
    return true;
  }

  return false;
}

const std::string& badgerdb::File::filename ( ) const

inlineinherited

Returns the name of the file this object represents.

Returns

Name of file.

Definition at line 158 of file file.h.

{ return filename_; }

PageId badgerdb::File::getFirstPageNo ( )

inherited

Returns pageid of first page in the file.

Returns

Iterator at first page of file.

Definition at line 62 of file file.cpp.

                            {
  const FileHeader& header = readHeader();
  return header.first_used_page;
}

bool badgerdb::File::isOpen ( const std::string &  filename )

staticinherited

Returns true if the file exists and is open.

Parameters

filename

Name of the file.

Definition at line 39 of file file.cpp.

                                           {
  if (!exists(filename)) {
    return false;
  }
  return open_counts_.find(filename) != open_counts_.end();
}

PageFile badgerdb::PageFile::open ( const std::string &  filename )

static

Opens the file named fileName and returns the corresponding File object. It first checks if the file is already open. If so, then the new File object created uses the same input-output stream to read to or write fom that already open file. Reference count (open_counts_ static variable inside the File object) is incremented whenever an already open file is opened again. Otherwise the UNIX file is actually opened. The fileName and the stream associated with this File object are inserted into the open_streams_ map.

Parameters

filename

Name of the file.

Exceptions

FileNotFoundException

If the requested file doesn't exist.

Definition at line 139 of file file.cpp.

                                                 {
  return PageFile(filename, false /* create_new */);
}

void badgerdb::File::openIfNeeded ( const bool  create_new )

protectedinherited

Opens the underlying file named in filename_. This method only opens the file if no other File objects exist that access the same filesystem file; otherwise, it reuses the existing stream.

Parameters

create_new

Whether to create a new file.

Exceptions

FileExistsException	If the underlying file exists and create_new is true.
FileNotFoundException	If the underlying file doesn't exist and create_new is false.

Definition at line 78 of file file.cpp.

                                             {
  if (open_counts_.find(filename_) != open_counts_.end()) { //exists an entry already
    ++open_counts_[filename_];
    stream_ = open_streams_[filename_];
  } else {
    std::ios_base::openmode mode =
        std::fstream::in | std::fstream::out | std::fstream::binary;
    const bool already_exists = exists(filename_);
    if (create_new) {
      // Error if we try to overwrite an existing file.
      if (already_exists) {
        throw FileExistsException(filename_);
      }
      // New files have to be truncated on open.
      mode = mode | std::fstream::trunc;
    } else {
      // Error if we try to open a file that doesn't exist.
      if (!already_exists) {
        throw FileNotFoundException(filename_);
      }
    }
    stream_.reset(new std::fstream(filename_, mode));
    open_streams_[filename_] = stream_;
    open_counts_[filename_] = 1;
  }
}

PageFile & badgerdb::PageFile::operator=

(

const PageFile &

rhs

)

Assignment operator.

Parameters

rhs	File object to assign.

Returns

Newly assigned file object.

Definition at line 156 of file file.cpp.

                                                 {
  // This accounts for self-assignment and assignment of a File object for the
  // same file.
  close();  //close my file and associate me with the new one
  filename_ = rhs.filename_;
  openIfNeeded(false /* create_new */);
  return *this;
}

static std::streampos badgerdb::File::pagePosition ( const PageId  page_number )

inlinestaticprotectedinherited

Returns the position of the page with the given number in the file (as an offset from the beginning of the file).

Parameters

page_number

Number of page.

Returns

Position of page in file.

Definition at line 175 of file file.h.

                                                             {
    return sizeof(FileHeader) + ((page_number - 1) * Page::SIZE);
  }

FileHeader badgerdb::File::readHeader ( ) const

protectedinherited

Reads the header for this file from disk.

Returns

The file header.

Definition at line 118 of file file.cpp.

                                  {
  FileHeader header;
  stream_->seekg(0 /* pos */, std::ios::beg);
  stream_->read(reinterpret_cast<char*>(&header), sizeof(FileHeader));
  return header;
}

Page badgerdb::PageFile::readPage ( const PageId  page_number ) const

virtual

Reads an existing page from the file.

Parameters

page_number

Number of page to read.

Returns

The page.

Exceptions

InvalidPageException

If the page doesn't exist in the file or is not currently used.

Implements badgerdb::File.

Definition at line 238 of file file.cpp.

                                                      {
  FileHeader header = readHeader();

  if (page_number >= header.num_pages)
  {
    throw InvalidPageException(page_number, filename_);
  }
  return readPage(page_number, false /* allow_free */);
}

void badgerdb::File::remove ( const std::string &  filename )

staticinherited

Deletes an existing file.

Parameters

filename

Name of the file.

Exceptions

FileNotFoundException	If the file doesn't exist.
FileOpenException	If the file is currently open.

Definition at line 29 of file file.cpp.

                                           {
  if (!exists(filename)) {
    throw FileNotFoundException(filename);
  }
  if (isOpen(filename)) {
    throw FileOpenException(filename);
  }
  std::remove(filename.c_str());
}

void badgerdb::File::writeHeader ( const FileHeader &  header )

protectedinherited

Writes the given header to the disk as the header for this file.

Parameters

header

File header to write.

Definition at line 125 of file file.cpp.

                                               {
  stream_->seekp(0 /* pos */, std::ios::beg);
  stream_->write(reinterpret_cast<const char*>(&header), sizeof(FileHeader));
  stream_->flush();
}

void badgerdb::PageFile::writePage ( const PageId  page_number, const Page &  new_page  )

virtual

Writes a page into the file at the given page number. No bounds checking is performed.

Parameters

page_number	Number of page whose contents to replace.
new_page	Page to write.

Implements badgerdb::File.

Definition at line 260 of file file.cpp.

                                                                           {
  PageHeader header = readPageHeader(new_page_number);
  if (header.current_page_number == Page::INVALID_NUMBER)
  {
    // Page has been deleted since it was read.
    throw InvalidPageException(new_page_number, filename_);
  }
  // Page on disk may have had its next page pointer updated since it was read;
  // we don't modify that, but we do keep all the other modifications to the
  // page header.
  const PageId next_page_number = header.next_page_number;
  header = new_page.header_;
  header.next_page_number = next_page_number;
  writePage(new_page_number, header, new_page);
}

Member Data Documentation

std::string badgerdb::File::filename_

protectedinherited

Name of the file this object represents.

Definition at line 229 of file file.h.

File::CountMap badgerdb::File::open_counts_

staticprotectedinherited

Counts for opened files.

Definition at line 224 of file file.h.

File::StreamMap badgerdb::File::open_streams_

staticprotectedinherited

Streams for opened files.

Definition at line 219 of file file.h.

std::shared_ptr<std::fstream> badgerdb::File::stream_

protectedinherited

Stream for underlying filesystem object.

Definition at line 234 of file file.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/file.h
• /afs/cs.wisc.edu/u/h/a/haiyun/private/cs564-spr17/projects/p3/Btree/src/file.cpp