Result.hpp

Go to the documentation of this file.

 
#ifndef TABLEAU_HYPER_RESULT_HPP
#define TABLEAU_HYPER_RESULT_HPP
 
#include <hyperapi/Date.hpp>
#include <hyperapi/ResultSchema.hpp>
#include <hyperapi/string_view.hpp>
#include <hyperapi/hyperapi.h>
 
#include <functional>
#include <iterator>
#include <string>
 
namespace hyperapi {
 
class ChunkIterator;
struct Chunks;
class ColumnIterator;
class Connection;
class Result;
class Row;
class ChunkedResultIterator;
class ResultIterator;
namespace internal {
inline bool hasCopyData(Result& result);
struct CopyData;
inline CopyData getCopyData(Result& result);
inline hyper_rowset_type_t getResultType(Result& result);
}
 
class Value final {
   public:
   Value(hyper_value_t value, SqlType type, string_view columnName) noexcept
      : value_(value), type_(type), columnName_(columnName) {
   }
 
   Value() noexcept {}
 
   template <typename ReturnType>
   operator ReturnType() const { return get<ReturnType>(); }
 
   template <typename ReturnType>
   ReturnType get() const;
 
   SqlType getType() const noexcept { return type_; }
 
   bool isNull() const noexcept { return !value_.value; }
 
   friend std::ostream& operator<<(std::ostream& os, const Value& value);
 
   friend bool operator==(const Value& lhs, const Value& rhs) noexcept { return lhs.value_.value == rhs.value_.value; }
 
   friend bool operator!=(const Value& lhs, const Value& rhs) noexcept { return !(lhs == rhs); }
 
   private:
   friend class ColumnIterator;
   template <typename ReturnType>
   friend struct internal::ValueAccess;
   friend class Connection;
 
   Value(const Value&) = default;
   Value(Value&&) = default;
   Value& operator=(const Value&) = default;
   Value& operator=(Value&&) = default;
 
   hyper_value_t value_{nullptr, 0};
   SqlType type_{TypeTag::Unsupported, 0};
   string_view columnName_ = "";
};
 
class Chunk final {
   public:
   Chunk() noexcept = default;
 
   ~Chunk() noexcept;
 
   Chunk(Chunk& other) = delete;
   Chunk& operator=(Chunk& other) = delete;
 
   Chunk(Chunk&& other) noexcept;
   Chunk& operator=(Chunk&& other) noexcept;
 
   Row getRowAt(hyper_row_index_t chunkRowIndex) const noexcept;
 
   size_t getRowCount() const noexcept { return rowCount_; }
 
   bool isOpen() const noexcept { return (chunk_ != nullptr); }
 
   operator bool() const noexcept { return isOpen(); }
 
   friend bool operator==(const Chunk& lhs, const Chunk& rhs) noexcept { return lhs.chunk_ == rhs.chunk_; }
 
   friend bool operator!=(const Chunk& lhs, const Chunk& rhs) noexcept { return !(lhs == rhs); }
 
   private:
   Chunk(hyper_rowset_chunk_t* chunk, const Result& result) noexcept;
 
   hyper_rowset_chunk_t* chunk_ = nullptr;
   mutable const uint8_t* const* values_ = nullptr;
   mutable const size_t* valuesSizes_ = nullptr;
   size_t chunkSize_ = 0;
   const Result* result_ = nullptr;
   size_t rowCount_ = 0;
 
   const uint8_t* const* getValues() const noexcept;
   const size_t* getValuesSizes() const noexcept;
 
   friend class Row;
   friend class ColumnIterator;
   friend class Result;
};
 
class Row final {
   public:
   template <typename ReturnType = Value>
   ReturnType get(hyper_field_index_t columnIndex) const;
 
   const ResultSchema& getSchema() const noexcept;
 
   private:
   Row(const Chunk& chunk, hyper_row_index_t chunkRowIndex) noexcept;
 
   Row(const Row&) = default;
   Row(Row&&) = default;
   Row& operator=(const Row&) = default;
   Row& operator=(Row&&) = default;
 
