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.
135 lines
2.8 KiB
C++
135 lines
2.8 KiB
C++
#include "block.h"
|
|
|
|
#include "exceptions.h"
|
|
|
|
#include <stdexcept>
|
|
|
|
namespace datastore {
|
|
|
|
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::At(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{});
|
|
}
|
|
|
|
}
|