reference/cxx/Connection_8hpp_source.html

#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