reference/cxx/Result_8hpp_source.html

#ifndef TABLEAU_HYPER_RESULT_HPP

#define TABLEAU_HYPER_RESULT_HPP


#include <hyperapi/ByteSpan.hpp>

#include <hyperapi/Date.hpp>

#include <hyperapi/HyperException.hpp>

#include <hyperapi/Interval.hpp>

#include <hyperapi/Numeric.hpp>

#include <hyperapi/OffsetTimestamp.hpp>

#include <hyperapi/ResultSchema.hpp>

#include <hyperapi/Time.hpp>

#include <hyperapi/Timestamp.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