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
 */

#pragma once

// TODO: I don't think we want this here, but it compiles

#include <string>
#include <vector>
#include <mutex>
#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;

// 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;

  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)
} 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, CatType type,
        std::string file_name);

    void deleteEntry(FileId file_id);

    std::string getFileName(FileId file_id);

    FileId getFileId(std::string name);

    File* getFile(FileId file_id);

     Schema *getSchema(FileId file_id);

     CatType getType(FileId file_id);

    std::vector<FileId> getFileIds();

  protected:

    void _setFile(FileId file_id, File *file_ptr);

    void _saveDBStateToFile(std::string db_metadata_filename);

    friend class SwatDB;
    friend class FileManager;

  private:
    std::vector<CatalogEntry> entries;

    FileId next_fid;

    std::mutex cat_mux;
};