/afs/cs.wisc.edu/u/n/w/nwilliam/private/workspace/Quut/src/filescan.cpp

#include <cstring>
#include "filescan.h"
#include "exceptions/end_of_file_exception.h"
#include "exceptions/file_not_found_exception.h"
#include "exceptions/insufficient_space_exception.h"

namespace badgerdb { 

FileScan::FileScan(const std::string &name, BufMgr *bufferMgr)
{
  try
  {
    file = new PageFile(name, false); //dont create new file
    //std::cout << "File:" << name << " opened.\n";
  }
  catch(FileNotFoundException e)
  {
    file = new PageFile(name, true);  //dont create new file
    //std::cout << "File:" << name << " created.\n";
  }

  bufMgr = bufferMgr;
  curDirtyFlag = false;
  curPage = NULL;
  filePageIter = file->begin();
}

void FileScan::gotoMark(RecordId rid)
{
  if(curPage != NULL)
  {
    bufMgr->unPinPage(file, (*filePageIter).page_number(), curDirtyFlag);
  }

  curDirtyFlag = false;
  filePageIter = file->beginAt(rid.page_number);
  bufMgr->readPage(file, rid.page_number, curPage); 
  pageRecordIter = curPage->beginAt(rid.slot_number);
}

void FileScan::insertRecord(const std::string &rec, RecordId &outRid)
{
  Page *iPage;
  PageId iPageNo;

  for (FileIterator iter = file->begin(); iter != file->end(); ++iter)
  {
    iPageNo = iter.getCurrentPageNo();

    if(iPageNo == Page::INVALID_NUMBER)
      break;

    bufMgr->readPage(file, iPageNo, iPage);

    try
    {
      outRid = iPage->insertRecord(rec);
      bufMgr->unPinPage(file, iPageNo, true);
      return;
    }
    catch(InsufficientSpaceException &e)
    {
      bufMgr->unPinPage(file, iPageNo, false);
    }
  }

  bufMgr->allocPage(file, iPageNo, iPage);
  outRid = iPage->insertRecord(rec);
  bufMgr->unPinPage(file, iPageNo, true);
}

void FileScan::deleteRecord(RecordId rid)
{
  Page *dPage;
  bufMgr->readPage(file, rid.page_number, dPage);
  dPage->deleteRecord(rid);
  bufMgr->unPinPage(file, rid.page_number, true);
}

void FileScan::flushFile()
{
  // generally must unpin last page of the scan
  if (curPage != NULL)
  {
    bufMgr->unPinPage(file, (*filePageIter).page_number(), curDirtyFlag);
    curPage = NULL;
    curDirtyFlag = false;
    filePageIter = file->begin();
  }

  bufMgr->flushFile(file);
}

FileScan::~FileScan()
{
  flushFile();

  delete file;
}

void FileScan::startScan(int offsetIn, int lengthIn, Datatype typeIn, std::string filterIn, Operator opIn)
{
  curPage = NULL;
  curDirtyFlag = false;
  filePageIter = file->begin();

  if (filterIn.empty()) {                        // no filtering requested
    filter.clear();
    return;
  }

  offset = offsetIn;
  length = lengthIn;
  type = typeIn;
  filter = filterIn;
  op = opIn;
}

void FileScan::endScan()
{
  if (curPage != NULL)
  {
    bufMgr->unPinPage(file, (*filePageIter).page_number(), curDirtyFlag);
  }

  curPage = NULL;
  curDirtyFlag = false;
  filePageIter = file->begin();
  filter.clear();
}

void FileScan::scanNext(RecordId& outRid)
{
  std::string rec;

  if(filePageIter == file->end())
  {
    throw EndOfFileException();
  }

  // special case of the first record of the first page of the file
  if (curPage == NULL)
  {
    // need to get the first page of the file
    filePageIter = file->begin();
    if(filePageIter == file->end())
    {
      throw EndOfFileException();
    }
   
    // read the first page of the file
    bufMgr->readPage(file, (*filePageIter).page_number(), curPage); 
    curDirtyFlag = false;

    // get the first record off the page
    pageRecordIter = curPage->begin(); 

    if(pageRecordIter != curPage->end()) 
    {
      // get pointer to record
      rec = *pageRecordIter;
      if(matchRec(rec))
      {
        outRid = pageRecordIter.getCurrentRecord();
        return;
      }
    }
  }

  // Loop, looking for a record that satisfied the predicate.
  // First try and get the next record off the current page
  pageRecordIter++;

  while(1)
  {
    while (pageRecordIter == curPage->end())
    {
      // unpin the current page
      bufMgr->unPinPage(file, (*filePageIter).page_number(), curDirtyFlag);
      curPage = NULL;
      curDirtyFlag = false;

      filePageIter++;
      if (filePageIter == file->end())
      {
        curPage = NULL;
        throw EndOfFileException();
      }

      // read the next page of the file
      bufMgr->readPage(file, (*filePageIter).page_number(), curPage);

      // get the first record off the page
      pageRecordIter = curPage->begin(); 
    }

    while (pageRecordIter != curPage->end())
    {
      rec = *pageRecordIter;

      if(matchRec(rec))
      {
        // return rid of the record
        outRid = pageRecordIter.getCurrentRecord();
        return;
      }
      pageRecordIter++;
    }
  }
}

// returns pointer to the current record.  page is left pinned
// and the scan logic is required to unpin the page 
std::string FileScan::getRecord()
{
  return *pageRecordIter;
}

std::string FileScan::getRandomRecord(RecordId rid)
{
  // Solution Starts
  Page* page;

  bufMgr->readPage(file, rid.page_number, page);
  std::string retStr = page->getRecord(rid);
  bufMgr->unPinPage(file, rid.page_number, false);

  return retStr;
}

bool FileScan::matchRec(const std::string &rec)
{
  // no filtering requested
  if (filter.empty()) return true;

  // see if offset + length is beyond end of record
  // maybe this should be an error???
  if ((offset + length -1 ) >= rec.size())
    return false;

  double diff = 0;                       // < 0 if attr < fltr
  switch(type) {

    case INTEGER:
      int iattr, ifltr;                 // word-alignment problem possible
      memcpy(&iattr, rec.c_str() + offset,  length);
      memcpy(&ifltr, filter.c_str(),  length);
      //ifltr = atoi(filter.c_str());
      diff = iattr - ifltr;
      break;

    case DOUBLE:
      double fattr, ffltr;               // word-alignment problem possible
      memcpy(&fattr, rec.c_str() + offset,  length);
      memcpy(&ffltr, filter.c_str(),  length);
      //ffltr = atof(filter.c_str());
      diff = fattr - ffltr;
      break;

    case STRING:
      diff = strncmp(rec.c_str() + offset,  filter.c_str(), length);
      break;
  }

  switch(op) {
    case LT:  if (diff < 0.0) return true; break;
    case LTE: if (diff <= 0.0) return true; break;
    case EQ:  if (diff == 0.0) return true; break;
    case GTE: if (diff >= 0.0) return true; break;
    case GT:  if (diff > 0.0) return true; break;
    case NE:  if (diff != 0.0) return true; break;
    default: break;
  }

  return false;

}

// mark current page of scan dirty
void FileScan::markDirty()
{
  curDirtyFlag = true;
}

}