/afs/cs.wisc.edu/u/n/w/nwilliam/private/workspace/Quut/src/index.h

#pragma once

#include "file.h"
#include "buffer.h"
#include <string>

#define MAXNAMESIZE       32                 // length of relName, attrName

namespace badgerdb
{

//TODO::this calculations seems wrong
const int DIRSIZE = (Page::SIZE - MAXNAMESIZE - 4*sizeof(int) - sizeof(Datatype)) / sizeof(PageId);
const int UNIQUE  = 1;
const int NONUNIQUE = 0;


struct iHeaderPage
{
  char          fileName[MAXNAMESIZE];  // name of file
  int           offset;                 // byte offset of the indexed attribute 
  int           length;                 // length of the attribute
  int           depth;                  // depth of the directory
  int           unique;                 // enforce uniqueness on inserts
  Datatype      type;                   // datatype of the attribute
  PageId        dir[DIRSIZE];
};

struct Bucket {
  short depth;
  short slotCnt;
  char  data[Page::SIZE - 2*sizeof(short)];
};

class Index {
  BufMgr        *bufMgr;
  File          *file;
  iHeaderPage*  headerPage;      
  PageId        headerPageNo;     
  int           dirSize;            // size of the directory
  int           numSlots;           // maximum number of slots in a page
  int           recSize;
  int           curOffset;          // offset of the next entry to be scanned 
  Bucket*       curBuc;             // pointer to pinned page in buffer pool
  PageId        curPageNo;          // page number of pinned page
  const void*   curValue;           // comparison value of filter
      
  void  matchRec(const Bucket* bucket, const void *value, int offset);

  void hashIndex(const void *value, int &hashvalue);

 public:
  /*
   * Construct an Index object over an attribute of a relation. If index alreayd present as a file on disk, the same index is read, else new index file is created.
   * @param name    Name of the relation being indexed
   * @param offset  Offset of the attribute being indexed inside records
   * @param length  Length of the attribute being indexed
   * @param type    Type of the attribute being indexed
   * @param unique  =1 if the index should only allow unique entries. Create UNIQUE indices only.
   * @param bufMgr  Instance of global buffer manager.
   */
  Index(const std::string & name,
  const int offset,
  const int length,
  const Datatype type,
  const int unique,
  BufMgr *bufMgr);

  /*
   * Destructor.
   */
  ~Index();

  /*
   * Insert an entry into the index. value should point to the index key (attribute)
   */
  void insertEntry(const void* value, RecordId rid);

  /*
   * Delete an entry from the index. value should point to the index key (attribute)
   */
  void deleteEntry(const void* value, const RecordId & rid);
  
  /*
   * Initiate a indexed scan
   */
  void startScan(const void* value);

  /*
   * Return RecordId of next scanned entry.
   */
  void scanNext(RecordId& outRid);

  /*
   * End the scan.
   */
  void endScan();

  /*
   * Print the directory.
   */
  void printDir();

  /*
   * Print all the buckets.
   */
  void printBucs();
};

}