Files
cpp/datastore/columns/lowcardinalityadaptor.h
zeekay 286f257aae De-brand the client: clickhouse-cpp -> datastore-cpp
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.
2026-07-26 11:44:39 -07:00

64 lines
2.1 KiB
C++

#pragma once
#include "column.h"
#include "lowcardinality.h"
#include <cassert>
namespace datastore {
class OutputStream;
class CodedInputStream;
/** Adapts any ColumnType to be serialized\deserialized as LowCardinality,
* and to be castable to ColumnType via ColumnPtr->As<ColumnType>().
*
* It helps to ease migration of the old codebases, which can't afford to switch
* to using ColumnLowCardinalityT or ColumnLowCardinality directly,
* but still want to benefit from smaller on-wire LowCardinality bandwidth footprint.
*
* Not intended to be used by users directly.
*
* @see ClientOptions, CreateColumnByType
*/
template <typename AdaptedColumnType>
class
[[deprecated("Makes implementation of LC(X) harder and code uglier. Will be removed in next major release (3.0) ")]]
LowCardinalitySerializationAdaptor : public AdaptedColumnType
{
public:
using AdaptedColumnType::AdaptedColumnType;
bool LoadPrefix(InputStream* input, size_t rows) override {
auto new_data_column = this->Slice(0, 0)->template As<AdaptedColumnType>();
ColumnLowCardinalityT<AdaptedColumnType> low_cardinality_col(new_data_column);
return low_cardinality_col.LoadPrefix(input, rows);
}
/// Loads column data from input stream.
bool LoadBody(InputStream* input, size_t rows) override {
auto new_data_column = this->CloneEmpty()->template As<AdaptedColumnType>();
ColumnLowCardinalityT<AdaptedColumnType> low_cardinality_col(new_data_column);
if (!low_cardinality_col.LoadBody(input, rows))
return false;
// It safe to reuse `flat_data_column` later since ColumnLowCardinalityT makes a deep copy, but still check just in case.
assert(new_data_column->Size() == 0);
for (size_t i = 0; i < low_cardinality_col.Size(); ++i)
new_data_column->Append(low_cardinality_col[i]);
this->Swap(*new_data_column);
return true;
}
/// Saves column data to output stream.
void SaveBody(OutputStream* output) override {
ColumnLowCardinalityT<AdaptedColumnType>(this->template As<AdaptedColumnType>()).SaveBody(output);
}
};
}