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.
106 lines
3.9 KiB
C++
106 lines
3.9 KiB
C++
#include <gtest/gtest.h>
|
|
#include <algorithm>
|
|
#include <iterator>
|
|
#include <vector>
|
|
|
|
#include <datastore/columns/array.h>
|
|
#include <datastore/columns/string.h>
|
|
#include <datastore/columns/lowcardinality.h>
|
|
#include "datastore/block.h"
|
|
#include "datastore/client.h"
|
|
#include "utils.h"
|
|
#include "datastore/base/buffer.h"
|
|
#include "datastore/base/output.h"
|
|
|
|
namespace
|
|
{
|
|
using namespace datastore;
|
|
}
|
|
|
|
std::shared_ptr<ColumnArray> buildTestColumn(const std::vector<std::vector<std::string>>& rows) {
|
|
auto arrayColumn = std::make_shared<ColumnArray>(std::make_shared<ColumnLowCardinalityT<ColumnString>>());
|
|
|
|
for (const auto& row : rows) {
|
|
auto column = std::make_shared<ColumnLowCardinalityT<ColumnString>>();
|
|
|
|
for (const auto& string : row) {
|
|
column->Append(string);
|
|
}
|
|
|
|
arrayColumn->AppendAsColumn(column);
|
|
}
|
|
|
|
return arrayColumn;
|
|
}
|
|
|
|
TEST(ArrayOfLowCardinality, Serialization) {
|
|
const auto inputColumn = buildTestColumn({
|
|
{ "aa", "bb" },
|
|
{ "cc" }
|
|
});
|
|
|
|
// The serialization data was extracted from a successful insert.
|
|
// When compared to what Datastore/NativeWriter does for the same fields, the only differences are the index type and indexes.
|
|
// Since we are setting a different index type in datastore-cpp, it's expected to have different indexes.
|
|
const std::vector<uint8_t> expectedSerialization {
|
|
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x61, 0x61,
|
|
0x02, 0x62, 0x62, 0x02, 0x63, 0x63, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
|
|
0x03, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
Buffer buf;
|
|
|
|
BufferOutput output(&buf);
|
|
inputColumn->Save(&output);
|
|
output.Flush();
|
|
|
|
ASSERT_EQ(expectedSerialization, buf);
|
|
}
|
|
|
|
TEST(ArrayOfLowCardinality, InsertAndQuery) {
|
|
|
|
const auto localHostEndpoint = ClientOptions()
|
|
.SetHost( getEnvOrDefault("DATASTORE_HOST", "localhost"))
|
|
.SetPort( getEnvOrDefault<size_t>("DATASTORE_PORT", "9000"))
|
|
.SetUser( getEnvOrDefault("DATASTORE_USER", "default"))
|
|
.SetPassword( getEnvOrDefault("DATASTORE_PASSWORD", ""))
|
|
.SetDefaultDatabase(getEnvOrDefault("DATASTORE_DB", "default"));
|
|
|
|
Client client(ClientOptions(localHostEndpoint)
|
|
.SetPingBeforeQuery(true));
|
|
|
|
const auto testData = std::vector<std::vector<std::string>> {
|
|
{ "aa", "bb" },
|
|
{},
|
|
{ "cc" },
|
|
{}
|
|
};
|
|
|
|
auto column = buildTestColumn(testData);
|
|
|
|
Block block;
|
|
block.AppendColumn("arr", column);
|
|
|
|
client.Execute("DROP TEMPORARY TABLE IF EXISTS array_lc");
|
|
client.Execute("CREATE TEMPORARY TABLE IF NOT EXISTS array_lc (arr Array(LowCardinality(String))) ENGINE = Memory");
|
|
client.Insert("array_lc", block);
|
|
|
|
client.Select("SELECT * FROM array_lc", [&](const Block& bl) {
|
|
for (size_t c = 0; c < bl.GetRowCount(); ++c) {
|
|
auto col = bl[0]->As<ColumnArray>()->GetAsColumn(c);
|
|
for (size_t i = 0; i < col->Size(); ++i) {
|
|
if (auto string_column = col->As<ColumnString>()) {
|
|
const auto string = string_column->At(i);
|
|
ASSERT_EQ(testData[c][i], string);
|
|
} else if (auto lc_string_column = col->As<ColumnLowCardinalityT<ColumnString>>()) {
|
|
const auto string = lc_string_column->At(i);
|
|
ASSERT_EQ(testData[c][i], string);
|
|
} else {
|
|
FAIL() << "Unexpected column type: " << col->Type()->GetName();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|