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.
246 lines
7.3 KiB
C++
246 lines
7.3 KiB
C++
#pragma once
|
|
|
|
#include "decimal.h"
|
|
#include "numeric.h"
|
|
|
|
#include <ctime>
|
|
|
|
namespace datastore {
|
|
|
|
/** */
|
|
class ColumnDate : public Column {
|
|
public:
|
|
using ValueType = std::time_t;
|
|
|
|
ColumnDate();
|
|
explicit ColumnDate(std::vector<uint16_t>&& data);
|
|
|
|
/// Appends one element to the end of column.
|
|
/// The implementation is fundamentally wrong, ignores timezones, leap years and daylight saving.
|
|
void Append(const std::time_t& value);
|
|
|
|
/// Returns element at given row number.
|
|
/// The implementation is fundamentally wrong, ignores timezones, leap years and daylight saving.
|
|
std::time_t At(size_t n) const;
|
|
inline std::time_t operator [] (size_t n) const { return At(n); }
|
|
|
|
/// Do append data as is -- number of day in Unix epoch, no conversions performed.
|
|
void AppendRaw(uint16_t value);
|
|
uint16_t RawAt(size_t n) const;
|
|
|
|
/// Appends content of given column to the end of current one.
|
|
void Append(ColumnRef column) override;
|
|
|
|
/// Get Raw Vector Contents
|
|
std::vector<uint16_t>& GetWritableData();
|
|
|
|
/// Increase the capacity of the column for large block insertion.
|
|
void Reserve(size_t new_cap) override;
|
|
|
|
/// Returns the capacity of the column
|
|
size_t Capacity() const;
|
|
|
|
/// Loads column data from input stream.
|
|
bool LoadBody(InputStream* input, size_t rows) override;
|
|
|
|
/// Saves column data to output stream.
|
|
void SaveBody(OutputStream* output) override;
|
|
|
|
/// Clear column data .
|
|
void Clear() override;
|
|
|
|
/// Returns count of rows in the column.
|
|
size_t Size() const override;
|
|
|
|
/// Makes slice of the current column.
|
|
ColumnRef Slice(size_t begin, size_t len) const override;
|
|
ColumnRef CloneEmpty() const override;
|
|
void Swap(Column& other) override;
|
|
|
|
ItemView GetItem(size_t index) const override;
|
|
|
|
private:
|
|
std::shared_ptr<ColumnUInt16> data_;
|
|
};
|
|
|
|
|
|
class ColumnDate32 : public Column {
|
|
public:
|
|
using ValueType = std::time_t;
|
|
|
|
ColumnDate32();
|
|
explicit ColumnDate32(std::vector<int32_t>&& data);
|
|
|
|
/// Appends one element to the end of column.
|
|
/// The implementation is fundamentally wrong, ignores timezones, leap years and daylight saving.
|
|
void Append(const std::time_t& value);
|
|
|
|
/// Returns element at given row number.
|
|
/// The implementation is fundamentally wrong, ignores timezones, leap years and daylight saving.
|
|
std::time_t At(size_t n) const;
|
|
|
|
inline std::time_t operator [] (size_t n) const { return At(n); }
|
|
|
|
/// Do append data as is -- number of day in Unix epoch (32bit signed), no conversions performed.
|
|
void AppendRaw(int32_t value);
|
|
int32_t RawAt(size_t n) const;
|
|
|
|
/// Get Raw Vector Contents
|
|
std::vector<int32_t>& GetWritableData();
|
|
|
|
/// Returns the capacity of the column
|
|
size_t Capacity() const;
|
|
|
|
public:
|
|
/// Increase the capacity of the column for large block insertion.
|
|
void Reserve(size_t new_cap) override;
|
|
|
|
/// Appends content of given column to the end of current one.
|
|
void Append(ColumnRef column) override;
|
|
|
|
/// Loads column data from input stream.
|
|
bool LoadBody(InputStream* input, size_t rows) override;
|
|
|
|
/// Saves column data to output stream.
|
|
void SaveBody(OutputStream* output) override;
|
|
|
|
/// Clear column data .
|
|
void Clear() override;
|
|
|
|
/// Returns count of rows in the column.
|
|
size_t Size() const override;
|
|
|
|
/// Makes slice of the current column.
|
|
ColumnRef Slice(size_t begin, size_t len) const override;
|
|
ColumnRef CloneEmpty() const override;
|
|
void Swap(Column& other) override;
|
|
|
|
ItemView GetItem(size_t index) const override;
|
|
|
|
private:
|
|
std::shared_ptr<ColumnInt32> data_;
|
|
};
|
|
|
|
|
|
/** DateTime64 supports date-time values (number of seconds since UNIX epoch), from 1970 up to 2130. */
|
|
class ColumnDateTime : public Column {
|
|
public:
|
|
using ValueType = std::time_t;
|
|
|
|
ColumnDateTime();
|
|
explicit ColumnDateTime(std::vector<uint32_t>&& data);
|
|
|
|
explicit ColumnDateTime(std::string timezone);
|
|
ColumnDateTime(std::string timezone, std::vector<uint32_t>&& data);
|
|
|
|
/// Appends one element to the end of column.
|
|
void Append(const std::time_t& value);
|
|
|
|
/// Returns element at given row number.
|
|
std::time_t At(size_t n) const;
|
|
inline std::time_t operator [] (size_t n) const { return At(n); }
|
|
|
|
/// Append raw as UNIX epoch seconds in uint32
|
|
void AppendRaw(uint32_t value);
|
|
uint32_t RawAt(size_t n) const;
|
|
|
|
/// Timezone associated with a data column.
|
|
std::string Timezone() const;
|
|
|
|
/// Get Raw Vector Contents
|
|
std::vector<uint32_t>& GetWritableData();
|
|
|
|
/// Returns the capacity of the column
|
|
size_t Capacity() const;
|
|
|
|
public:
|
|
/// Increase the capacity of the column for large block insertion.
|
|
void Reserve(size_t new_cap) override;
|
|
|
|
/// Appends content of given column to the end of current one.
|
|
void Append(ColumnRef column) override;
|
|
|
|
/// Loads column data from input stream.
|
|
bool LoadBody(InputStream* input, size_t rows) override;
|
|
|
|
/// Clear column data .
|
|
void Clear() override;
|
|
|
|
/// Saves column data to output stream.
|
|
void SaveBody(OutputStream* output) override;
|
|
|
|
/// Returns count of rows in the column.
|
|
size_t Size() const override;
|
|
|
|
/// Makes slice of the current column.
|
|
ColumnRef Slice(size_t begin, size_t len) const override;
|
|
ColumnRef CloneEmpty() const override;
|
|
void Swap(Column& other) override;
|
|
|
|
ItemView GetItem(size_t index) const override;
|
|
|
|
private:
|
|
std::shared_ptr<ColumnUInt32> data_;
|
|
};
|
|
|
|
|
|
/** DateTime64 supports date-time values of arbitrary sub-second precision, from 1900 up to 2300. */
|
|
class ColumnDateTime64 : public Column {
|
|
public:
|
|
using ValueType = Int64;
|
|
|
|
explicit ColumnDateTime64(size_t precision);
|
|
ColumnDateTime64(size_t precision, std::string timezone);
|
|
|
|
/// Appends one element to the end of column.
|
|
void Append(const Int64& value);
|
|
// It is a bit controversial: users might expect it to parse string of ISO8601 or some other human-friendly format,
|
|
// but current implementation parses it as fractional integer with decimal point, e.g. "123.456".
|
|
// void Append(const std::string& value);
|
|
|
|
/// Returns element at given row number.
|
|
Int64 At(size_t n) const;
|
|
|
|
inline Int64 operator[](size_t n) const { return At(n); }
|
|
|
|
/// Timezone associated with a data column.
|
|
std::string Timezone() const;
|
|
|
|
public:
|
|
/// Increase the capacity of the column for large block insertion.
|
|
void Reserve(size_t new_cap) override;
|
|
|
|
/// Appends content of given column to the end of current one.
|
|
void Append(ColumnRef column) override;
|
|
|
|
/// Loads column data from input stream.
|
|
bool LoadBody(InputStream* input, size_t rows) override;
|
|
|
|
/// Clear column data .
|
|
void Clear() override;
|
|
|
|
/// Saves column data to output stream.
|
|
void SaveBody(OutputStream* output) override;
|
|
|
|
/// Returns count of rows in the column.
|
|
size_t Size() const override;
|
|
|
|
/// Makes slice of the current column.
|
|
ColumnRef Slice(size_t begin, size_t len) const override;
|
|
ColumnRef CloneEmpty() const override;
|
|
void Swap(Column& other) override;
|
|
|
|
ItemView GetItem(size_t index) const override;
|
|
|
|
size_t GetPrecision() const;
|
|
|
|
private:
|
|
ColumnDateTime64(TypeRef type, std::shared_ptr<ColumnDecimal> data);
|
|
|
|
private:
|
|
std::shared_ptr<ColumnDecimal> data_;
|
|
const size_t precision_;
|
|
};
|
|
|
|
}
|