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

#include "utility.h"
#include <cstring>
#include "catalog.h"
#include "exceptions/relation_not_found_exception.h"
#include "exceptions/relation_already_exists_exception.h"
#include "exceptions/duplicate_attribute_exception.h"
#include "exceptions/end_of_file_exception.h"
#include "exceptions/bad_param_exception.h"

extern badgerdb::AttrCatalog *attrCat;  // Pointer to the attribute catalog object

namespace badgerdb {

// extern variables that are instantianted in the main program.

RelCatalog::RelCatalog(BufMgr *bufferMgr)
:FileScan(RELCATNAME, bufferMgr)
{
}

void RelCatalog::getInfo(const std::string &relation, RelDesc &reldesc)
{
  RecordId rid;

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

  try
  {
    scanNext(rid);
  }
  catch(EndOfFileException e)
  {
    throw RelationNotFoundException();
  }

  std::string recordStr = getRecord();

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

  memcpy(&reldesc, recordStr.c_str(), sizeof(RelDesc));

  endScan();
}

void RelCatalog::addInfo(RelDesc &reldesc)
{
  RecordId outRid;
  std::string new_data(reinterpret_cast<char*>(&reldesc), sizeof(RelDesc));
  insertRecord(new_data, outRid);
}

void RelCatalog::removeInfo(const std::string & relation)
{
  RecordId rid;

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

  try
  {
    scanNext(rid);
  }
  catch(EndOfFileException e)
  {
    throw RelationNotFoundException();
  }

  endScan();

  deleteRecord(rid);
}

void RelCatalog::createRel(const std::string &relation, int attrCnt, const attrInfo attrList[])
{
  RelDesc rd;
  AttrDesc ad;

  if(relation.size() >= sizeof(rd.relName))
    throw BadParamException();
 
  // make sure the relation doesn't already exist
  try
  {
    getInfo(relation, rd);
    throw RelationAlreadyExistsException();
  }
  catch(RelationNotFoundException &e)
  {
  }

  //make sure there are no duplicate attribute names

  if(attrCnt > 1)
  {
    for(int i = 1; i < attrCnt; i++)
    {
      for(int j = 0; j < i; j++)
      {
        if(strcmp(attrList[i].attrName, attrList[j].attrName) == 0)
          throw DuplicateAttributeException();
      }
    }
  }
  
  strcpy(rd.relName, relation.c_str());
  rd.attrCnt = attrCnt;
  rd.indexCnt = 0;

  addInfo(rd);

  strcpy(ad.relName, relation.c_str());
  int offset = 0;

  for(int i = 0; i < attrCnt; i++)
  {
    if (strlen(attrList[i].attrName) >= sizeof(ad.attrName))
      throw BadParamException();

    //TODO::remove the following offset computation, get it from the user
    strcpy(ad.attrName, attrList[i].attrName);
    ad.attrOffset = offset;
    ad.attrType = attrList[i].attrType;
    ad.attrLen = attrList[i].attrLen;
    ad.indexed = false;

    attrCat->addInfo(ad);

    offset += ad.attrLen;
  }

  //create relation file
  PageFile relFile(relation, true);

  //so that select on these relations show updated information
  attrCat->flushFile();
  this->flushFile();
}

//
// Destroys a relation. It performs the following steps:
//
//  removes the catalog entry for the relation
//  destroys the heap file containing the tuples in the relation
//
// Returns:
//  OK on success
//  error code otherwise
//

void RelCatalog::destroyRel(const std::string & relation)
{
  if (relation.empty() || relation == RELCATNAME || relation == ATTRCATNAME)
    throw BadParamException();

  // delete attrcat entries
  attrCat->dropRelation(relation);

  // delete entry from relcat
  removeInfo(relation);

  File::remove(relation);

  //so that select on these relations show updated information
  attrCat->flushFile();
  this->flushFile();
}


RelCatalog::~RelCatalog()
{
}

//
// Retrieves and prints the catalog information for the relation.
// If no relation is given (relation is NULL), then it lists all
// the relations in the database, along with the width in bytes of the
// relation, the number of attributes in the relation, and the number of
// attributes that are indexed.  If a relation is given, then it lists
// all of the attributes of the relation, as well as its type, length,
// and offset, whether it's indexed or not, and its index number.
//
// Returns:
//  OK on success
//  error code otherwise
//

void RelCatalog::help(const std::string &relation)
{
  if(relation.empty())
  {
    Utilities::Print(std::string(RELCATNAME));
    return;
  }

  RelDesc rd;
  AttrDesc *attrs;
  int attrCnt;

  // get relation data

  try
  {
    getInfo(relation, rd);
  }
  catch(RelationNotFoundException &e)
  {
    return;
  }

  // get attribute data

  attrCat->getRelInfo(relation, attrCnt, attrs);

  // print relation information

  std::cout << "Relation name: " << rd.relName << " (" << rd.attrCnt << " attributes, " << rd.indexCnt << " indexed)" << std::endl << std::endl;

  printf("%16.16s   Off   T   Len   I\n\n",  "Attribute name");
  for(int i = 0; i < attrCnt; i++)
  {
    Datatype t = (Datatype)attrs[i].attrType;
    printf("%16.16s   %3d   %c   %3d   %c\n", attrs[i].attrName, attrs[i].attrOffset, (t == INTEGER ? 'i' : (t == DOUBLE ? 'f' : 's')),
     attrs[i].attrLen, (attrs[i].indexed ? 'Y' : 'N'));
  }

  delete [] attrs;
}

//
// Creates an index on attribute `attrName' of relation `relation.'  This
// function assumes (but does not verify) that relation is an empty relation.
// It performs the following steps:
//
//  verifies the existance of relation relname and attribute attrname
//  creates the appropriate index file
//  updates the index count in relcat
//
// Returns:
//  OK on success
//  error code otherwise
//

void RelCatalog::addIndex(const std::string &relation, const std::string &attrName)
{
  RelDesc rd;

  // get existing relation data
  getInfo(relation, rd);

  // create index file
  attrCat->addIndex(relation, attrName);

  // modify indexCnt in relcat
  rd.indexCnt++;

  removeInfo(relation);
  addInfo(rd);

  //so that select on these relations show updated information
  attrCat->flushFile();
  this->flushFile();
}

//
// Drops an index.
//
// Returns:
//  OK on success
//  error code otherwise
//

void RelCatalog::dropIndex(const std::string &relation, const std::string &attrName)
{
  RelDesc rd;

  // get existing relation data
  getInfo(relation, rd);

  // destroy index file
  attrCat->dropIndex(relation, attrName);

  // modify indexCnt in relcat
  rd.indexCnt--;

  removeInfo(relation);
  addInfo(rd);

  //so that select on these relations show updated information
  attrCat->flushFile();
  this->flushFile();
}

}