mirror of
https://github.com/hanzo-ds/cpp.git
synced 2026-10-30 20:31:26 +00:00
zeekay
286f257aae
Pure rename applied on top of upstream tag v2.6.2 (8d2415d6), not HEAD.
The fork was cut at 737145d = v2.6.2-57, which still declared version 2.6.2
in version.h; renaming there would have shipped 57 unreleased commits wearing
a 2.6.2 label. Reset to the tag first so this commit changes names only.
clickhouse/ -> datastore/ (public include root)
namespace clickhouse -> namespace datastore
CLICKHOUSE_CPP_VERSION -> DATASTORE_CPP_VERSION
clickhouse-cpp-lib/-ut -> datastore-cpp-lib/-ut (CMake, Bazel)
CH_MAP_BOOL_TO_UINT8 -> DS_MAP_BOOL_TO_UINT8
CLICKHOUSE_* -> DATASTORE_* (test env vars)
doc links -> docs.hanzo.ai/datastore
This client speaks the NATIVE binary protocol only - there is no HTTP path
and no X-ClickHouse-* header anywhere in it, so the header rename that the
HTTP clients required does not apply and nothing here was broken.
The one string that reaches the wire is CLIENT_NAME, sent by both SendHello
and SendQuery's ClientInfo from a single macro, and it lands in
system.query_log.client_name. Both sites still read the one macro, so they
stay consistent and the server's Hello/Query consistency check is satisfied.
Old rows keep the old name; that is a reporting discontinuity, not a
migration, since nothing keys on it.
CI is repointed at our own server: ghcr.io/hanzoai/datastore:26.2.3.2, the
image production runs. Its entrypoint honours DATASTORE_SKIP_USER_SETUP, not
the CLICKHOUSE_ spelling the compose file used, and its config lives in
/etc/hanzo-datastore-server. ci/docker-compose/config.xml is now layered in
as a config.d drop-in so the image keeps its own white-labelling. That file
and users.xml deliberately keep a <clickhouse> root: it must match the roots
of the drop-ins the image ships, and a mismatch fails silently - the server
logs "Merging bypassed" and starts with every drop-in discarded.
The remote-TLS suites used to default to the third-party host
play.clickhouse.com. They now read DATASTORE_SECURE*_HOST and skip when it is
unset rather than point at a host we do not run.
Dropped as upstream infrastructure with no meaning here: AI_POLICY.md
(upstream's policy about their codebase), .travis.yml (dead CI referencing a
third-party apt repo), cross-repo-bug-relay.yml (relays our issues into an
upstream triage repo). LICENSE keeps its copyright notice, as Apache-2.0
requires.
Verified: cmake configure + 115-target build clean; the full suite is green
against ghcr.io/hanzoai/datastore:26.2.3.2 (894 passed, 0 failed); the
pristine v2.6.2 build run against that same server passes the identical set,
and both logged the same 3914 queries under their respective client names.
143 lines
3.2 KiB
C++
143 lines
3.2 KiB
C++
#pragma once
|
|
|
|
#include "buffer.h"
|
|
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <vector>
|
|
#include <memory.h>
|
|
#include <memory>
|
|
|
|
namespace datastore {
|
|
|
|
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));
|
|
}
|
|
|
|
}
|