swatdb_types.h

Go to the documentation of this file.

/*
 * SwatDB
 *
 * @authors: See Contributors.doc for code contributors
 *
 * Copyright (c) 2020 Swarthmore College Computer Science Department
 * Swarthmore PA, Professors Tia Newhall, Ameet Soni
 */
 
#ifndef  _SWATDB_SWATDBTYPES_H_
#define  _SWATDB_SWATDBTYPES_H_
 
 
 
#include <cstdint>
#include <string>
 
typedef std::uint32_t FileId;
 
typedef std::uint32_t PageNum;
 
typedef std::uint32_t FrameId;
 
typedef std::uint32_t SlotId;
 
struct PageId{
  FileId file_id;
  PageNum page_num;
 
  bool operator==(const PageId& other) const{
    return (file_id == other.file_id) && (page_num == other.page_num);
  }
 
  bool operator!=(const PageId& other) const{
    return (file_id != other.file_id) || (page_num != other.page_num);
  }
};
 
struct RecordId{
  PageNum page_num;
  SlotId slot_id;
 
  bool operator==(const RecordId& other) const{
    return (page_num == other.page_num) && (slot_id == other.slot_id);
  }
 
  bool operator!=(const RecordId& other) const{
    return (page_num != other.page_num) || (slot_id != other.slot_id);
  }
};
 
typedef std::uint32_t FieldId;
 
typedef std::uint16_t FieldOffset;
 
enum FieldType { IntFieldT,
                 FloatFieldT,
                 StringFieldT,
                 InvalidFieldT};
 
 
struct FieldEntry{
  std::string field_name;
  FieldType field_type; 
  std::uint32_t max_size;
 
  bool operator==(const FieldEntry& other) const{
    return (max_size == other.max_size)  && (field_name == other.field_name) 
       && (field_type == other.field_type);
  } 
 
  bool operator!=(const FieldEntry& other) const{
    return (max_size != other.max_size) || (field_name != other.field_name)
         || (field_type != other.field_type);
  }
 
};
 
 
typedef std::uint32_t Level;
 
typedef std::uint32_t HashVal;
 
enum CatType { INVALID_CAT_TYPE,
              HeapFileT,
              SortedFileT,
              BPlusTreeT,
              HashIndexT
              // add new types here (and add `,` after HashIndexT )
             };
 
 
enum Comp {INVALID_TYPE,
          LESS,
          GREATER,
          EQUAL,
          NOT_EQUAL,
          LESS_EQUAL,
          GREATER_EQUAL
          };
 
enum RepType { INVALID_REP_TYPE,
              ClockT,
              RandomT,
              MruT,
              ClockRandomT,  
              LruT,
       // add new types here (and add  after LruT and before MAXREPTYPES) 
              MAXREPTYPES
};
 
const int  BM_MAX_REP_STR_LEN = (48);
const char bm_rep_strs[MAXREPTYPES][BM_MAX_REP_STR_LEN]  = { "Invalid",
                "Clock",
                "Random",
                "MRU",
                "ClockRandom",  /* what is this? */
                "LRU"
       // add new string for new policy types here (add `,` after "LRU" ) 
       // make sure length of string is less than BM_MAX_REP_STR_LEN 
};
 
 
enum SelectType { INVALID_SELECT_TYPE,
              FileScanT,
              IndexT
       // add new types here (and add `,` after Index )
            };
 
 
enum JoinType { INVALID_JOIN_TYPE,
              TupleNLJT,
              IndexNLJT,
              BlockNLJT,
              SeqHashJoinT,
              ParHashJoinT
       // add new types here (and add `,` after ParHashJoin )
            };
 
 
struct SelectConjunct{
 
  FieldId field_id;
  void *value;
  Comp comp;
 
};
 
 
const std::uint32_t FILE_MAX_CAPACITY = 100000000;
//const std::uint32_t FILE_MAX_CAPACITY =   2097152;  /* 2 MB */
//const std::uint32_t FILE_MAX_CAPACITY =   5242880;  /* 5 MB */
 
const std::uint32_t MAX_FILE_NUM = 1000;
 
/* NOTE: (don't make the page size larger than 2^16 due to field offsets in 
 * records)
 */
const std::uint32_t PAGE_SIZE = 1024;
 
// TODO: these is defined in terms of the internal details of the current
// HeapFile implementation, and assuming a specific target architecture
// and compiler padding of structs.  We should make these more generic
// to deal with changes to any of these.
const std::uint32_t MAX_RECORD_SIZE = PAGE_SIZE - (8 * sizeof(std::uint32_t));
 
const std::uint32_t MAX_PAGE_NUM = ((8*(FILE_MAX_CAPACITY -sizeof(std::uint32_t)
    *2))/(8*PAGE_SIZE+1))-1;
 
const std::uint32_t MAX_FILE_NAME_LEN = 511;  /* 2^9 is huge */
 
const std::uint32_t BUF_SIZE = 1024;
 
//const std::uint32_t BUF_SIZE = 2048;
 
const std::uint32_t MAX_FIELD_NAME = 32;
 
const std::uint32_t INVALID_PAGE_NUM = MAX_PAGE_NUM+1;
 
const std::uint32_t HEADER_PAGE_NUM = 0;
 
const std::uint32_t INVALID_FILE_ID = MAX_FILE_NUM+1;
 
const PageId INVALID_PAGE_ID = {INVALID_FILE_ID, INVALID_PAGE_NUM};
 
const std::uint32_t INVALID_SLOT_OFFSET = PAGE_SIZE+1;
 
const SlotId INVALID_SLOT_ID = INVALID_SLOT_OFFSET;
 
const RecordId INVALID_RECORD_ID = {INVALID_PAGE_NUM, INVALID_SLOT_ID};
 
const float MAX_HEAP_PAGE_LOAD = 0.9;
 
const float MAX_HASH_BUCKET_LOAD = 0.9;
 
const SlotId MAX_HASH_DIRSLOT = PAGE_SIZE/sizeof(PageNum);
 
 
#endif