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.
150 lines
4.1 KiB
C++
150 lines
4.1 KiB
C++
#include "tuple.h"
|
|
|
|
namespace datastore {
|
|
namespace {
|
|
|
|
std::vector<TypeRef> CollectTypes(const std::vector<ColumnRef>& columns) {
|
|
std::vector<TypeRef> types;
|
|
for (const auto& col : columns) {
|
|
types.push_back(col->Type());
|
|
}
|
|
return types;
|
|
}
|
|
|
|
/// Tuple types can be appended if they have the same shape.
|
|
bool CanAppendType(const TypeRef& destination_type, const TypeRef& source_type) {
|
|
if (destination_type->GetCode() != Type::Tuple || source_type->GetCode() != Type::Tuple) {
|
|
return destination_type->IsEqual(source_type);
|
|
}
|
|
|
|
const auto* destination_tuple = destination_type->As<TupleType>();
|
|
const auto* source_tuple = source_type->As<TupleType>();
|
|
|
|
const auto destination_item_types = destination_tuple->GetTupleType();
|
|
const auto source_item_types = source_tuple->GetTupleType();
|
|
if (destination_item_types.size() != source_item_types.size()) {
|
|
return false;
|
|
}
|
|
|
|
for (size_t i = 0; i < destination_item_types.size(); ++i) {
|
|
if (!CanAppendType(destination_item_types[i], source_item_types[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
ColumnTuple::ColumnTuple(const std::vector<ColumnRef>& columns)
|
|
: Column(Type::CreateTuple(CollectTypes(columns)))
|
|
, columns_(columns)
|
|
{
|
|
}
|
|
|
|
ColumnTuple::ColumnTuple(const std::vector<ColumnRef>& columns,
|
|
std::vector<std::string> names)
|
|
: Column(Type::CreateTuple(CollectTypes(columns), std::move(names)))
|
|
, columns_(columns)
|
|
{
|
|
}
|
|
|
|
size_t ColumnTuple::TupleSize() const {
|
|
return columns_.size();
|
|
}
|
|
|
|
void ColumnTuple::Reserve(size_t new_cap) {
|
|
for (auto& column : columns_) {
|
|
column->Reserve(new_cap);
|
|
}
|
|
}
|
|
|
|
void ColumnTuple::Append(ColumnRef column) {
|
|
if (!CanAppendType(this->Type(), column->Type())) {
|
|
throw ValidationError(
|
|
"can't append column of type " + column->Type()->GetName() + " "
|
|
"to column type " + this->Type()->GetName());
|
|
}
|
|
const auto & source_tuple_column = column->As<ColumnTuple>();
|
|
for (size_t ci = 0; ci < columns_.size(); ++ci) {
|
|
columns_[ci]->Append((*source_tuple_column)[ci]);
|
|
}
|
|
}
|
|
|
|
size_t ColumnTuple::Size() const {
|
|
return columns_.empty() ? 0 : columns_[0]->Size();
|
|
}
|
|
|
|
ColumnRef ColumnTuple::Slice(size_t begin, size_t len) const {
|
|
std::vector<ColumnRef> sliced_columns;
|
|
sliced_columns.reserve(columns_.size());
|
|
for(const auto &column : columns_) {
|
|
sliced_columns.push_back(column->Slice(begin, len));
|
|
}
|
|
|
|
const auto& names = this->Type()->As<TupleType>()->GetItemNames();
|
|
if (names.empty()) {
|
|
return std::make_shared<ColumnTuple>(sliced_columns);
|
|
}
|
|
return std::make_shared<ColumnTuple>(sliced_columns, names);
|
|
}
|
|
|
|
ColumnRef ColumnTuple::CloneEmpty() const {
|
|
std::vector<ColumnRef> result_columns;
|
|
result_columns.reserve(columns_.size());
|
|
|
|
for(const auto &column : columns_) {
|
|
result_columns.push_back(column->CloneEmpty());
|
|
}
|
|
|
|
const auto& names = this->Type()->As<TupleType>()->GetItemNames();
|
|
if (names.empty()) {
|
|
return std::make_shared<ColumnTuple>(result_columns);
|
|
}
|
|
return std::make_shared<ColumnTuple>(result_columns, names);
|
|
}
|
|
|
|
bool ColumnTuple::LoadPrefix(InputStream* input, size_t rows) {
|
|
for (auto ci = columns_.begin(); ci != columns_.end(); ++ci) {
|
|
if (!(*ci)->LoadPrefix(input, rows)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ColumnTuple::LoadBody(InputStream* input, size_t rows) {
|
|
for (auto ci = columns_.begin(); ci != columns_.end(); ++ci) {
|
|
if (!(*ci)->LoadBody(input, rows)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void ColumnTuple::SavePrefix(OutputStream* output) {
|
|
for (auto & column : columns_) {
|
|
column->SavePrefix(output);
|
|
}
|
|
}
|
|
|
|
void ColumnTuple::SaveBody(OutputStream* output) {
|
|
for (auto & column : columns_) {
|
|
column->SaveBody(output);
|
|
}
|
|
}
|
|
|
|
void ColumnTuple::Clear() {
|
|
columns_.clear();
|
|
}
|
|
|
|
void ColumnTuple::Swap(Column& other) {
|
|
auto & col = dynamic_cast<ColumnTuple &>(other);
|
|
columns_.swap(col.columns_);
|
|
}
|
|
|
|
}
|