Connection.hpp

Go to the documentation of this file.

 
#ifndef TABLEAU_HYPER_CONNECTION_HPP
#define TABLEAU_HYPER_CONNECTION_HPP
 
#include <functional>
#include <hyperapi/Catalog.hpp>
#include <hyperapi/HyperException.hpp>
#include <hyperapi/HyperProcess.hpp>
#include <hyperapi/HyperServiceVersion.hpp>
#include <hyperapi/Name.hpp>
#include <hyperapi/Result.hpp>
#include <hyperapi/impl/infra.hpp>
#include <hyperapi/optional.hpp>
#include <memory>
#include <mutex>
#include <new>
#include <string>
#include <hyperapi/hyperapi.h>
 
namespace hyperapi {
 
enum class CreateMode {
   None = HYPER_DO_NOT_CREATE,
   Create = HYPER_CREATE,
   CreateIfNotExists = HYPER_CREATE_IF_NOT_EXISTS,
   CreateAndReplace = HYPER_CREATE_AND_REPLACE
};
 
class Value;
 
class Connection final {
   using CatalogPimpl = std::unique_ptr<Catalog>;
 
   public:
   Connection(const Endpoint& endpoint, const std::unordered_map<std::string, std::string>& parameters = {});
 
   Connection(
      const Endpoint& endpoint,
      const std::string& databasePath,
      CreateMode createMode = CreateMode::None,
      const std::unordered_map<std::string, std::string>& parameters = {});
 
   Connection() noexcept {}
 
   virtual ~Connection() noexcept;
 
   Connection(Connection&& other) noexcept;
 
   Connection& operator=(Connection&& other) noexcept;
 
   Connection(const Connection& other) = delete;
   Connection& operator=(const Connection& other) = delete;
 
   HYPER_API_NODISCARD Result executeQuery(const std::string& sql);
 
   int64_t executeCommand(const std::string& sql);
 
   template <typename T>
   T executeScalarQuery(const std::string& sql);
 
   Catalog& getCatalog() noexcept;
 
   void cancel() noexcept;
 
   bool isReady();
 
   bool isOpen() const noexcept { return m_handle != nullptr; }
 
   virtual void close() noexcept;
 
   HyperServiceVersion getHyperServiceVersion();
 
   bool isCapabilityActive(const std::string& capabilityFlag);
 
   static std::vector<HyperServiceVersion> querySupportedHyperServiceVersionRange(const Endpoint& endpoint);
 
   private:
   std::mutex m_mutex;
   hyper_connection_t* m_handle = nullptr;
   CatalogPimpl m_catalog;
   std::unique_ptr<internal::NoticeReceiver> noticeReceiver{new internal::NoticeReceiver()};
   std::unique_ptr<internal::AsyncResultCallback> asyncResultCallback{new internal::AsyncResultCallback()};
 
   friend class Catalog;
   friend class Inserter;
   friend void internal::setNoticeReceiver(Connection& connection, internal::NoticeReceiver noticeReceiver) noexcept;
   friend void internal::setAsyncResultCallback(Connection& connection, internal::AsyncResultCallback asyncResultCallback) noexcept;
   friend const internal::AsyncResultCallback& internal::getAsyncResultCallback(Connection& connection) noexcept;
   friend hyper_connection_t* internal::getHandle(Connection&) noexcept;
};
}
 
#include <hyperapi/impl/Catalog.impl.hpp>
#include <hyperapi/impl/Connection.impl.hpp>
 
#endif