catalog.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_CATALOG_H_
#define  _SWATDB_CATALOG_H_
 
// TODO: I don't think we want this here, but it compiles
 
#include <string>
#include <vector>
#include <mutex>
#include <unordered_map>
#include "swatdb_types.h"
 
// too many circular includes, just define these types like
// this and include the .h file for them in the .cpp files:
class File;
class Schema;
class SwatDB;
class SearchKeyFormat;
 
// TODO: we need to think about what this is and
// if this should be a base class with derived classes for
// index and relations.  For now it is just a struct so that we
// can implement the fileIDtoFileName methods
// This is here now to support the getFileName method for testing
// the diskMgr, but needs more thought
// TODO: should this be a private field or do we want to
// export it...  It might be a protected field?
/*
 * An entry in the catalog.  There is one entry for each relation and
 * index in the system.
 *
 * A Catalog Entry includes:
 *   file_id: the entries FileId used as a system-wide identifier for this
 *        relation or index
 *   name: the name of the index or relation
 *   type: the type of entry (Relation or Index)
 *   schema: a pointer to its schema object
 *   file: a pointer to its SwatDB file object (ex. HeapFile, BplusTree)
 *   disk_file_name: the name of the Unix file storing it in diskMgr
 *   valid: set to true if this entry has valid contents
 *   alloc: set to true if this entry has been allocated for use
 *          (it may currently be being filled by another thread)
 */
 
typedef struct {
 
  FileId file_id;
 
  std::string name;
 
  CatType entry_type;
 
  Schema *schema;
 
  SearchKeyFormat* key_format;
 
  File *file;
 
  std::string file_name;
 
  bool valid;
 
  bool alloced;      // TODO: only need this if lock on catalog vector
  // may be released well some of an entry is filled in
  // (so no other thread will allocate this entry)
 
  FileId relation;
 
  std::vector<FileId> index_list;
 
  bool save_on_exit;
 
} CatalogEntry;
 
class Catalog {
 
  public:
    Catalog();
 
    Catalog(std::string db_metadata_file);
 
    ~Catalog();
 
    // TODO: we need to think about if we have one method for
    //       adding both index entries and file entries or different
    //       methods (addRelationEntry and addIndexEntry)
    //       Also, we may want multiple versions with different parameters
    //
    //    this method(s) may be called from DB loading that reads relation
    //    data from a config file on booting/initing, or it could
    //    be from a "query" layer for creating a new relation or
    //
    //    TODO: it may make sense for this to be a protected method
    /*
     * This method can be called to add an entry for a newly created
     * index or relation as SwatDB runs, or to add a catalog entry for
     * an index or relation during that is loaded from saved swatdb state
     * during SwatDB boot.
     */
    //
    FileId addEntry(std::string name, Schema *schema, File *file, 
        SearchKeyFormat *key_format, CatType type, FileId relation, 
        std::string file_name, bool to_save = true);
 
    void deleteEntry(FileId file_id);
 
    void printCatInfo();
 
    std::uint32_t getNumValid(); 
 
    std::string getFileName(FileId file_id);
 
    FileId getFileId(std::string name);
 
    FileId getRelationFileId(FileId file_id);
 
    File* getFile(FileId file_id);
 
     Schema *getSchema(FileId file_id);
 
     CatType getType(FileId file_id);
 
    std::vector<FileId> getFileIds();
 
    void setSave(bool save_on_exit, std::string rel_name);
 
    void setRelName(std::string old_rel_name, std::string new_rel_name);
 
  protected:
 
    void _setFile(FileId file_id, File *file_ptr);
 
    void _saveDBStateToFile(std::string db_metadata_filename);
 
    friend class SwatDB;
    friend class FileManager;
 
  private:
 
    std::unordered_map<std::string, FileId> relations; 
    std::vector<CatalogEntry> entries;
 
    FileId next_fid;
 
     std::uint32_t  num_valid_entries;
 
    std::mutex cat_mux;
};
 
#endif