   std::reference_wrapper<const Chunk> chunk_;
   hyper_row_index_t chunkRowIndex_;
 
   friend class Chunk;
   friend class ResultIterator;
   friend class ColumnIterator;
   friend class ChunkIterator;
};
 
struct IteratorBeginTag {
};
static constexpr IteratorBeginTag iteratorBeginTag = {};
 
struct IteratorEndTag {
};
static constexpr IteratorEndTag iteratorEndTag = {};
 
class ChunkIterator final {
   public:
   using iterator_category = std::input_iterator_tag;
   using value_type = Row;
   using difference_type = std::ptrdiff_t;
   using pointer = const Row*;
   using reference = const Row&;
 
   ChunkIterator(const Chunk& chunk, IteratorBeginTag) noexcept
      : chunk_(chunk), rowIndex_(0), currentRow_(chunk, 0) {
   }
 
   ChunkIterator(const Chunk& chunk, IteratorEndTag) noexcept
      : chunk_(chunk), rowIndex_(static_cast<hyper_row_index_t>(chunk.getRowCount())), currentRow_(chunk, 0) {
   }
 
   reference operator*() const noexcept;
 
   pointer operator->() const noexcept { return &**this; }
 
   ChunkIterator& operator++() noexcept;
 
   ChunkIterator operator++(int) noexcept;
 
   friend bool operator==(const ChunkIterator& lhs, const ChunkIterator& rhs) noexcept { return (lhs.chunk_.get() == rhs.chunk_.get()) && (lhs.rowIndex_ == rhs.rowIndex_); }
 
   friend bool operator!=(const ChunkIterator& lhs, const ChunkIterator& rhs) noexcept { return !(lhs == rhs); }
 
   private:
   std::reference_wrapper<const Chunk> chunk_;
   hyper_row_index_t rowIndex_;
   mutable Row currentRow_;
 
   friend class ResultIterator;
};
 
inline ChunkIterator begin(const Chunk& chunk) {
   return {chunk, iteratorBeginTag};
}
 
inline ChunkIterator end(const Chunk& chunk) noexcept {
   return {chunk, iteratorEndTag};
}
 
class Result final {
   public:
   Result() : currentChunkIterator_(end(currentChunk_)) {}
 
   ~Result() noexcept;
 
   Result(Result&& other) noexcept;
 
   Result& operator=(Result&& other) noexcept;
 
   Result& operator=(const Result& other) = delete;
   Result(const Result& other) = delete;
 
   const ResultSchema& getSchema() const noexcept { return *schema_; }
 
   optional<size_t> getAffectedRowCount() const;
 
   Connection& getConnection();
 
   bool isOpen() const noexcept;
 
   void close() noexcept;
 
   private:
   explicit Result(hyper_rowset_t* rowset, Connection& conn);
 
   void fetchNextChunk();
 
   Chunk& getCurrentChunk();
 
   ChunkIterator& getCurrentChunkIterator();
 
   void createSchema();
 
   hyper_rowset_t* rowset_ = nullptr;
 
   Connection* conn_ = nullptr;
 
   mutable optional<ResultSchema> schema_;
 
   Chunk currentChunk_;
   ChunkIterator currentChunkIterator_;
 
   friend class Row;
   friend class Connection;
   friend class Chunk;
   friend class ChunkedResultIterator;
   friend class ResultIterator;
   friend Result internal::executePreparedQuery(Connection& connection, const std::string& statement_name, hyper_rowset_result_format_t result_format);
   friend Result internal::executeQueryParams(Connection& connection, const std::string& query, hyper_rowset_result_format_t result_format);
   friend bool operator==(const ChunkedResultIterator& lhs, const ChunkedResultIterator& rhs) noexcept;
   friend bool operator==(const ResultIterator& lhs, const ResultIterator& rhs) noexcept;
   friend inline bool internal::hasCopyData(Result&);
   friend inline internal::CopyData internal::getCopyData(Result& result);
   friend inline hyper_rowset_type_t internal::getResultType(Result& result);
};
 
struct Chunks {
   Chunks(Result& result) : result(result) {
   }
 
