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

#include <cstdio>
#include <string>
#include <cstring>
#include <fcntl.h>
#include "catalog.h"
#include "utility.h"
#include "index.h"
#include "buffer.h"
#include "exceptions/end_of_file_exception.h"
#include "exceptions/bad_param_exception.h"
#include "exceptions/file_open_exception.h"

#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define MIN(a,b) ((a) < (b) ? (a) : (b))

extern badgerdb::RelCatalog *relCat;    // pointer to the relation catalogs 
extern badgerdb::AttrCatalog *attrCat;  // pointer to the attribute catalogs
extern badgerdb::BufMgr *bufMgr;  // pointer to the attribute catalogs

namespace badgerdb
{
  // Compute widths of columns in attribute array.
  //

  void Utilities::UT_computeWidth(int attrCnt, AttrDesc attrs[], int *&attrWidth)
  {
    attrWidth = new int [attrCnt];

    for(int i = 0; i < attrCnt; i++)
      {
  int namelen = strlen(attrs[i].attrName);
  switch(attrs[i].attrType)
    {
    case INTEGER:
    case DOUBLE:
      // For ints and doubles print at most 7 characters.
      attrWidth[i] = MIN(MAX(namelen, 5), 7);

      // To print numbers using a longer format, comment out the previous line
      // and uncomment the next line.
      // attrWidth[i] = MAX(namelen, 5);
      break;
    case STRING:
      // For strings print at most 15 characters. 
      // BUG: The MAX implies that if the length of the attribute name is greater 
      //      than the type of the attribute, the subsequent print may print out garbage
      //      values
      attrWidth[i] = MIN(MAX(namelen, attrs[i].attrLen), 15);

      // To print the entire string, comment out the previous line
      // and uncomment the next line.
      // attrWidth[i] = MAX(namelen, attrs[i].attrLen);
      break;
    }
      }
  }


  //
  // Prints values of attributes stored in buffer pointed to
  // by recPtr. The desired width of columns is in attrWidth.
  //

  void UT_printRec(int attrCnt, AttrDesc attrs[], int *attrWidth, const std::string &rec)
  {
    for(int i = 0; i < attrCnt; i++)
      {
  char *attr = (char *)rec.c_str() + attrs[i].attrOffset;
  switch(attrs[i].attrType)
    {
    case INTEGER:
      int tempi;
      memcpy(&tempi, attr, sizeof(int));
      printf("%-*d  ", attrWidth[i], tempi);
      break;
    case DOUBLE:
      double tempf;
      memcpy(&tempf, attr, sizeof(double));
      printf("%-*.2f  ", attrWidth[i], tempf);
      break;
    default:
      printf("%-*.*s  ", attrWidth[i], attrWidth[i], attr);
      break;
    }
      }

    printf("\n");
  }


  void Utilities::Print(const std::string &relation)
  {
    RelDesc rd;
    AttrDesc *attrs;
    int attrCnt;

    if(relation.empty())
      std::string relation = RELCATNAME;

    relCat->getInfo(relation, rd);

    // get attribute data
    attrCat->getRelInfo(rd.relName, attrCnt, attrs);

    // compute width of output columns
    int *attrWidth;
    UT_computeWidth(attrCnt, attrs, attrWidth);

    // open data file
    FileScan filescan(rd.relName, bufMgr);

    for(int i = 0; i < attrCnt; i++)
      {
  printf("%-*.*s%c ", attrWidth[i], attrWidth[i], attrs[i].attrName, (attrs[i].indexed ? '*' : ' '));
      }
    printf("\n");

    for(int i = 0; i < attrCnt; i++) {
      for(int j = 0; j < attrWidth[i]; j++)
  putchar('-');
      printf("  ");
    }
    printf("\n");

    RecordId rid;

    int records = 0;
    while(1)
      {
  try
    {
      filescan.scanNext(rid);
      std::string recordStr = filescan.getRecord();
      UT_printRec(attrCnt, attrs, attrWidth, recordStr);
      records++;
    }
  catch(EndOfFileException &e)
    {
      break;
    }
      }

    std::cout << std::endl << "Number of records: " << records << std::endl;

    delete [] attrWidth;
    delete [] attrs;
  }

