clickhouse-native 0.0.1

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

@@ -0,0 +1,142 @@
+#pragma once
+
+#include "buffer.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+#include <memory.h>
+#include <memory>
+
+namespace clickhouse {
+
+class OutputStream {
+public:
+    virtual ~OutputStream()
+    { }
+
+    inline void Flush() {
+        DoFlush();
+    }
+
+    inline size_t Write(const void* data, size_t len) {
+        return DoWrite(data, len);
+    }
+
+protected:
+    virtual void DoFlush() { }
+
+    virtual size_t DoWrite(const void* data, size_t len) = 0;
+};
+
+
+class ZeroCopyOutput : public OutputStream {
+public:
+    inline size_t Next(void** data, size_t size) {
+        return DoNext(data, size);
+    }
+
+protected:
+    // Obtains a buffer into which data can be written.  Any data written
+    // into this buffer will eventually (maybe instantly, maybe later on)
+    // be written to the output.
+    virtual size_t DoNext(void** data, size_t len) = 0;
+
+    size_t DoWrite(const void* data, size_t len) override;
+};
+
+
+/**
+ * A ZeroCopyOutput stream backed by an in-memory array of bytes.
+ */
+class ArrayOutput : public ZeroCopyOutput {
+public:
+     ArrayOutput(void* buf, size_t len);
+    ~ArrayOutput() override;
+
+    /// Number of bytes available in the stream.
+    inline size_t Avail() const noexcept {
+        return end_ - buf_;
+    }
+
+    /// Current write position in the memory block used by this stream.
+    inline const uint8_t* Data() const noexcept {
+        return buf_;
+    }
+
+    /// Whether there is more space in the stream.
+    inline bool Exhausted() const noexcept {
+        return !Avail();
+    }
+
+    /// Initializes this stream with a new memory block.
+    inline void Reset(void* buf, size_t len) noexcept {
+        buf_ = static_cast<uint8_t*>(buf);
+        end_ = buf_ + len;
+        buffer_size_ = len;
+    }
+
+    /// Number of bytes written to the buffer.
+    inline size_t Size() const noexcept {
+        return buffer_size_ - Avail();
+    }
+
+protected:
+    size_t DoNext(void** data, size_t len) override;
+
+private:
+    uint8_t* buf_;
+    uint8_t* end_;
+    size_t buffer_size_;
+};
+
+
+/**
+ * A ZeroCopyOutput stream backed by a vector.
+ *
+ * Doesn't Flush() in destructor, client must ensure to do it manually at some point.
+ */
+class BufferOutput : public ZeroCopyOutput {
+public:
+     BufferOutput(Buffer* buf);
+    ~BufferOutput() override;
+
+protected:
+    size_t DoNext(void** data, size_t len) override;
+
+private:
+    Buffer* buf_;
+    size_t pos_;
+};
+
+/** BufferedOutput writes data to internal buffer first.
+ *
+ *  Any data goes to underlying stream only if internal buffer is full
+ *  or when client invokes Flush() on this.
+ *
+ * Doesn't Flush() in destructor, client must ensure to do it manually at some point.
+ */
+class BufferedOutput : public ZeroCopyOutput {
+public:
+    explicit BufferedOutput(std::unique_ptr<OutputStream> destination, size_t buflen = 8192);
+    ~BufferedOutput() override;
+
+    void Reset();
+
+protected:
+    void DoFlush() override;
+    size_t DoNext(void** data, size_t len) override;
+    size_t DoWrite(const void* data, size_t len) override;
+
+private:
+    std::unique_ptr<OutputStream> const destination_;
+    Buffer buffer_;
+    ArrayOutput array_output_;
+};
+
+template <typename T>
+void WriteUnaligned(void* buf, const T& value) {
+    memcpy(buf, &value, sizeof(value));
+}
+
+}

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

@@ -0,0 +1 @@
+#include "platform.h"

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

@@ -0,0 +1,33 @@
+#pragma once
+
+#if defined(__linux__)
+#   define _linux_
+#elif defined(_WIN64)
+#   define _win64_
+#   define _win32_
+#elif defined(__WIN32__) || defined(_WIN32)
+#   define _win32_
+#elif defined(__APPLE__)
+#   define _darwin_
+#endif
+
+#if defined(_win32_) || defined(_win64_)
+#   define _win_
+#   if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0600)
+#      undef _WIN32_WINNT
+#      define _WIN32_WINNT 0x0600 // The WSAPoll function is defined on Windows Vista and later.
+#   endif
+#   define WIN32_LEAN_AND_MEAN 1  // don't include too much header automatically
+#endif
+
+#if defined(_linux_) || defined (_darwin_)
+#   define _unix_
+#endif
+
+#if defined(_MSC_VER)
+#   undef NOMINMAX
+#   define NOMINMAX
+#   include <basetsd.h>
+#   define ssize_t SSIZE_T
+#   define HAVE_SSIZE_T 1
+#endif

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

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+namespace clickhouse {
+
+template <typename UnaryFunction, typename Iterator, typename Reference = decltype(std::declval<UnaryFunction>()(std::declval<Iterator>())),
+          typename Value = std::decay_t<Reference>>
+class ProjectedIterator {
+public:
+    using value_type        = Value;
+    using reference         = Reference;
+    using pointer           = Reference;
+    using difference_type   = typename std::iterator_traits<Iterator>::difference_type;
+    using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
+
+    ProjectedIterator() = default;
+
+    inline ProjectedIterator(Iterator const& iterator, UnaryFunction functor)
+        : iterator_(iterator)
+        , functor_(std::move(functor)) {
+    }
+
+    inline UnaryFunction functor() const { return functor; }
+
+    inline Iterator const& base() const { return iterator_; }
+
+    inline reference operator*() const { return functor_(iterator_); }
+
+    inline ProjectedIterator& operator++() {
+        ++iterator_;
+        return *this;
+    }
+
+    inline ProjectedIterator& operator--() {
+        --iterator_;
+        return *this;
+    }
+
+    inline bool operator==(const ProjectedIterator& other) const {
+        return this->iterator_ == other.iterator_;
+    }
+
+    inline bool operator!=(const ProjectedIterator& other) const {
+        return !(*this == other);
+    }
+
+private:
+    Iterator iterator_;
+    UnaryFunction functor_;
+};
+
+}  // namespace clickhouse

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

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace clickhouse {
+
+template <typename T>
+T* Singleton() {
+    static T instance;
+    return &instance;
+}
+
+}