clickhouse-native 0.0.1

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/base/wire_format.cpp

@@ -0,0 +1,177 @@
+#include <assert.h>
+#include "wire_format.h"
+
+#include "input.h"
+#include "output.h"
+
+#include "../exceptions.h"
+
+#include <stdexcept>
+#include <algorithm>
+
+namespace {
+constexpr int MAX_VARINT_BYTES = 10;
+}
+
+namespace clickhouse {
+
+bool WireFormat::ReadAll(InputStream& input, void* buf, size_t len) {
+    uint8_t* p = static_cast<uint8_t*>(buf);
+
+    size_t read_previously = 1; // 1 to execute loop at least once
+    while (len > 0 && read_previously) {
+        read_previously = input.Read(p, len);
+
+        p += read_previously;
+        len -= read_previously;
+    }
+
+    return !len;
+}
+
+void WireFormat::WriteAll(OutputStream& output, const void* buf, size_t len) {
+    const size_t original_len = len;
+    const uint8_t* p = static_cast<const uint8_t*>(buf);
+
+    size_t written_previously = 1; // 1 to execute loop at least once
+    while (len > 0 && written_previously) {
+        written_previously = output.Write(p, len);
+
+        p += written_previously;
+        len -= written_previously;
+    }
+
+    if (len) {
+        throw ProtocolError("Failed to write " + std::to_string(original_len)
+                + " bytes, only written " + std::to_string(original_len - len));
+    }
+}
+
+bool WireFormat::ReadVarint64(InputStream& input, uint64_t* value) {
+    *value = 0;
+
+    for (size_t i = 0; i < MAX_VARINT_BYTES; ++i) {
+        uint8_t byte = 0;
+
+        if (!input.ReadByte(&byte)) {
+            return false;
+        } else {
+            *value |= uint64_t(byte & 0x7F) << (7 * i);
+
+            if (!(byte & 0x80)) {
+                return true;
+            }
+        }
+    }
+
+    // TODO skip invalid
+    return false;
+}
+
+void WireFormat::WriteVarint64(OutputStream& output, uint64_t value) {
+    uint8_t bytes[MAX_VARINT_BYTES];
+    int size = 0;
+
+    for (size_t i = 0; i < MAX_VARINT_BYTES; ++i) {
+        uint8_t byte = value & 0x7F;
+        if (value > 0x7F)
+            byte |= 0x80;
+
+        bytes[size++] = byte;
+
+        value >>= 7;
+        if (!value) {
+            break;
+        }
+    }
+
+    WriteAll(output, bytes, size);
+}
+
+bool WireFormat::SkipString(InputStream& input) {
+    uint64_t len = 0;
+
+    if (ReadVarint64(input, &len)) {
+        if (len > 0x00FFFFFFULL)
+            return false;
+
+        return input.Skip((size_t)len);
+    }
+
+    return false;
+}
+
+inline const char* find_quoted_chars(const char* start, const char* end)
+{
+    static constexpr char quoted_chars[] = {'\0', '\b', '\t', '\n', '\'', '\\'};
+    const auto first  = std::find_first_of(start, end, std::begin(quoted_chars), std::end(quoted_chars));
+
+    return (first == end) ? nullptr : first;
+}
+
+void WireFormat::WriteQuotedString(OutputStream& output, std::string_view value) {
+    auto size               = value.size();
+    const char* start       = value.data();
+    const char* end         = start + size;
+    const char* quoted_char = find_quoted_chars(start, end);
+    if (quoted_char == nullptr) {
+        WriteVarint64(output, size + 2);
+        WriteAll(output, "'", 1);
+        WriteAll(output, start, size);
+        WriteAll(output, "'", 1);
+        return;
+    }
+
+    // calculate quoted chars count
+    int quoted_count             = 1;
+    const char* next_quoted_char = quoted_char + 1;
+    while ((next_quoted_char = find_quoted_chars(next_quoted_char, end))) {
+        quoted_count++;
+        next_quoted_char++;
+    }
+    WriteVarint64(output, size + 2 + 3 * quoted_count);  // length
+
+    WriteAll(output, "'", 1);
+
+    do {
+        auto write_size = quoted_char - start;
+        WriteAll(output, start, write_size);
+        WriteAll(output, "\\", 1);
+        char c = quoted_char[0];
+        switch (c) {
+            case '\0':
+                WriteAll(output, "x00", 3);
+                break;
+            case '\b':
+                WriteAll(output, "x08", 3);
+                break;
+            case '\t':
+                WriteAll(output, R"(\\t)", 3);
+                break;
+            case '\n':
+                WriteAll(output, R"(\\n)", 3);
+                break;
+            case '\'':
+                WriteAll(output, "x27", 3);
+                break;
+            case '\\':
+                WriteAll(output, R"(\\\)", 3);
+                break;
+            default:
+                break;
+        }
+        start       = quoted_char + 1;
+        quoted_char = find_quoted_chars(start, end);
+    } while (quoted_char);
+
+    WriteAll(output, start, end - start);
+    WriteAll(output, "'", 1);
+}
+
+void WireFormat::WriteParamNullRepresentation(OutputStream& output) {
+    const std::string NULL_REPRESENTATION(R"('\\N')");
+    WriteVarint64(output, NULL_REPRESENTATION.size());
+    WriteAll(output, NULL_REPRESENTATION.data(), NULL_REPRESENTATION.size());
+}
+
+}  // namespace clickhouse

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/base/wire_format.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <string>
+#include <cstdint>
+
+namespace clickhouse {
+
+class InputStream;
+class OutputStream;
+
+class WireFormat {
+public:
+    template <typename T>
+    static bool ReadFixed(InputStream& input, T* value);
+    static bool ReadString(InputStream& input, std::string* value);
+    static bool SkipString(InputStream& input);
+    static bool ReadBytes(InputStream& input, void* buf, size_t len);
+    static bool ReadUInt64(InputStream& input, uint64_t* value);
+    static bool ReadVarint64(InputStream& output, uint64_t* value);
+
+    template <typename T>
+    static void WriteFixed(OutputStream& output, const T& value);
+    static void WriteBytes(OutputStream& output, const void* buf, size_t len);
+    static void WriteString(OutputStream& output, std::string_view value);
+    static void WriteQuotedString(OutputStream& output, std::string_view value);
+    static void WriteParamNullRepresentation(OutputStream& output);
+    static void WriteUInt64(OutputStream& output, const uint64_t value);
+    static void WriteVarint64(OutputStream& output, uint64_t value);
+
+private:
+    static bool ReadAll(InputStream& input, void* buf, size_t len);
+    static void WriteAll(OutputStream& output, const void* buf, size_t len);
+};
+
+template <typename T>
+inline bool WireFormat::ReadFixed(InputStream& input, T* value) {
+    return ReadAll(input, value, sizeof(T));
+}
+
+inline bool WireFormat::ReadString(InputStream& input, std::string* value) {
+    uint64_t len = 0;
+    if (ReadVarint64(input, &len)) {
+        if (len > 0x00FFFFFFULL) {
+            return false;
+        }
+        value->resize((size_t)len);
+        return ReadAll(input, value->data(), (size_t)len);
+    }
+
+    return false;
+}
+
+inline bool WireFormat::ReadBytes(InputStream& input, void* buf, size_t len) {
+    return ReadAll(input, buf, len);
+}
+
+inline bool WireFormat::ReadUInt64(InputStream& input, uint64_t* value) {
+    return ReadVarint64(input, value);
+}
+
+template <typename T>
+inline void WireFormat::WriteFixed(OutputStream& output, const T& value) {
+    WriteAll(output, &value, sizeof(T));
+}
+
+inline void WireFormat::WriteBytes(OutputStream& output, const void* buf, size_t len) {
+    WriteAll(output, buf, len);
+}
+
+inline void WireFormat::WriteString(OutputStream& output, std::string_view value) {
+    WriteVarint64(output, value.size());
+    WriteAll(output, value.data(), value.size());
+}
+
+inline void WireFormat::WriteUInt64(OutputStream& output, const uint64_t value) {
+    WriteVarint64(output, value);
+}
+
+}

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/block.cpp

