Skip to content

Commit b5fa0c4

Browse files
gty404gty404
committed
rename some class name and fix comments
1 parent 47586de commit b5fa0c4

File tree

11 files changed

+255
-201
lines changed

11 files changed

+255
-201
lines changed

‎src/iceberg/CMakeLists.txt‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -59,8 +59,6 @@ set(ICEBERG_SOURCES
5959
transform.cc
6060
transform_function.cc
6161
type.cc
62-
update_requirement.cc
63-
update_requirements.cc
6462
util/conversions.cc
6563
util/decimal.cc
6664
util/gzip_internal.cc

‎src/iceberg/meson.build‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -74,7 +74,10 @@ iceberg_sources = files(
7474
'table.cc',
7575
'table_metadata.cc',
7676
'table_properties.cc',
77+
'table_requirement.cc',
78+
'table_requirements.cc',
7779
'table_scan.cc',
80+
'table_update.cc',
7881
'transform.cc',
7982
'transform_function.cc',
8083
'type.cc',
@@ -169,7 +172,10 @@ install_headers(
169172
'table.h',
170173
'table_identifier.h',
171174
'table_metadata.h',
175+
'table_requirement.h',
176+
'table_requirements.h',
172177
'table_scan.h',
178+
'table_update.h',
173179
'transaction.h',
174180
'transform_function.h',
175181
'transform.h',

‎src/iceberg/table_metadata.cc‎

Lines changed: 40 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,8 @@
2525

2626
#include <nlohmann/json.hpp>
2727

28+
#include "../../build/_deps/fmt-src/include/fmt/color.h"
29+
#include "iceberg/exception.h"
2830
#include "iceberg/file_io.h"
2931
#include "iceberg/json_internal.h"
3032
#include "iceberg/partition_spec.h"
@@ -228,152 +230,157 @@ std::unique_ptr<TableMetadataBuilder> TableMetadataBuilder::BuildFrom(
228230

229231
TableMetadataBuilder& TableMetadataBuilder::SetMetadataLocation(
230232
std::string_view metadata_location) {
231-
return *this;
233+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
232234
}
233235

234236
TableMetadataBuilder& TableMetadataBuilder::SetPreviousMetadataLocation(
235237
std::string_view previous_metadata_location) {
236-
return *this;
238+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
237239
}
238240

239-
TableMetadataBuilder& TableMetadataBuilder::AssignUUID() { return *this; }
241+
TableMetadataBuilder& TableMetadataBuilder::AssignUUID() {
242+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
243+
}
240244

241245
TableMetadataBuilder& TableMetadataBuilder::AssignUUID(std::string_view uuid) {
242-
return *this;
246+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
247+
;
243248
}
244249

245250
TableMetadataBuilder& TableMetadataBuilder::UpgradeFormatVersion(
246251
int8_t new_format_version) {
247-
return *this;
252+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
248253
}
249254

250255
TableMetadataBuilder& TableMetadataBuilder::SetCurrentSchema(
251256
std::shared_ptr<Schema> schema, int32_t new_last_column_id) {
252-
return *this;
257+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
253258
}
254259

255260
TableMetadataBuilder& TableMetadataBuilder::SetCurrentSchema(int32_t schema_id) {
256-
return *this;
261+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
257262
}
258263

259264
TableMetadataBuilder& TableMetadataBuilder::AddSchema(std::shared_ptr<Schema> schema) {
260-
return *this;
265+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
261266
}
262267

263268
TableMetadataBuilder& TableMetadataBuilder::SetDefaultPartitionSpec(
264269
std::shared_ptr<PartitionSpec> spec) {
265-
return *this;
270+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
266271
}
267272

268273
TableMetadataBuilder& TableMetadataBuilder::SetDefaultPartitionSpec(int32_t spec_id) {
269-
return *this;
274+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
270275
}
271276

272277
TableMetadataBuilder& TableMetadataBuilder::AddPartitionSpec(
273278
std::shared_ptr<PartitionSpec> spec) {
274-
return *this;
279+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
275280
}
276281

277282
TableMetadataBuilder& TableMetadataBuilder::RemovePartitionSpecs(
278283
const std::vector<int32_t>& spec_ids) {
279-
return *this;
284+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
280285
}
281286

282287
TableMetadataBuilder& TableMetadataBuilder::RemoveSchemas(
283288
const std::vector<int32_t>& schema_ids) {
284-
return *this;
289+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
285290
}
286291

287292
TableMetadataBuilder& TableMetadataBuilder::SetDefaultSortOrder(
288293
std::shared_ptr<SortOrder> order) {
289-
return *this;
294+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
290295
}
291296

292297
TableMetadataBuilder& TableMetadataBuilder::SetDefaultSortOrder(int32_t order_id) {
293-
return *this;
298+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
294299
}
295300

296301
TableMetadataBuilder& TableMetadataBuilder::AddSortOrder(
297302
std::shared_ptr<SortOrder> order) {
298-
return *this;
303+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
299304
}
300305

301306
TableMetadataBuilder& TableMetadataBuilder::AddSnapshot(
302307
std::shared_ptr<Snapshot> snapshot) {
303-
return *this;
308+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
304309
}
305310

306311
TableMetadataBuilder& TableMetadataBuilder::SetBranchSnapshot(int64_t snapshot_id,
307312
const std::string& branch) {
308-
return *this;
313+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
309314
}
310315

311316
TableMetadataBuilder& TableMetadataBuilder::SetRef(const std::string& name,
312317
std::shared_ptr<SnapshotRef> ref) {
313-
return *this;
318+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
314319
}
315320

316321
TableMetadataBuilder& TableMetadataBuilder::RemoveRef(const std::string& name) {
317-
return *this;
322+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
318323
}
319324

320325
TableMetadataBuilder& TableMetadataBuilder::RemoveSnapshots(
321326
const std::vector<std::shared_ptr<Snapshot>>& snapshots_to_remove) {
322-
return *this;
327+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
323328
}
324329

325330
TableMetadataBuilder& TableMetadataBuilder::RemoveSnapshots(
326331
const std::vector<int64_t>& snapshot_ids) {
327-
return *this;
332+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
328333
}
329334

330335
TableMetadataBuilder& TableMetadataBuilder::suppressHistoricalSnapshots() {
331-
return *this;
336+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
332337
}
333338

334339
TableMetadataBuilder& TableMetadataBuilder::SetStatistics(
335340
const std::shared_ptr<StatisticsFile>& statistics_file) {
336-
return *this;
341+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
337342
}
338343

339344
TableMetadataBuilder& TableMetadataBuilder::RemoveStatistics(int64_t snapshot_id) {
340-
return *this;
345+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
341346
}
342347

343348
TableMetadataBuilder& TableMetadataBuilder::SetPartitionStatistics(
344349
const std::shared_ptr<PartitionStatisticsFile>& partition_statistics_file) {
345-
return *this;
350+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
346351
}
347352

348353
TableMetadataBuilder& TableMetadataBuilder::RemovePartitionStatistics(
349354
int64_t snapshot_id) {
350-
return *this;
355+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
351356
}
352357

353358
TableMetadataBuilder& TableMetadataBuilder::SetProperties(
354359
const std::unordered_map<std::string, std::string>& updated) {
355-
return *this;
360+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
356361
}
357362

358363
TableMetadataBuilder& TableMetadataBuilder::RemoveProperties(
359364
const std::vector<std::string>& removed) {
360-
return *this;
365+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
361366
}
362367

363368
TableMetadataBuilder& TableMetadataBuilder::SetLocation(std::string_view location) {
364-
return *this;
369+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
365370
}
366371

367372
TableMetadataBuilder& TableMetadataBuilder::AddEncryptionKey(
368373
std::shared_ptr<EncryptedKey> key) {
369-
return *this;
374+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
370375
}
371376

372377
TableMetadataBuilder& TableMetadataBuilder::RemoveEncryptionKey(std::string_view key_id) {
373-
return *this;
378+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
374379
}
375380

376-
TableMetadataBuilder& TableMetadataBuilder::DiscardChanges() { return *this; }
381+
TableMetadataBuilder& TableMetadataBuilder::DiscardChanges() {
382+
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
383+
}
377384

378385
Result<std::unique_ptr<TableMetadata>> TableMetadataBuilder::Build() {
379386
return NotImplemented("TableMetadataBuilder::Build not implemented");

‎src/iceberg/table_requirement.cc‎

Lines changed: 15 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -31,28 +31,31 @@ Status AssertTableUUID::Validate(const TableMetadata* base) const {
3131
return NotImplemented("AssertTableUUID::Validate not implemented");
3232
}
3333

34-
Status AssertRefSnapshotID::Validate(const TableMetadata* base) const {
35-
return NotImplemented("AssertRefSnapshotID::Validate not implemented");
34+
Status AssertTableRefSnapshotID::Validate(const TableMetadata* base) const {
35+
return NotImplemented("AssertTableRefSnapshotID::Validate not implemented");
3636
}
3737

38-
Status AssertLastAssignedFieldId::Validate(const TableMetadata* base) const {
39-
return NotImplemented("AssertLastAssignedFieldId::Validate not implemented");
38+
Status AssertCurrentTableLastAssignedFieldId::Validate(const TableMetadata* base) const {
39+
return NotImplemented(
40+
"AssertCurrentTableLastAssignedFieldId::Validate not implemented");
4041
}
4142

42-
Status AssertCurrentSchemaID::Validate(const TableMetadata* base) const {
43-
return NotImplemented("AssertCurrentSchemaID::Validate not implemented");
43+
Status AssertCurrentTableSchemaID::Validate(const TableMetadata* base) const {
44+
return NotImplemented("AssertCurrentTableSchemaID::Validate not implemented");
4445
}
4546

46-
Status AssertLastAssignedPartitionId::Validate(const TableMetadata* base) const {
47-
return NotImplemented("AssertLastAssignedPartitionId::Validate not implemented");
47+
Status AssertCurrentTableLastAssignedPartitionId::Validate(
48+
const TableMetadata* base) const {
49+
return NotImplemented(
50+
"AssertCurrentTableLastAssignedPartitionId::Validate not implemented");
4851
}
4952

50-
Status AssertDefaultSpecID::Validate(const TableMetadata* base) const {
51-
return NotImplemented("AssertDefaultSpecID::Validate not implemented");
53+
Status AssertDefaultTableSpecID::Validate(const TableMetadata* base) const {
54+
return NotImplemented("AssertDefaultTableSpecID::Validate not implemented");
5255
}
5356

54-
Status AssertDefaultSortOrderID::Validate(const TableMetadata* base) const {
55-
return NotImplemented("AssertDefaultSortOrderID::Validate not implemented");
57+
Status AssertDefaultTableSortOrderID::Validate(const TableMetadata* base) const {
58+
return NotImplemented("AssertDefaultTableSortOrderID::Validate not implemented");
5659
}
5760

5861
} // namespace iceberg

‎src/iceberg/table_requirement.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@
3333
#include "iceberg/result.h"
3434
#include "iceberg/type_fwd.h"
3535

36-
namespace iceberg {
36+
namespace iceberg {
3737

3838
/// \brief Base class for update requirement operations
3939
///

‎src/iceberg/table_requirements.cc‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -19,18 +19,18 @@
1919

2020
#include "iceberg/table_requirements.h"
2121

22+
#include "iceberg/exception.h"
2223
#include "iceberg/table_metadata.h"
2324
#include "iceberg/table_update.h"
2425

2526
namespace iceberg {
2627

27-
void MetadataUpdateContext::AddRequirement(
28-
std::unique_ptr<TableRequirement> requirement) {
29-
requirements_.push_back(std::move(requirement));
28+
void TableUpdateContext::AddRequirement(std::unique_ptr<TableRequirement> requirement) {
29+
throw IcebergError("TableUpdateContext::AddRequirement not implemented");
3030
}
3131

32-
Result<std::vector<std::unique_ptr<TableRequirement>>> MetadataUpdateContext::Build() {
33-
return std::move(requirements_);
32+
Result<std::vector<std::unique_ptr<TableRequirement>>> TableUpdateContext::Build() {
33+
return NotImplemented("TableUpdateContext::Build not implemented");
3434
}
3535

3636
Result<std::vector<std::unique_ptr<TableRequirement>>> TableRequirements::ForCreateTable(

0 commit comments

Comments
 (0)