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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
|
#pragma once
#include <ydb/public/sdk/cpp/client/ydb_result/result.h>
#include <ydb/public/sdk/cpp/client/ydb_scheme/scheme.h>
#include <ydb/public/sdk/cpp/client/ydb_table/table.h>
#include <ydb/public/api/protos/draft/ydb_logstore.pb.h>
namespace Ydb::LogStore {
class Schema;
class Compression;
class CreateLogStoreRequest;
class CreateLogTableRequest;
class DescribeLogStoreResult;
class DescribeLogTableResult;
}
namespace NYdb::NLogStore {
using NTable::TTtlSettings;
using NTable::TAlterTtlSettings;
enum class EColumnCompression {
None,
LZ4,
ZSTD
};
enum EShardingHashType {
HASH_TYPE_UNSPECIFIED,
HASH_TYPE_MODULO_N,
HASH_TYPE_LOGS_SPECIAL,
};
struct TCompression {
EColumnCompression Codec = EColumnCompression::LZ4;
TMaybe<int> Level;
void SerializeTo(Ydb::LogStore::Compression& compression) const;
};
struct TCreateLogStoreSettings : public TOperationRequestSettings<TCreateLogStoreSettings> {
using TSelf = TCreateLogStoreSettings;
};
struct TDropLogStoreSettings : public TOperationRequestSettings<TDropLogStoreSettings> {
using TSelf = TDropLogStoreSettings;
};
struct TDescribeLogStoreSettings : public TOperationRequestSettings<TDescribeLogStoreSettings> {
using TSelf = TDescribeLogStoreSettings;
};
struct TAlterLogStoreSettings : public TOperationRequestSettings<TAlterLogStoreSettings> {
using TSelf = TAlterLogStoreSettings;
};
struct TCreateLogTableSettings : public TOperationRequestSettings<TCreateLogTableSettings> {
using TSelf = TCreateLogTableSettings;
};
struct TDropLogTableSettings : public TOperationRequestSettings<TDropLogTableSettings> {
using TSelf = TDropLogTableSettings;
};
struct TDescribeLogTableSettings : public TOperationRequestSettings<TDescribeLogTableSettings> {
using TSelf = TDescribeLogTableSettings;
};
struct TAlterLogTableSettings : public TOperationRequestSettings<TAlterLogTableSettings> {
using TSelf = TAlterLogTableSettings;
TSelf& AlterTtlSettings(const TMaybe<TAlterTtlSettings>& value);
const TMaybe<TAlterTtlSettings>& GetAlterTtlSettings() const;
private:
TMaybe<TAlterTtlSettings> AlterTtlSettings_;
};
TType MakeColumnType(EPrimitiveType primitiveType, bool notNull = false);
class TSchema {
public:
TSchema(const TVector<TColumn>& columns = {}, const TVector<TString> primaryKeyColumns = {},
const TCompression& defaultCompression = {})
: Columns(columns)
, PrimaryKeyColumns(primaryKeyColumns)
, DefaultCompression(defaultCompression)
{}
explicit TSchema(const Ydb::LogStore::Schema& schema);
void SerializeTo(Ydb::LogStore::Schema& schema) const;
TVector<TColumn> GetColumns() const {
return Columns;
}
const TVector<TString>& GetPrimaryKeyColumns() const {
return PrimaryKeyColumns;
}
const TCompression GetDefaultCompression() const {
return DefaultCompression;
}
private:
TVector<TColumn> Columns;
TVector<TString> PrimaryKeyColumns;
TCompression DefaultCompression;
};
class TLogStoreDescription {
public:
TLogStoreDescription(ui32 shardsCount, const THashMap<TString, TSchema>& schemaPresets);
TLogStoreDescription(Ydb::LogStore::DescribeLogStoreResult&& desc, const TDescribeLogStoreSettings& describeSettings);
void SerializeTo(Ydb::LogStore::CreateLogStoreRequest& request) const;
const THashMap<TString, TSchema>& GetSchemaPresets() const {
return SchemaPresets;
}
ui32 GetShardsCount() const {
return ShardsCount;
}
const TString& GetOwner() const {
return Owner;
}
const TVector<NScheme::TPermissions>& GetPermissions() const {
return Permissions;
}
const TVector<NScheme::TPermissions>& GetEffectivePermissions() const {
return EffectivePermissions;
}
private:
ui32 ShardsCount;
THashMap<TString, TSchema> SchemaPresets;
TString Owner;
TVector<NScheme::TPermissions> Permissions;
TVector<NScheme::TPermissions> EffectivePermissions;
};
struct TLogTableSharding {
EShardingHashType Type;
TVector<TString> Columns;
ui32 ShardsCount;
ui32 ActiveShardsCount;
TLogTableSharding(EShardingHashType type, const TVector<TString>& columns, ui32 shardsCount, ui32 activeShards = 0)
: Type(type)
, Columns(columns)
, ShardsCount(shardsCount)
, ActiveShardsCount(activeShards)
{}
TLogTableSharding(const Ydb::LogStore::DescribeLogTableResult& desc);
};
class TTieringSettings {
private:
TString TieringId;
public:
TTieringSettings(const TString& tieringId)
: TieringId(tieringId) {
}
void SerializeTo(Ydb::LogStore::TieringSettings& proto) const {
proto.set_tiering_id(TieringId);
}
};
class TLogTableDescription {
public:
TLogTableDescription(const TString& schemaPresetName, const TLogTableSharding& sharding);
TLogTableDescription(const TSchema& schema, const TLogTableSharding& sharding);
TLogTableDescription(Ydb::LogStore::DescribeLogTableResult&& desc, const TDescribeLogTableSettings& describeSettings);
void SerializeTo(Ydb::LogStore::CreateLogTableRequest& request) const;
const TSchema& GetSchema() const {
return Schema;
}
const TVector<TString>& GetShardingColumns() const {
return Sharding.Columns;
}
ui32 GetShardsCount() const {
return Sharding.ShardsCount;
}
const TMaybe<TTtlSettings>& GetTtlSettings() const {
return TtlSettings;
}
const TString& GetOwner() const {
return Owner;
}
const TVector<NScheme::TPermissions>& GetPermissions() const {
return Permissions;
}
const TVector<NScheme::TPermissions>& GetEffectivePermissions() const {
return EffectivePermissions;
}
TLogTableDescription& SetTtlSettings(const TTtlSettings& settings) {
TtlSettings = settings;
return *this;
}
TLogTableDescription& SetTieringSettings(const TTieringSettings& settings) {
TieringSettings = settings;
return *this;
}
private:
const TString SchemaPresetName;
const TSchema Schema;
const TLogTableSharding Sharding;
TMaybe<TTtlSettings> TtlSettings;
TMaybe<TTieringSettings> TieringSettings;
TString Owner;
TVector<NScheme::TPermissions> Permissions;
TVector<NScheme::TPermissions> EffectivePermissions;
};
//! Represents result of DescribeLogStore call
class TDescribeLogStoreResult : public TStatus {
public:
TDescribeLogStoreResult(TStatus&& status, Ydb::LogStore::DescribeLogStoreResult&& desc,
const TDescribeLogStoreSettings& describeSettings);
const TLogStoreDescription& GetDescription() const {
return LogStoreDescription_;
}
private:
TLogStoreDescription LogStoreDescription_;
};
//! Represents result of DescribeLogTable call
class TDescribeLogTableResult : public TStatus {
public:
TDescribeLogTableResult(TStatus&& status, Ydb::LogStore::DescribeLogTableResult&& desc,
const TDescribeLogTableSettings& describeSettings);
TLogTableDescription GetDescription() const {
return LogTableDescription_;
}
private:
TLogTableDescription LogTableDescription_;
};
using TAsyncDescribeLogStoreResult = NThreading::TFuture<TDescribeLogStoreResult>;
using TAsyncDescribeLogTableResult = NThreading::TFuture<TDescribeLogTableResult>;
class TLogStoreClient {
class TImpl;
public:
TLogStoreClient(const TDriver& driver, const TCommonClientSettings& settings = TCommonClientSettings());
TAsyncStatus CreateLogStore(const TString& path, TLogStoreDescription&& tableDesc,
const TCreateLogStoreSettings& settings = TCreateLogStoreSettings());
TAsyncDescribeLogStoreResult DescribeLogStore(const TString& path,
const TDescribeLogStoreSettings& settings = TDescribeLogStoreSettings());
TAsyncStatus DropLogStore(const TString& path, const TDropLogStoreSettings& settings = TDropLogStoreSettings());
TAsyncStatus AlterLogStore(const TString& path, const TAlterLogStoreSettings& settings = TAlterLogStoreSettings());
TAsyncStatus CreateLogTable(const TString& path, TLogTableDescription&& tableDesc,
const TCreateLogTableSettings& settings = TCreateLogTableSettings());
TAsyncDescribeLogTableResult DescribeLogTable(const TString& path,
const TDescribeLogTableSettings& settings = TDescribeLogTableSettings());
TAsyncStatus DropLogTable(const TString& path, const TDropLogTableSettings& settings = TDropLogTableSettings());
TAsyncStatus AlterLogTable(const TString& path, const TAlterLogTableSettings& settings = TAlterLogTableSettings());
private:
std::shared_ptr<TImpl> Impl_;
};
}
|