   Result& result;
};
 
class ColumnIterator final {
   public:
   using iterator_category = std::input_iterator_tag;
   using value_type = Value;
   using difference_type = std::ptrdiff_t;
   using pointer = const Value*;
   using reference = const Value&;
 
   ColumnIterator(const Row& row, IteratorBeginTag) noexcept
      : row_(row), columnIndex_(0) {
   }
 
   ColumnIterator(const Row& row, IteratorEndTag) noexcept
      : row_(row), columnIndex_(static_cast<hyper_field_index_t>(row.getSchema().getColumnCount())) {
   }
 
   reference operator*() const noexcept;
 
   pointer operator->() const noexcept { return &**this; }
 
   ColumnIterator& operator++();
 
   ColumnIterator operator++(int);
 
   friend bool operator==(const ColumnIterator& lhs, const ColumnIterator& rhs) noexcept { return (&lhs.row_.get() == &rhs.row_.get()) && (lhs.columnIndex_ == rhs.columnIndex_); }
 
   friend bool operator!=(const ColumnIterator& lhs, const ColumnIterator& rhs) noexcept { return !(lhs == rhs); }
 
   private:
   std::reference_wrapper<const Row> row_;
   hyper_field_index_t columnIndex_;
   mutable Value currentValue_;
};
 
inline ColumnIterator begin(const Row& row) {
   return {row, iteratorBeginTag};
}
 
inline ColumnIterator end(const Row& row) noexcept {
   return {row, iteratorEndTag};
}
 
class ChunkedResultIterator final {
   public:
   using iterator_category = std::input_iterator_tag;
   using value_type = Chunk;
   using difference_type = std::ptrdiff_t;
   using pointer = Chunk*;
   using reference = Chunk&;
 
   ChunkedResultIterator(Result& result, IteratorBeginTag);
   ChunkedResultIterator(Result& result, IteratorEndTag) noexcept
      : result_(result), isEndIterator_(true) {
   }
 
   reference operator*() noexcept { return result_.get().currentChunk_; }
 
   pointer operator->() noexcept { return &**this; }
 
   ChunkedResultIterator& operator++();
 
   friend bool operator==(const ChunkedResultIterator& lhs, const ChunkedResultIterator& rhs) noexcept;
 
   friend bool operator!=(const ChunkedResultIterator& lhs, const ChunkedResultIterator& rhs) noexcept { return !(lhs == rhs); }
 
   private:
   std::reference_wrapper<Result> result_;
   bool isEndIterator_;
};
 
inline ChunkedResultIterator begin(const Chunks& chunks) {
   return {chunks.result, iteratorBeginTag};
}
 
inline ChunkedResultIterator end(const Chunks& chunks) noexcept {
   return {chunks.result, iteratorEndTag};
}
 
class ResultIterator final {
   public:
   using iterator_category = std::input_iterator_tag;
   using value_type = Row;
   using difference_type = std::ptrdiff_t;
   using pointer = const Row*;
   using reference = const Row&;
 
   ResultIterator(Result& result, IteratorBeginTag);
   ResultIterator(Result& result, IteratorEndTag) noexcept
      : result_(result), isEndIterator_(true) {
   }
 
   reference operator*() const noexcept { return *result_.get().getCurrentChunkIterator(); }
 
   pointer operator->() const noexcept { return &**this; }
 
   ResultIterator& operator++();
 
   friend bool operator==(const ResultIterator& lhs, const ResultIterator& rhs) noexcept;
 
   friend bool operator!=(const ResultIterator& lhs, const ResultIterator& rhs) noexcept { return !(lhs == rhs); }
 
   private:
   std::reference_wrapper<Result> result_;
   bool isEndIterator_;
};
 
inline ResultIterator begin(Result& result) {
   return {result, iteratorBeginTag};
}
 
inline ResultIterator end(Result& result) noexcept {
   return {result, iteratorEndTag};
}
}
 
#include <hyperapi/impl/Result.impl.hpp>
 
#endif