btree.h

#pragma once

#include <iostream>
#include <string>
#include "string.h"
#include <sstream>

#include "types.h"
#include "page.h"
#include "file.h"
#include "buffer.h"

namespace badgerdb
{

enum Datatype
{
  INTEGER = 0,
  DOUBLE = 1,
  STRING = 2
};

enum Operator
{ 
  LT,   /* Less Than */
  LTE,  /* Less Than or Equal to */
  GTE,  /* Greater Than or Equal to */
  GT    /* Greater Than */
};

const  int STRINGSIZE = 10;

//                                                  sibling ptr             key               rid
const  int INTARRAYLEAFSIZE = ( Page::SIZE - sizeof( PageId ) ) / ( sizeof( int ) + sizeof( RecordId ) );

//                                                     sibling ptr               key               rid
const  int DOUBLEARRAYLEAFSIZE = ( Page::SIZE - sizeof( PageId ) ) / ( sizeof( double ) + sizeof( RecordId ) );

//                                                    sibling ptr           key                      rid
const  int STRINGARRAYLEAFSIZE = ( Page::SIZE - sizeof( PageId ) ) / ( 10 * sizeof(char) + sizeof( RecordId ) );

//                                                     level     extra pageNo                  key       pageNo
const  int INTARRAYNONLEAFSIZE = ( Page::SIZE - sizeof( int ) - sizeof( PageId ) ) / ( sizeof( int ) + sizeof( PageId ) );

//                                                        level        extra pageNo                 key            pageNo   -1 due to structure padding
const  int DOUBLEARRAYNONLEAFSIZE = (( Page::SIZE - sizeof( int ) - sizeof( PageId ) ) / ( sizeof( double ) + sizeof( PageId ) )) - 1;

//                                                        level        extra pageNo             key                   pageNo
const  int STRINGARRAYNONLEAFSIZE = ( Page::SIZE - sizeof( int ) - sizeof( PageId ) ) / ( 10 * sizeof(char) + sizeof( PageId ) );

template <class T>
class RIDKeyPair{
public:
  RecordId rid;
  T key;
  void set( RecordId r, T k)
  {
    rid = r;
    key = k;
  }
};

template <class T>
class PageKeyPair{
public:
  PageId pageNo;
  T key;
  void set( int p, T k)
  {
    pageNo = p;
    key = k;
  }
};

template <class T>
bool operator<( const RIDKeyPair<T>& r1, const RIDKeyPair<T>& r2 )
{
  if( r1.key != r2.key )
    return r1.key < r2.key;
  else
    return r1.rid.page_number < r2.rid.page_number;
}

struct IndexMetaInfo{
  char relationName[20];

  int attrByteOffset;

  Datatype attrType;

  PageId rootPageNo;
};

/*
Each node is a page, so once we read the page in we just cast the pointer to the page to this struct and use it to access the parts
These structures basically are the format in which the information is stored in the pages for the index file depending on what kind of 
node they are. The level memeber of each non leaf structure seen below is set to 1 if the nodes 
at this level are just above the leaf nodes. Otherwise set to 0.
*/

struct NonLeafNodeInt{
  int level;

  int keyArray[ INTARRAYNONLEAFSIZE ];

  PageId pageNoArray[ INTARRAYNONLEAFSIZE + 1 ];
};

struct NonLeafNodeDouble{
  int level;

  double keyArray[ DOUBLEARRAYNONLEAFSIZE ];

  PageId pageNoArray[ DOUBLEARRAYNONLEAFSIZE + 1 ];
};

struct NonLeafNodeString{
  int level;

  char keyArray[ STRINGARRAYNONLEAFSIZE ][ STRINGSIZE ];

  PageId pageNoArray[ STRINGARRAYNONLEAFSIZE + 1 ];
};

struct LeafNodeInt{
  int keyArray[ INTARRAYLEAFSIZE ];

  RecordId ridArray[ INTARRAYLEAFSIZE ];

  PageId rightSibPageNo;
};

struct LeafNodeDouble{
  double keyArray[ DOUBLEARRAYLEAFSIZE ];

  RecordId ridArray[ DOUBLEARRAYLEAFSIZE ];

  PageId rightSibPageNo;
};

struct LeafNodeString{
  char keyArray[ STRINGARRAYLEAFSIZE ][ STRINGSIZE ];

  RecordId ridArray[ STRINGARRAYLEAFSIZE ];

  PageId rightSibPageNo;
};

class BTreeIndex {

 private:

  File    *file;

  BufMgr  *bufMgr;

  PageId  headerPageNum;

  PageId  rootPageNum;

  Datatype  attributeType;

  int     attrByteOffset;

  int   leafOccupancy;

  int   nodeOccupancy;


  // MEMBERS SPECIFIC TO SCANNING

  bool    scanExecuting;

  int   nextEntry;

  PageId  currentPageNum;

  Page    *currentPageData;

  int   lowValInt;

  double  lowValDouble;

  std::string lowValString;

  int   highValInt;

  double  highValDouble;

  std::string highValString;
  
  Operator  lowOp;

  Operator  highOp;

  
 public:

  BTreeIndex(const std::string & relationName, std::string & outIndexName,
            BufMgr *bufMgrIn, const int attrByteOffset, const Datatype attrType);
  

  ~BTreeIndex();


  const void insertEntry(const void* key, const RecordId rid);


  const void startScan(const void* lowVal, const Operator lowOp, const void* highVal, const Operator highOp);


  const void scanNext(RecordId& outRid);  // returned record id


  const void endScan();
  
};

}