PartitionedFile.h

Go to the documentation of this file.

/*****************************************************************************
 *                                                                           *
 *  Copyright 2018 Rice University                                           *
 *                                                                           *
 *  Licensed under the Apache License, Version 2.0 (the "License");          *
 *  you may not use this file except in compliance with the License.         *
 *  You may obtain a copy of the License at                                  *
 *                                                                           *
 *      http://www.apache.org/licenses/LICENSE-2.0                           *
 *                                                                           *
 *  Unless required by applicable law or agreed to in writing, software      *
 *  distributed under the License is distributed on an "AS IS" BASIS,        *
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
 *  See the License for the specific language governing permissions and      *
 *  limitations under the License.                                           *
 *                                                                           *
 *****************************************************************************/
#ifndef PARTITIONEDFILE_H
#define PARTITIONEDFILE_H

#include "PDBFile.h"
#include "PartitionedFileMetaData.h"
#include "SharedMem.h"
#include <string>
#include <vector>
#include <memory>
using namespace std;
class PartitionedFile;
typedef shared_ptr<PartitionedFile> PartitionedFilePtr;

class PartitionedFile : public PDBFileInterface {
public:
    PartitionedFile(NodeID nodeId,
                    DatabaseID dbId,
                    UserTypeID typeId,
                    SetID setId,
                    string metaPartitionPath,
                    vector<string> dataPartitionPaths,
                    pdb::PDBLoggerPtr logger,
                    size_t pageSize);

    PartitionedFile(NodeID nodeId,
                    DatabaseID dbId,
                    UserTypeID typeId,
                    SetID setId,
                    string metaPartitionPath,
                    pdb::PDBLoggerPtr logger);

    ~PartitionedFile();

    bool openAll() override;

    bool openMeta();

    bool openData();

    bool openDataDirect();

    bool closeAll() override;

    bool closeDirect();

    void clear() override;

    int appendPage(FilePartitionID partitionId, PDBPagePtr page) override;

    int appendPageDirect(FilePartitionID partitionId, PDBPagePtr page);

    int writeMeta() override;


    int updateMeta() override;

    size_t loadPage(FilePartitionID partitionId,
                    unsigned int pageSeqInPartition,
                    char* pageInCache,
                    size_t length) override;

    size_t loadPageDirect(FilePartitionID partitionId,
                          unsigned int pageSeqInPartition,
                          char* pageInCache,
                          size_t length);


    size_t loadPageFromCurPos(FilePartitionID partitionId,
                              unsigned int pageSeqInPartition,
                              char* pageInCache,
                              size_t length);

    PageID loadPageId(FilePartitionID partitionId, unsigned int pageSeqInPartition);

    PageID loadPageIdFromCurPos(FilePartitionID partitionId,
                                unsigned int pageSeqInPartition,
                                char* pageInCache,
                                size_t length);


    unsigned int getAndSetNumFlushedPages() override;

    unsigned int getNumFlushedPages() override;

    PageID getLastFlushedPageID() override;

    PageID getLatestPageID() override;

    NodeID getNodeId() override;

    DatabaseID getDbId() override;

    UserTypeID getTypeId() override;

    SetID getSetId() override;

    size_t getPageSize() override;

    size_t getPageSizeInMeta() override;

    FileType getFileType() override;

    PartitionedFileMetaDataPtr getMetaData();

    void initializeDataFiles();

    void setDataPartitionPaths(const vector<string>& dataPartitionPaths);

    void buildMetaDataFromMetaPartition(SharedMemPtr shm);

    unsigned int getNumPartitions();

protected:
    int writeData(FILE* file, void* data, size_t length);

    int writeDataDirect(int handle, void* data, size_t length);

    int seekPage(FILE* file, unsigned int pageSeqInPartition);

    int seekPageDirect(int handle, unsigned int pageSeqInPartition);

    int seekPageSizeInMeta();

    int seekNumFlushedPagesInMeta();

    int seekNumFlushedPagesInPartitionMeta(FilePartitionID partitionId);


private:
    pthread_mutex_t fileMutex;


    FILE* metaFile = nullptr;
    // int metaHandle;

    vector<FILE*> dataFiles;
    vector<int> dataHandles;

    string metaPartitionPath;

    vector<string> dataPartitionPaths;

    pdb::PDBLoggerPtr logger = nullptr;

    PartitionedFileMetaDataPtr metaData = nullptr;

    NodeID nodeId;

    DatabaseID dbId;

    UserTypeID typeId;

    SetID setId;

    size_t pageSize = 0;

    bool usingDirect;

    bool cleared;
};


#endif /* PARTITIONEDFILE_H */