StorageCollection.h

Go to the documentation of this file.

//
// Created by Nico Schäfer on 11/16/17.
//
 
#ifndef JODA_STORAGECOLLECTION_H
#define JODA_STORAGECOLLECTION_H
 
#include <joda/join/JoinManager.h>
 
#include <unordered_map>
 
#include <joda/join/JoinManager.h>
#include <boost/functional/hash.hpp>
#include "../../../../../include/joda/storage/JSONStorage.h"
 
#define JODA_TEMPORARY_STORAGE_NAME "TEMPORARY_RESULT"
#define JODA_STORE_SKIPPED_QUERY_ID 0
#define JODA_STORE_EXTERNAL_RS_ID 1
#define JODA_STORE_EMPTY_RS_ID 2
#define JODA_STORE_VALID_ID_START 3
 
class StorageCollection {
 public:
  static StorageCollection &getInstance() {
    static StorageCollection instance;  // Guaranteed to be destroyed.
    // Instantiated on first use.
    return instance;
  }
 
  StorageCollection(StorageCollection const &) = delete;
  void operator=(StorageCollection const &) = delete;
 
  virtual ~StorageCollection();
  std::shared_ptr<JSONStorage> getStorage(const std::string &name);
  bool storageExists(const std::string &name);
  std::shared_ptr<JSONStorage> getOrAddStorage(const std::string &name);
  void removeStorage(const std::string &name);
  std::vector<std::shared_ptr<JSONStorage>> getStorages();
  std::vector<std::shared_ptr<JSONStorage>> getTemporaryStorages();
  std::vector<std::pair<unsigned long, std::shared_ptr<JSONStorage>>>
  getTemporaryIDStorages();
  std::shared_ptr<JSONStorage> getStorage(unsigned long id);
  unsigned long addTemporaryStorage(
      const std::shared_ptr<JSONStorage> &storage);
  unsigned long addTemporaryStorage();
  void removeStorage(unsigned long id);
 
  std::shared_ptr<JoinManager> getOrStartJoin(
      std::unique_ptr<joda::query::IValueProvider> &&valProv);
 
  void stopJoin(const joda::query::IValueProvider &valProv);
  void stopJoin(const JoinManager &jm);
 
  void ensureSpace(
      unsigned long long estimatedSize,
      const std::shared_ptr<JSONStorage> &withoutDependency = nullptr);
  void addDependency(const std::shared_ptr<JSONStorage> &store,
                     const std::shared_ptr<JSONStorage> &dependson);
  size_t estimateHierarchySize(const std::shared_ptr<JSONStorage> &store) const;
  long long estimatedStorageSize() const;
  size_t parsedHierarchySize(const std::shared_ptr<JSONStorage> &store) const;
  size_t estimatedSize() const;
  size_t estimatedParsedSize() const;
 
 protected:
  std::vector<JSONStorage *> getDependencies(
      const std::shared_ptr<JSONStorage> &store) const;
 
  std::vector<std::pair<JSONStorage *, size_t>> chooseStoragesToRemove(
      long long toFree, const std::vector<JSONStorage *> &except) const;
  void orderContainerBySize(
      std::vector<std::pair<JSONStorage *, size_t>> &candidates) const;
  void orderContainerByLRU(
      std::vector<std::pair<JSONStorage *, size_t>> &candidates) const;
  void orderContainerByFIFO(
      std::vector<std::pair<JSONStorage *, size_t>> &candidates) const;
  void orderContainerByDependencies(
      std::vector<std::pair<JSONStorage *, size_t>> &candidates) const;
  void orderContainerByRandomExplorer(
      std::vector<std::pair<JSONStorage *, size_t>> &candidates) const;
 
  std::string getJoinName(const joda::query::IValueProvider &valProv);
  std::unordered_map<std::string, std::shared_ptr<JSONStorage>> storages;
  std::vector<std::string> storageInsertion;
  std::unordered_map<unsigned long, std::shared_ptr<JSONStorage>> resultStorage;
  std::unordered_map<std::string, std::shared_ptr<JoinManager>> runningJoins;
  std::mutex mut;
  std::atomic_ulong tmpRes{JODA_STORE_VALID_ID_START};
 
  std::unordered_set<
      std::pair<std::shared_ptr<JSONStorage>, std::shared_ptr<JSONStorage>>,
      boost::hash<std::pair<std::shared_ptr<JSONStorage>,
                            std::shared_ptr<JSONStorage>>>>
      dependencies;
 
  StorageCollection(){};
 
 private:
  friend class CollectionTest;
  friend class CollectionTest_FIFO_Test;
  friend class CollectionTest_LARGEST_Test;
  friend class CollectionTest_DEPENDENCIES_Test;
};
 
#endif  // JODA_STORAGECOLLECTION_H