PDBCatalog.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 PDB_CATALOG_H_
#define PDB_CATALOG_H_

#include <algorithm>
#include <ctime>
#include <dirent.h>
#include <dlfcn.h>
#include <fstream>
#include <iostream>
#include <map>
#include <pthread.h>
#include <sqlite3.h>
#include <sstream>
#include <stdio.h>
#include <string.h>
#include <string>
#include <sys/stat.h>
#include <unistd.h>
#include <vector>

#include "CatalogDatabaseMetadata.h"
#include "CatalogNodeMetadata.h"
#include "CatalogPermissionsMetadata.h"
#include "CatalogPrintMetadata.h"
#include "CatalogSetMetadata.h"
#include "CatalogStandardDatabaseMetadata.h"
#include "CatalogStandardNodeMetadata.h"
#include "CatalogStandardSetMetadata.h"
#include "CatalogStandardUserTypeMetadata.h"
#include "CatalogUserTypeMetadata.h"
#include "CatalogUserTypeMetadata.h"
#include "Handle.h"
#include "InterfaceFunctions.h"
#include "Object.h"
#include "PDBCatalogMsgType.h"
#include "PDBCommunicator.h"
#include "PDBDebug.h"
#include "PDBLogger.h"

using namespace std;
using namespace pdb;

class PDBCatalog;
typedef shared_ptr<PDBCatalog> PDBCatalogPtr;

class PDBCatalog {
public:
  PDBCatalog(PDBLoggerPtr logger, string location);

  ~PDBCatalog();

  void open();

  bool registerUserDefinedObject(
      int16_t typeCode,
      pdb::Handle<CatalogUserTypeMetadata> &objectToRegister,
      const string &objectBytes,
      const string &typeName,
      const string &fileName,
      const string &tableName,
      string &errorMessage);

  template <class CatalogMetadataType>
  bool addMetadataToCatalog(
      Handle<CatalogMetadataType> &metadataValue,
      int &metadataCategory,
      string &errorMessage);

  template <class CatalogMetadataType>
  bool addItemToVector(Handle<CatalogMetadataType> &item, int &key);

  template <class CatalogMetadataType>
  bool updateMetadataInCatalog(
      pdb::Handle<CatalogMetadataType> &metadataValue,
      int &metadataCategory,
      string &errorMessage);

  template <class CatalogMetadataType>
  bool deleteMetadataInCatalog(
      pdb::Handle<CatalogMetadataType> metadataValue,
      int &metadataCategory,
      string &errorMessage);

  template <class CatalogMetadataType>
  bool updateItemInVector(
       int &index,
       Handle<CatalogMetadataType> &item);

  template <class CatalogMetadataType>
  bool deleteItemInVector(
       int &index,
       Handle<CatalogMetadataType> &item);

  map<string, CatalogNodeMetadata> getListOfNodesInCluster();

  bool getSerializedCatalog(string fileName, string version,
                            string &returnedBytes, string &errorMessage);

  void setCatalogVersion(string version);

  string getCatalogVersion();

  void getModifiedMetadata(Handle<CatalogPrintMetadata> &itemMetadata);

  template <class CatalogMetadataType>
  bool getMetadataFromCatalog(
      bool onlyModified,
      string key,
      Handle<pdb::Vector<CatalogMetadataType>> &returnedEntries,
      string &errorMessage,
      int metadataCategory);

  int getLastId(int &metadataCategory);

  string itemName2ItemId(int &metadataCategory, string &key);

  bool keyIsFound(int &metadataCategory, string &key, string &value);

  friend std::ostream &operator<<(std::ostream &out, PDBCatalog &catalog);

  PDBLoggerPtr getLogger();

  map<string, CatalogUserTypeMetadata> getUserDefinedTypesList();

  void printsAllCatalogMetadata(
       std::string &outputString,
       std::string &errMsg);

  void listRegisteredDatabases(
       std::string &outputString,
       std::string &errMsg);

  void listRegisteredSetsForADatabase(
       std::string databaseName,
       std::string &outputString,
       std::string &errMsg);

  void listNodesInCluster(
       std::string &outputString,
       std::string &errMsg);

  void listUserDefinedTypes(
       std::string &outputString,
       std::string &errMsg);

  bool retrievesDynamicLibrary(
       string fileName,
       string tableName,
       Handle<CatalogUserTypeMetadata> &returnedItem,
       string &returnedSoLibrary,
       string &errorName);

  void getListOfDatabases(
      Handle<Vector<CatalogDatabaseMetadata>> &databasesInCatalog,
      const string &key);

  void getListOfSets(
       Handle<Vector<CatalogSetMetadata>> &setsInCatalog,
       const string &key);

  void getListOfNodes(Handle<Vector<CatalogNodeMetadata>> &nodesInCatalog,
                      const string &key);

  void closeSQLiteHandler();

private:
  string getMapsPDBOjbect2SQLiteTable(int typeOfObject);

  void loadsMetadataIntoMemory();

  pthread_mutex_t registerMetadataMutex;

  string catalogVersion;

  PDBLoggerPtr logger;

  sqlite3 *sqliteDBHandler = NULL;

  vector<CatalogDatabaseMetadata> dbList;

  Handle<pdb::Vector<Handle<CatalogUserTypeMetadata>>> listUsersInCluster;

  multimap<string, CatalogUserTypeMetadata> mapUsersInCluster;

  map<string, int16_t> mapTypeNameToTypeID;

  map<int16_t, string> mapTypeIdToTypeName;

  map<string, CatalogNodeMetadata> registeredNodes;

  Handle<Vector<CatalogNodeMetadata>> registeredNodesMetadata;

  map<string, CatalogSetMetadata> registeredSets;

  Handle<Vector<CatalogSetMetadata>> registeredSetsMetadata;

  map<string, CatalogDatabaseMetadata> registeredDatabases;

  Handle<Vector<CatalogDatabaseMetadata>> registeredDatabasesMetadata;

  map<string, CatalogUserTypeMetadata> registeredUserDefinedTypes;

  Handle<Vector<CatalogUserTypeMetadata>> registeredUserDefinedTypesMetadata;

  Handle<Map<String, Handle<Vector<Object>>>> catalogContents;

  string uriPath;

  string catalogRootPath;

  string catalogFilename;

  string tempPath;

  bool catalogSqlQuery(string statement);

  bool catalogSqlStep(sqlite3_stmt *stmt, string &errorMsg);

  int createsTempPath();

  void setUriPath(string thePath) { uriPath = thePath; }

  void deleteTempSoFiles(string filePath);

  map<int, string> mapsPDBOjbect2SQLiteTable;

  map<int, string> mapsPDBArrayOjbect2SQLiteTable;
};

#endif /* PDB_CATALOG_H_ */