@@ -0,0 +1,134 @@
+#include "block.h"
+
+#include "exceptions.h"
+
+#include <stdexcept>
+
+namespace clickhouse {
+
+Block::Iterator::Iterator(const Block& block)
+    : block_(block)
+    , idx_(0)
+{
+}
+
+Block::Iterator::Iterator(const Block& block, Block::Iterator::ConstructAtEndTag /*at_end*/)
+    : block_(block)
+    , idx_(block.GetColumnCount())
+{}
+
+const std::string& Block::Iterator::Name() const {
+    return block_.columns_[idx_].name;
+}
+
+TypeRef Block::Iterator::Type() const {
+    return block_.columns_[idx_].column->Type();
+}
+
+ColumnRef Block::Iterator::Column() const {
+    return block_.columns_[idx_].column;
+}
+
+bool Block::Iterator::Next() {
+    ++idx_;
+    return IsValid();
+}
+
+bool Block::Iterator::IsValid() const {
+    return idx_ < block_.columns_.size();
+}
+
+
+Block::Block()
+    : rows_(0)
+{
+}
+
+Block::Block(size_t cols, size_t rows)
+    : rows_(rows)
+{
+    columns_.reserve(cols);
+}
+
+Block::~Block() = default;
+
+void Block::AppendColumn(const std::string& name, const ColumnRef& col) {
+    if (columns_.empty()) {
+        rows_ = col->Size();
+    } else if (col->Size() != rows_) {
+        throw ValidationError("all columns in block must have same count of rows. Name: ["+name+"], rows: ["+std::to_string(rows_)+"], columns: [" + std::to_string(col->Size())+"]");
+    }
+
+    columns_.push_back(ColumnItem{name, col});
+}
+
+/// Count of columns in the block.
+size_t Block::GetColumnCount() const {
+    return columns_.size();
+}
+
+const BlockInfo& Block::Info() const {
+    return info_;
+}
+
+/// Set block info
+void Block::SetInfo(BlockInfo info) {
+    info_ = std::move(info);
+}
+
+/// Count of rows in the block.
+size_t Block::GetRowCount() const {
+    return rows_;
+}
+
+size_t Block::RefreshRowCount() {
+    size_t rows = 0UL;
+
+    for (size_t idx = 0UL; idx < columns_.size(); ++idx)
+    {
+       const std::string& name = columns_[idx].name;
+       const ColumnRef& col = columns_[idx].column;
+
+       if (idx == 0UL)
+           rows = col->Size();
+       else if (rows != col->Size())
+           throw ValidationError("all columns in block must have same count of rows. Name: ["+name+"], rows: ["+std::to_string(rows)+"], columns: [" + std::to_string(col->Size())+"]");
+    }
+
+    rows_ = rows;
+    return rows_;
+}
+
+void Block::Clear() {
+    for (auto & c : columns_) {
+        c.column->Clear();
+    }
+
+    RefreshRowCount();
+}
+
+void Block::Reserve(size_t new_cap) {
+    for (auto & c : columns_) {
+        c.column->Reserve(new_cap);
+    }
+}
+
+
+
+ColumnRef Block::operator [] (size_t idx) const {
+    if (idx < columns_.size()) {
+        return columns_[idx].column;
+    }
+
+    throw std::out_of_range("column index is out of range. Index: ["+std::to_string(idx)+"], columns: [" + std::to_string(columns_.size())+"]");
+}
+
+Block::Iterator Block::begin() const {
+    return Iterator(*this);
+}
+
+Block::Iterator Block::end() const {
+    return Iterator(*this, Iterator::ConstructAtEndTag{});
+}
+
+}

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/block.h

