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.5 KiB
C++
143 lines
3.5 KiB
C++
#pragma once
|
|
|
|
#include <cassert>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
|
|
/**
|
|
* A lightweight non-owning read-only view into a subsequence of a string.
|
|
*/
|
|
template <
|
|
typename TChar,
|
|
typename TTraits = std::char_traits<TChar>
|
|
>
|
|
class
|
|
[[deprecated("Obsolete due to C++17's std::string_view. Will be removed in next major release (3.0) ")]]
|
|
StringViewImpl {
|
|
public:
|
|
using size_type = size_t;
|
|
using traits_type = TTraits;
|
|
using value_type = typename TTraits::char_type;
|
|
|
|
static constexpr size_type npos = size_type(-1);
|
|
|
|
public:
|
|
inline StringViewImpl() noexcept
|
|
: data_(nullptr)
|
|
, size_(0)
|
|
{
|
|
}
|
|
|
|
constexpr inline StringViewImpl(const TChar* data, size_t len) noexcept
|
|
: data_(data)
|
|
, size_(len)
|
|
{
|
|
}
|
|
|
|
template <size_t len>
|
|
constexpr inline StringViewImpl(const TChar (&str)[len]) noexcept
|
|
: data_(str)
|
|
, size_(len - 1)
|
|
{
|
|
}
|
|
|
|
inline StringViewImpl(const TChar* begin, const TChar* end) noexcept
|
|
: data_(begin)
|
|
, size_(end - begin)
|
|
{
|
|
assert(begin <= end);
|
|
}
|
|
|
|
inline StringViewImpl(const std::basic_string<TChar>& str) noexcept
|
|
: data_(str.data())
|
|
, size_(str.size())
|
|
{
|
|
}
|
|
|
|
inline TChar at(size_type pos) const {
|
|
if (pos >= size_)
|
|
throw std::out_of_range("pos must be less than len");
|
|
return data_[pos];
|
|
}
|
|
|
|
inline const TChar* data() const noexcept {
|
|
return data_;
|
|
}
|
|
|
|
inline bool empty() const noexcept {
|
|
return size_ == 0;
|
|
}
|
|
|
|
inline bool null() const noexcept {
|
|
assert(size_ == 0);
|
|
return data_ == nullptr;
|
|
}
|
|
|
|
inline size_type size() const noexcept {
|
|
return size_;
|
|
}
|
|
|
|
// to mimic std::string and std::string_view
|
|
inline size_type length() const noexcept {
|
|
return size();
|
|
}
|
|
|
|
public:
|
|
// Returns a substring [pos, pos + count).
|
|
// If the requested substring extends past the end of the string,
|
|
// or if count == npos, the returned substring is [pos, size()).
|
|
StringViewImpl substr(size_type pos, size_type count = npos) const {
|
|
if (pos >= size_)
|
|
throw std::out_of_range("pos must be less than len");
|
|
if (pos + count >= size_ || count == npos)
|
|
return StringViewImpl(data_ + pos, size_ - pos);
|
|
else
|
|
return StringViewImpl(data_ + pos, count);
|
|
}
|
|
|
|
inline const std::basic_string<TChar> to_string() const {
|
|
return std::basic_string<TChar>(data_, size_);
|
|
}
|
|
|
|
public:
|
|
inline operator bool () const noexcept {
|
|
return !empty();
|
|
}
|
|
|
|
inline explicit operator const std::basic_string<TChar> () const {
|
|
return to_string();
|
|
}
|
|
|
|
inline TChar operator [] (size_type pos) const noexcept {
|
|
return data_[pos];
|
|
}
|
|
|
|
inline bool operator < (const StringViewImpl& other) const noexcept {
|
|
if (size_ < other.size_)
|
|
return true;
|
|
if (size_ > other.size_)
|
|
return false;
|
|
return TTraits::compare(data_, other.data_, size_) < 0;
|
|
}
|
|
|
|
inline bool operator == (const StringViewImpl& other) const noexcept {
|
|
if (size_ == other.size_)
|
|
return TTraits::compare(data_, other.data_, size_) == 0;
|
|
return false;
|
|
}
|
|
|
|
private:
|
|
const TChar* data_;
|
|
size_t size_;
|
|
};
|
|
|
|
|
|
// It creates StringView from literal constant at compile time.
|
|
template <typename TChar, size_t size>
|
|
constexpr inline StringViewImpl<TChar> MakeStringView(const TChar (&str)[size]) {
|
|
return StringViewImpl<TChar>(str, size - 1);
|
|
}
|
|
|
|
|
|
using StringView = StringViewImpl<char>;
|