clickhouse-sys 0.0.1

Static clickhouse-cpp bridge for the clickhouse-cxx workspace
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

#pragma once

#include "rust/cxx.h"

#include <cstdint>
#include <memory>
#include <string>
#include <vector>

#include "clickhouse/block.h"
#include "clickhouse/client.h"

namespace chcxx {

/// Owned handle around a clickhouse-cpp Block.
class BlockHandle {
public:
    BlockHandle();
    explicit BlockHandle(const clickhouse::Block& block);

    void append_column(rust::Str name, const class ColumnHandle& column);
    size_t column_count() const;
    size_t row_count() const;
    rust::String column_name(size_t index) const;
    int32_t column_type_code(size_t index) const;
    rust::String column_type_name(size_t index) const;
    std::shared_ptr<class ColumnHandle> column(size_t index) const;
    void clear();
    void reserve(size_t capacity);

    const clickhouse::Block& ref() const { return block_; }

private:
    clickhouse::Block block_;
};

/// Column owner with copy-on-write storage and stable immutable projections.
/// Rust mutations require a pinned exclusive borrow; independent handles detach
/// shared column trees before changing any vector or nested value.
class ColumnHandle {
public:
    explicit ColumnHandle(clickhouse::ColumnRef column);

    size_t size() const;
    int32_t type_code() const;
    rust::String type_name() const;
    void clear();
    void reserve(size_t capacity);
    size_t capacity() const;

    /// Flat bytes of a fixed-width column, using the native storage width.
    rust::Slice<const uint8_t> fixed_bytes() const;
    /// Bytes of one item, valid until the column is mutated.
    rust::Slice<const uint8_t> item_bytes(size_t index) const;
    void append_fixed(rust::Slice<const uint8_t> bytes);
    void append_column(const ColumnHandle& other);
    void append_string(rust::Slice<const uint8_t> value);
    void append_default();

    rust::Slice<const uint8_t> string_at(size_t index) const;
    size_t fixed_string_size() const;

    std::shared_ptr<ColumnHandle> nested() const;
    rust::Slice<const uint8_t> nulls() const;
    void append_nullable_flag(bool is_null);

    rust::Slice<const uint64_t> array_offsets() const;
    void array_append_row(const ColumnHandle& values);

    size_t tuple_len() const;
    std::shared_ptr<ColumnHandle> tuple_at(size_t index) const;
    void tuple_append_fixed(size_t index, rust::Slice<const uint8_t> bytes);
    void tuple_append_string(size_t index, rust::Slice<const uint8_t> value);

    void map_append_row(const ColumnHandle& keys, const ColumnHandle& values);
    std::shared_ptr<ColumnHandle> map_row(size_t index) const;
    void low_cardinality_append_string(rust::Slice<const uint8_t> value);
    void low_cardinality_append_i64(int64_t value);
    void low_cardinality_append_u64(uint64_t value);
    void geo_append_point(double x, double y);

    void nullable_append_fixed(rust::Slice<const uint8_t> bytes);
    void nullable_append_string(rust::Slice<const uint8_t> value);
    void nullable_append_column(const ColumnHandle& other);
    void nullable_append_default();

    const clickhouse::ColumnRef& ref() const { return column_; }

private:
    // Child adapters exist only within a parent mutation that detached the whole tree.
    ColumnHandle(clickhouse::ColumnRef column, bool detach_on_write);
    void prepare_mutation();
    clickhouse::ColumnRef column_;
    bool detach_on_write_ = true;
    mutable std::vector<uint8_t> cache_;
    mutable bool cache_valid_ = false;
};

/// Synchronous Native TCP client used by the integration tests.
class ClientHandle {
public:
    ClientHandle(rust::Str host, uint16_t port);

    void ping();
    void execute(rust::Str query);
    void insert(rust::Str table, const BlockHandle& block);
    std::unique_ptr<BlockHandle> select_one(rust::Str query);

private:
    clickhouse::Client client_;
};

/// Copy the complete column schema and values into independent storage.
clickhouse::ColumnRef clone_column_storage(const clickhouse::ColumnRef& column);
/// Whether independently owned handles share any publicly reachable column storage.
bool column_storage_shared(const clickhouse::ColumnRef& column, long owners = 1);
/// Detach a block from all shared column and nested-column storage before mutation.
void detach_block_storage(clickhouse::Block& block);

std::unique_ptr<BlockHandle> new_block_handle();
std::unique_ptr<ColumnHandle> new_column_handle(rust::Str type_name);
std::unique_ptr<ClientHandle> new_column_client(rust::Str host, uint16_t port);

}  // namespace chcxx