  void Utilities::Load(const std::string &relation, const std::string &fileName)
  {
    RelDesc rd;
    AttrDesc *attrs;
    int attrCnt;

    if(relation.empty() || fileName.empty() || relation == std::string(RELCATNAME) || relation == std::string(ATTRCATNAME))
      throw BadParamException();

    // open Unix data file
    int fd;
    if((fd = open(fileName.c_str(), O_RDONLY, 0)) < 0)
      throw FileOpenException(fileName);

    // get relation data
    relCat->getInfo(relation, rd);

    // get attribute data

    attrCat->getRelInfo(rd.relName, attrCnt, attrs);

    // open data file
    FileScan fscan(std::string(rd.relName), bufMgr);

    int records = 0;

    Index **index = new Index * [attrCnt];

    //compute width of tuple and open index files, if any

    int width = 0;
    int i;

    for(i = 0; i < attrCnt; i++)
      {
  width += attrs[i].attrLen;
  index[i] = NULL;
  if (attrs[i].indexed)
    {
      index[i] = new Index(std::string(rd.relName), attrs[i].attrOffset, attrs[i].attrLen,  (Datatype)attrs[i].attrType, NONUNIQUE, bufMgr);
    }
      }

    // Now start reading "width" bytes from the unix file (fd). The bytes that you
    // read are in the same format as the record used by Minirel. You now need to
    // insert this record into the heapfile (hfile) corresponding to this relation 
    // and also insert entries for this record in "each" index. You can insert 
    // entries into the index using the index[i]->insesrtEntry(...) command. Note,
    // you will need to provide to this method, the key of the entry being inserted.
    // Use the record and the index information from the catalog to locate the 
    // key that you need to pass to insertEntry.

    // Solution Starts
    // create a record for constructing the tuple

    char *record = new char [width];

    int nbytes;
    std::string rec;

    while((nbytes = read(fd, record, width)) == width)
      {
  RecordId rid;
  rec.assign(record, width);

  fscan.insertRecord(rec, rid);

  for(i = 0; i < attrCnt; i++)
    {
      if (index[i])
        {
    index[i]->insertEntry(record + attrs[i].attrOffset, rid);
        }
    }
  records++;
      }

    std::cout << "Number of records inserted: " << records << std::endl;

    if(close(fd) < 0)
      throw FileOpenException(fileName);

    for(i = 0; i < attrCnt; i++)
      {
  if(index[i])
    delete index[i];
      }

    delete []index;

    delete [] record;
    delete [] attrs;
  }


  void Utilities::Quit()
  {
    // close relcat and attrcat

    delete ::relCat;
    delete ::attrCat;

    // delete bufMgr to flush out all dirty pages

    delete ::bufMgr;

    exit(1);
  }
   
  void Helpers::printAttrInfo(const attrInfo *attr){
    if(attr!=NULL){
      std::cout<<"\nPrinting attrInfo\n";
      std::cout<<"\n\tRelname:"<<attr->relName<<"\n";
      std::cout<<"\n\tattrName:"<<attr->attrName<<"\n";
      std::cout<<"\n\tattrType:"<<attr->attrType<<"\n";
      if(attr->attrValue)
  std::cout<<"\n\tValue:"<< (attr->attrValue)<<"\n";
      else
  std::cout<<"\n\tValue is NULL\n";
    }
    else{
      std::cout<<"\nATTR is NULL\n";
    }
  }
  void Helpers::printAttrDesc(const AttrDesc *attrDesc){
    if(attrDesc!=NULL){
      std::cout<<"\nPrinting attrDesc\n";
      if(attrDesc->attrName)
  std::cout<<"\n\tAttrName:"<<attrDesc->attrName<<"\n";
      else
  std::cout<<"\n\tAttrName is NULL\n";
      std::cout<<"\n\tattrType:"<<Datatype(attrDesc->attrType)<<"\n";
      std::cout<<"\n\tattrLen:"<<attrDesc->attrLen<<"\n";
     
    }
    else{
      std::cout<<"\nATTRDESC is NULL\n";
    }
  }

  void Helpers::printAttrCat(std::string attributeName){
    print("ATTR CAT INFO");
    AttrDesc *outAttrDesc = new AttrDesc[6];
    int six = 6;
    attrCat->getRelInfo(attributeName,six,outAttrDesc);
    int i;
    for(i=0; i< 6; i++){
      print(outAttrDesc[i].relName);
      print(outAttrDesc[i].attrName);
      print(outAttrDesc[i].attrOffset);
      print(outAttrDesc[i].attrType);
      print(outAttrDesc[i].attrLen);
      print(outAttrDesc[i].indexed);
    }
    delete[] outAttrDesc;
  }
  std::string Helpers::charArrToStr(char charArr[]){
    std::string returnString;
    int i = 0;
    while(charArr[i] != 0){
      returnString += charArr[i];
      i++;
    }
    return returnString;
  }

}