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.
256 lines
7.0 KiB
C++
256 lines
7.0 KiB
C++
#include "decimal.h"
|
|
|
|
namespace
|
|
{
|
|
using namespace datastore;
|
|
|
|
#ifdef ABSL_HAVE_INTRINSIC_INT128
|
|
template <typename T>
|
|
inline bool addOverflow(const Int128 & l, const T & r, Int128 * result)
|
|
{
|
|
__int128 res;
|
|
const auto ret_value = __builtin_add_overflow(static_cast<__int128>(l), static_cast<__int128>(r), &res);
|
|
|
|
*result = res;
|
|
return ret_value;
|
|
}
|
|
|
|
template <typename T>
|
|
inline bool mulOverflow(const Int128 & l, const T & r, Int128 * result)
|
|
{
|
|
__int128 res;
|
|
const auto ret_value = __builtin_mul_overflow(static_cast<__int128>(l), static_cast<__int128>(r), &res);
|
|
|
|
*result = res;
|
|
return ret_value;
|
|
}
|
|
|
|
#else
|
|
template <typename T>
|
|
inline bool getSignBit(const T & v)
|
|
{
|
|
return v < static_cast<T>(0);
|
|
}
|
|
|
|
inline bool getSignBit(const Int128 & v)
|
|
{
|
|
// static constexpr Int128 zero {};
|
|
// return v < zero;
|
|
|
|
// Sign of the whole absl::int128 value is determined by sign of higher 64 bits.
|
|
return absl::Int128High64(v) < 0;
|
|
}
|
|
|
|
inline bool addOverflow(const Int128 & l, const Int128 & r, Int128 * result)
|
|
{
|
|
// *result = l + r;
|
|
// const auto result_sign = getSignBit(*result);
|
|
// return l_sign == r_sign && l_sign != result_sign;
|
|
|
|
// Based on code from:
|
|
// https://wiki.sei.cmu.edu/confluence/display/c/INT32-C.+Ensure+that+operations+on+signed+integers+do+not+result+in+overflow#INT32C.Ensurethatoperationsonsignedintegersdonotresultinoverflow-CompliantSolution
|
|
const auto r_positive = !getSignBit(r);
|
|
|
|
if ((r_positive && (l > (std::numeric_limits<Int128>::max() - r))) ||
|
|
(!r_positive && (l < (std::numeric_limits<Int128>::min() - r)))) {
|
|
return true;
|
|
}
|
|
*result = l + r;
|
|
|
|
return false;
|
|
}
|
|
|
|
template <typename T>
|
|
inline bool mulOverflow(const Int128 & l, const T & r, Int128 * result)
|
|
{
|
|
// Based on code from:
|
|
// https://wiki.sei.cmu.edu/confluence/display/c/INT32-C.+Ensure+that+operations+on+signed+integers+do+not+result+in+overflow#INT32C.Ensurethatoperationsonsignedintegersdonotresultinoverflow-CompliantSolution.3
|
|
const auto l_positive = !getSignBit(l);
|
|
const auto r_positive = !getSignBit(r);
|
|
|
|
if (l_positive) {
|
|
if (r_positive) {
|
|
if (r != 0 && l > (std::numeric_limits<Int128>::max() / r)) {
|
|
return true;
|
|
}
|
|
} else {
|
|
if (l != 0 && r < (std::numeric_limits<Int128>::min() / l)) {
|
|
return true;
|
|
}
|
|
}
|
|
} else {
|
|
if (r_positive) {
|
|
if (r != 0 && l < (std::numeric_limits<Int128>::min() / r)) {
|
|
return true;
|
|
}
|
|
} else {
|
|
if (l != 0 && (r < (std::numeric_limits<Int128>::max() / l))) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
*result = l * r;
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
namespace datastore {
|
|
|
|
ColumnDecimal::ColumnDecimal(size_t precision, size_t scale)
|
|
: Column(Type::CreateDecimal(precision, scale))
|
|
{
|
|
if (precision <= 9) {
|
|
data_ = std::make_shared<ColumnInt32>();
|
|
} else if (precision <= 18) {
|
|
data_ = std::make_shared<ColumnInt64>();
|
|
} else {
|
|
data_ = std::make_shared<ColumnInt128>();
|
|
}
|
|
data_type_code_ = data_->Type()->GetCode();
|
|
}
|
|
|
|
ColumnDecimal::ColumnDecimal(TypeRef type, ColumnRef data)
|
|
: Column(type),
|
|
data_(data),
|
|
data_type_code_(data_->Type()->GetCode())
|
|
{
|
|
}
|
|
|
|
void ColumnDecimal::Append(const Int128& value) {
|
|
switch (data_type_code_) {
|
|
case Type::Int32:
|
|
static_cast<ColumnInt32*>(data_.get())->Append(static_cast<int32_t>(value));
|
|
break;
|
|
case Type::Int64:
|
|
static_cast<ColumnInt64*>(data_.get())->Append(static_cast<int64_t>(value));
|
|
break;
|
|
default:
|
|
static_cast<ColumnInt128*>(data_.get())->Append(static_cast<Int128>(value));
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ColumnDecimal::Append(const std::string& value) {
|
|
Int128 int_value = 0;
|
|
auto c = value.begin();
|
|
auto end = value.end();
|
|
bool sign = true;
|
|
bool has_dot = false;
|
|
|
|
size_t zeros = 0;
|
|
|
|
while (c != end) {
|
|
if (*c == '-') {
|
|
sign = false;
|
|
if (c != value.begin()) {
|
|
break;
|
|
}
|
|
} else if (*c == '.' && !has_dot) {
|
|
size_t distance = std::distance(c, end) - 1;
|
|
auto scale = type_->As<DecimalType>()->GetScale();
|
|
|
|
if (distance <= scale) {
|
|
zeros = scale - distance;
|
|
} else {
|
|
std::advance(end, scale - distance);
|
|
}
|
|
|
|
has_dot = true;
|
|
} else if (*c >= '0' && *c <= '9') {
|
|
if (mulOverflow(int_value, 10, &int_value) ||
|
|
addOverflow(int_value, *c - '0', &int_value)) {
|
|
throw AssertionError("value is too big for 128-bit integer");
|
|
}
|
|
} else {
|
|
throw ValidationError(std::string("unexpected symbol '") + (*c) + "' in decimal value");
|
|
}
|
|
++c;
|
|
}
|
|
|
|
if (c != end) {
|
|
throw ValidationError("unexpected symbol '-' in decimal value");
|
|
}
|
|
|
|
while (zeros) {
|
|
if (mulOverflow(int_value, 10, &int_value)) {
|
|
throw AssertionError("value is too big for 128-bit integer");
|
|
}
|
|
--zeros;
|
|
}
|
|
|
|
Append(sign ? int_value : -int_value);
|
|
}
|
|
|
|
Int128 ColumnDecimal::At(size_t i) const {
|
|
switch (data_type_code_) {
|
|
case Type::Int32:
|
|
return static_cast<Int128>(static_cast<const ColumnInt32*>(data_.get())->At(i));
|
|
case Type::Int64:
|
|
return static_cast<Int128>(static_cast<const ColumnInt64*>(data_.get())->At(i));
|
|
case Type::Int128:
|
|
return static_cast<const ColumnInt128*>(data_.get())->At(i);
|
|
default:
|
|
throw ValidationError("Invalid data_ column type in ColumnDecimal");
|
|
}
|
|
}
|
|
|
|
void ColumnDecimal::Reserve(size_t new_cap) {
|
|
data_->Reserve(new_cap);
|
|
}
|
|
|
|
void ColumnDecimal::Append(ColumnRef column) {
|
|
if (auto col = column->As<ColumnDecimal>()) {
|
|
data_->Append(col->data_);
|
|
}
|
|
}
|
|
|
|
bool ColumnDecimal::LoadBody(InputStream * input, size_t rows) {
|
|
return data_->LoadBody(input, rows);
|
|
}
|
|
|
|
void ColumnDecimal::SaveBody(OutputStream* output) {
|
|
data_->SaveBody(output);
|
|
}
|
|
|
|
void ColumnDecimal::Clear() {
|
|
data_->Clear();
|
|
}
|
|
|
|
size_t ColumnDecimal::Size() const {
|
|
return data_->Size();
|
|
}
|
|
|
|
ColumnRef ColumnDecimal::Slice(size_t begin, size_t len) const {
|
|
// coundn't use std::make_shared since this c-tor is private
|
|
return ColumnRef{new ColumnDecimal(type_, data_->Slice(begin, len))};
|
|
}
|
|
|
|
ColumnRef ColumnDecimal::CloneEmpty() const {
|
|
// coundn't use std::make_shared since this c-tor is private
|
|
return ColumnRef{new ColumnDecimal(type_, data_->CloneEmpty())};
|
|
}
|
|
|
|
void ColumnDecimal::Swap(Column& other) {
|
|
auto & col = dynamic_cast<ColumnDecimal &>(other);
|
|
data_.swap(col.data_);
|
|
}
|
|
|
|
ItemView ColumnDecimal::GetItem(size_t index) const {
|
|
return ItemView{GetType().GetCode(), data_->GetItem(index)};
|
|
}
|
|
|
|
size_t ColumnDecimal::GetScale() const
|
|
{
|
|
return type_->As<DecimalType>()->GetScale();
|
|
}
|
|
|
|
size_t ColumnDecimal::GetPrecision() const
|
|
{
|
|
return type_->As<DecimalType>()->GetPrecision();
|
|
}
|
|
|
|
}
|