@@ -0,0 +1,114 @@
+#pragma once
+
+#include "columns/column.h"
+
+namespace clickhouse {
+
+struct BlockInfo {
+    uint8_t is_overflows = 0;
+    int32_t bucket_num = -1;
+};
+
+class Block {
+public:
+    /// Allow to iterate over block's columns.
+    class Iterator {
+    public:
+        Iterator(const Block& block);
+
+        /// Name of column.
+        const std::string& Name() const;
+
+        /// Type of column.
+        TypeRef Type() const;
+
+        /// Reference to column object.
+        ColumnRef Column() const;
+
+        /// Move to next column, returns false if next call to IsValid() would return false;
+        bool Next();
+
+        /// Is the iterator still valid.
+        bool IsValid() const;
+
+        size_t ColumnIndex() const {
+            return idx_;
+        }
+
+        Iterator& operator*() { return *this; }
+        const Iterator& operator*() const { return *this; }
+
+        bool operator==(const Iterator & other) const {
+            return &block_ == &other.block_ && idx_ == other.idx_;
+        }
+        bool operator!=(const Iterator & other) const {
+            return !(*this == other);
+        }
+
+        Iterator& operator++() {
+            this->Next();
+            return *this;
+        }
+
+    private:
+        friend class Block;
+        struct ConstructAtEndTag {};
+        Iterator(const Block& block, ConstructAtEndTag at_end);
+        Iterator() = delete;
+
+        const Block& block_;
+        size_t idx_;
+    };
+
+public:
+     Block();
+     Block(size_t cols, size_t rows);
+    ~Block();
+
+    /// Append named column to the block.
+    void AppendColumn(const std::string& name, const ColumnRef& col);
+
+    /// Count of columns in the block.
+    size_t GetColumnCount() const;
+
+    const BlockInfo& Info() const;
+
+    /// Set block info
+    void SetInfo(BlockInfo info);
+
+    /// Count of rows in the block.
+    size_t GetRowCount() const;
+
+    size_t RefreshRowCount();
+
+    const std::string& GetColumnName(size_t idx) const {
+        return columns_.at(idx).name;
+    }
+
+    /// Convenience method to wipe out all rows from all columns
+    void Clear();
+
+    /// Convenience method to do Reserve() on all columns
+    void Reserve(size_t new_cap);
+
+    /// Reference to column by index in the block.
+    ColumnRef operator [] (size_t idx) const;
+
+    Iterator begin() const;
+    Iterator end() const;
+    Iterator cbegin() const { return begin(); }
+    Iterator cend() const { return end(); }
+
+private:
+    struct ColumnItem {
+        std::string name;
+        ColumnRef   column;
+    };
+
+    BlockInfo info_;
+    std::vector<ColumnItem> columns_;
+    /// Count of rows in the block.
+    size_t rows_;
+};
+
+}