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

#include "catalog.h"
#include <cstdlib>
#include <sstream>
#include <cstring>
#include "index.h"
#include "exceptions/attribute_not_found_exception.h"
#include "exceptions/index_not_found_exception.h"
#include "exceptions/index_already_exists_exception.h"
#include "exceptions/end_of_file_exception.h"
#include "exceptions/bad_opcodes_exception.h"

namespace badgerdb {

static int attrCmp(const void* a1, const void* a2)
{
   return ((AttrDesc*)a1)->attrOffset - ((AttrDesc*)a2)->attrOffset; 
}

AttrCatalog::AttrCatalog(BufMgr *bufferMgr)
:FileScan(ATTRCATNAME, bufferMgr)
{
}

void AttrCatalog::getInfo(const std::string &relation, const std::string &attrName, AttrDesc &attrdesc)
{
  RecordId rid;

  startScan(0, relation.size() + 1, STRING, relation, EQ);

  while(1)
  {
    try
    {
      scanNext(rid);
      std::string recordStr = getRecord();

      assert(sizeof(AttrDesc) == recordStr.size());

      memcpy(&attrdesc, recordStr.c_str(), sizeof(AttrDesc));
      if(std::string(attrdesc.attrName) == attrName)
        break;
    }
    catch(EndOfFileException e)
    {
      throw AttributeNotFoundException();
    }
  }

  endScan();
}


void AttrCatalog::addInfo(AttrDesc &attrdesc)
{
  RecordId outRid;
  std::string new_data(reinterpret_cast<char*>(&attrdesc), sizeof(AttrDesc));
  insertRecord(new_data, outRid);
}


void AttrCatalog::removeInfo(const std::string &relation, const std::string &attrName)
{
  RecordId rid;
  AttrDesc attrdesc;

  startScan(0, relation.size() + 1, STRING, relation, EQ);

  while(1)
  {
    try
    {
      scanNext(rid);
      std::string recordStr = getRecord();

      assert(sizeof(AttrDesc) == recordStr.size());

      memcpy(&attrdesc, recordStr.c_str(), sizeof(AttrDesc));
      if (std::string(attrdesc.attrName) == attrName)
        break;
    }
    catch(EndOfFileException e)
    {
      throw AttributeNotFoundException();
    }
  }

  endScan();

  deleteRecord(rid);
}

void AttrCatalog::getRelInfo(const std::string &relation, int &attrCnt, AttrDesc *&attrs)
{
  RecordId rid;

  startScan(0, relation.size() + 1, STRING, relation, EQ);

  attrCnt = 0;
  int curSize = 8;
  attrs = new AttrDesc [curSize];

  memset (attrs, 0, curSize*sizeof(AttrDesc)); // keep purify happy.

  while(1)
  {
    try
    {
      scanNext(rid);
      std::string recordStr = getRecord();

      assert(sizeof(AttrDesc) == recordStr.size());

      ++attrCnt;

      // Check if the attrs array can hold this entry.
      if (attrCnt > curSize)
      {
        // reallocate the attrs array and start over.
        AttrDesc* newArray = new AttrDesc [curSize*2]; // double the size of the array.
        memset (newArray, 0, curSize*2*sizeof(AttrDesc)); // keep purify happy.
        memcpy (newArray, attrs, curSize*sizeof(AttrDesc)); // copy the old contents
        delete [] attrs;  // free up the previously allocated memory.
        attrs = newArray; // point to the new (larger) array.
        curSize *= 2;
      }

      memcpy(&attrs[attrCnt - 1], recordStr.c_str(), sizeof(AttrDesc));
    }
    catch(EndOfFileException e)
    {
      break;
    }
  }

  endScan();

  qsort(attrs, attrCnt, sizeof(AttrDesc), badgerdb::attrCmp);
}

//
// Drops a relation. It performs the following steps:
//
//      destroys any index files
//  removes the catalog entries for the relation
//
// Returns:
//  OK on success
//  error code otherwise
//

void AttrCatalog::dropRelation(const std::string &relation)
{
  AttrDesc *attrs;
  int attrCnt, i;

  // get attribute information

  getRelInfo(relation, attrCnt, attrs);

  // first drop any index files
  // (this must occur before removeInfo() is called because
  // dropIndex computes offsets (needed in index filenames)
  // based on attrcat entries!)

  for(i = 0; i < attrCnt; i++)
  {
    if(attrs[i].indexed)
    {
      dropIndex(relation, attrs[i].attrName);
    }
  }

  // remove entries from catalog
  for(i = 0; i < attrCnt; i++)
  {
    removeInfo(relation, attrs[i].attrName);
  }

  delete [] attrs;
}

AttrCatalog::~AttrCatalog()
{
}

//
// Creates an index on attribute `attrName' of relation `relation.'
// It performs the following steps:
//
//      creates the appropriate index file by instantiating an Index object, which
//      creates the index file.
//  marks the attribute `indexed' in attrcat
//
// Returns:
//  OK on success
//  error code otherwise
//

void AttrCatalog::addIndex(const std::string &relation, const std::string &attrName)
{
  AttrDesc ad;

  // get attribute information
  getInfo(relation, attrName, ad);

  if(ad.indexed)
    throw IndexAlreadyExistsException();

  // create index file
  Index index(relation, ad.attrOffset, ad.attrLen, (Datatype)ad.attrType, 1, bufMgr);
  //index.printBucs();

  // modify entry in attrcat
  ad.indexed = true;

  removeInfo(relation, attrName);
  addInfo(ad);
}



void AttrCatalog::dropIndex(const std::string &relation, const std::string &attrName)
{
  AttrDesc ad;

  // get attribute information
  getInfo(relation, attrName, ad);

  if(ad.indexed == false)
    throw IndexNotFoundException();

  // destroy file
  std::ostringstream outputString;
  outputString << relation << '.' << ad.attrOffset << std::endl;
  std::string tmpString = outputString.str();

  File::remove(tmpString);

  // modify entry in attrcat
  ad.indexed = false;

  removeInfo(relation, attrName);
  addInfo(ad);
}

}