buffer_manager.h

 
#ifndef _BUFFER_MANAGER_H_
#define _BUFFER_MANAGER_H_ 1
 
#include <cstdio>
#include <iostream>
#include <vector>
#include <string>
#include <sys/timeb.h>
#include <sys/stat.h>
#include <filesystem>
#include <map>
 
#include "share/config.h"
#include "share/err_type.h"
 
class Page {
    public:
        Page();
        void initialize();
        void setFileName(std::string file_name);
        std::string getFileName() const;
        void setBlockId(int block_id);
        int getBlockId() const;
        void setPinCount(int pin_count);
        int getPinCount() const;
        void setDirty(bool dirty);
        bool isDirty() const;
        void setAvaliable(bool avaliable);
        bool getAvaliable() const;
        void setTime();
        long long getTime();
        char* getBuffer();
//    private:
        char buffer_[PAGESIZE]; 
        std::string file_name_; 
        int block_id_; 
        int pin_count_; 
        bool dirty_; 
        bool avaliable_; 
        long long last_access_time;
 
        std::string getPageStrId(){
            return getFileName() + std::to_string(getBlockId());
        };
 
        static std::string generatePageStrId(const std::string &file_path, int b_id){
            return file_path + std::to_string(b_id);
        }
};
 
class BufferManager {
    public:
        BufferManager();
        BufferManager(int frame_size);
        ~BufferManager();
        char* getPage(const std::string& file_name , int block_id); 
        char* getPage(const std::string& file_name, int block_id, pageId_t& pageId);
        void modifyPage(int page_id); 
        void pinPage(int page_id); 
        int unpinPage(int page_id); 
        int flushPage(pageId_t page_id); 
        int getPageId(const std::string& file_name , int block_id); 
        static size_t getFileSize(std::string file_name){
            struct stat file_state{};
            const char *path = file_name.c_str();
            if (stat(path, &file_state) == -1){
                std::cout << "File path error" << std::endl;
                throw DB_FILE_NOT_FOUND;
            }
            size_t size = file_state.st_size;
            return size;
        }
 
        static bool FileExists(const std::string& path){
            return std::filesystem::exists(path);
        }
 
        static void createEmptyFile(const std::string& path){
            FILE* f;
            f = fopen(path.c_str(), "w");
            if (f == nullptr) throw DB_FAILED;
            fclose(f);
        }
 
        void removeFile(const std::string& path){
            remove(path.c_str());
            auto iter = fname_page_map.find(path);
            if(iter != fname_page_map.end()){ // Bfm still has a block of the file. Clear.
                Frames[iter->second].initialize();
            }
        }
 
        int getBlockNum(const std::string& fileName);
 
    private:
        Page* Frames; 
        int frame_size_; 
        int current_position_; 
        void initialize(int frame_size); 
        int getEmptyPageId(); 
        int loadDiskBlock(int page_id , const std::string& file_name , int block_id); 
        std::map<std::string, pageId_t> fname_page_map; 
};
 
#endif