Skip to content

Commit 718b62f

Browse files
gty404gty404
committed
move subclass of TableUpdate/TableRequirement to sub namespace
1 parent 35c22e2 commit 718b62f

File tree

4 files changed

+125
-109
lines changed

4 files changed

+125
-109
lines changed

‎src/iceberg/table_requirement.cc‎

Lines changed: 12 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -23,39 +23,43 @@
2323

2424
namespace iceberg {
2525

26-
Status AssertTableDoesNotExist::Validate(const TableMetadata* base) const {
26+
namespace table {
27+
28+
Status AssertDoesNotExist::Validate(const TableMetadata* base) const {
2729
return NotImplemented("AssertTableDoesNotExist::Validate not implemented");
2830
}
2931

30-
Status AssertTableUUID::Validate(const TableMetadata* base) const {
32+
Status AssertUUID::Validate(const TableMetadata* base) const {
3133
return NotImplemented("AssertTableUUID::Validate not implemented");
3234
}
3335

34-
Status AssertTableRefSnapshotID::Validate(const TableMetadata* base) const {
36+
Status AssertRefSnapshotID::Validate(const TableMetadata* base) const {
3537
return NotImplemented("AssertTableRefSnapshotID::Validate not implemented");
3638
}
3739

38-
Status AssertCurrentTableLastAssignedFieldId::Validate(const TableMetadata* base) const {
40+
Status AssertLastAssignedFieldId::Validate(const TableMetadata* base) const {
3941
return NotImplemented(
4042
"AssertCurrentTableLastAssignedFieldId::Validate not implemented");
4143
}
4244

43-
Status AssertCurrentTableSchemaID::Validate(const TableMetadata* base) const {
45+
Status AssertCurrentSchemaID::Validate(const TableMetadata* base) const {
4446
return NotImplemented("AssertCurrentTableSchemaID::Validate not implemented");
4547
}
4648

47-
Status AssertCurrentTableLastAssignedPartitionId::Validate(
49+
Status AssertLastAssignedPartitionId::Validate(
4850
const TableMetadata* base) const {
4951
return NotImplemented(
5052
"AssertCurrentTableLastAssignedPartitionId::Validate not implemented");
5153
}
5254

53-
Status AssertDefaultTableSpecID::Validate(const TableMetadata* base) const {
55+
Status AssertDefaultSpecID::Validate(const TableMetadata* base) const {
5456
return NotImplemented("AssertDefaultTableSpecID::Validate not implemented");
5557
}
5658

57-
Status AssertDefaultTableSortOrderID::Validate(const TableMetadata* base) const {
59+
Status AssertDefaultSortOrderID::Validate(const TableMetadata* base) const {
5860
return NotImplemented("AssertDefaultTableSortOrderID::Validate not implemented");
5961
}
6062

63+
} // namespace table
64+
6165
} // namespace iceberg

‎src/iceberg/table_requirement.h‎

Lines changed: 20 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -51,13 +51,15 @@ class ICEBERG_EXPORT TableRequirement {
5151
virtual Status Validate(const TableMetadata* base) const = 0;
5252
};
5353

54+
namespace table {
55+
5456
/// \brief Requirement that the table does not exist
5557
///
5658
/// This requirement is used when creating a new table to ensure
5759
/// it doesn't already exist.
58-
class ICEBERG_EXPORT AssertTableDoesNotExist : public TableRequirement {
60+
class ICEBERG_EXPORT AssertDoesNotExist : public TableRequirement {
5961
public:
60-
AssertTableDoesNotExist() = default;
62+
AssertDoesNotExist() = default;
6163

6264
Status Validate(const TableMetadata* base) const override;
6365
};
@@ -66,9 +68,9 @@ class ICEBERG_EXPORT AssertTableDoesNotExist : public TableRequirement {
6668
///
6769
/// This ensures the table hasn't been replaced or recreated between
6870
/// reading the metadata and attempting to update it.
69-
class ICEBERG_EXPORT AssertTableUUID : public TableRequirement {
71+
class ICEBERG_EXPORT AssertUUID : public TableRequirement {
7072
public:
71-
explicit AssertTableUUID(std::string uuid) : uuid_(std::move(uuid)) {}
73+
explicit AssertUUID(std::string uuid) : uuid_(std::move(uuid)) {}
7274

7375
const std::string& uuid() const { return uuid_; }
7476

@@ -83,9 +85,9 @@ class ICEBERG_EXPORT AssertTableUUID : public TableRequirement {
8385
/// This requirement validates that a named reference (branch or tag) either:
8486
/// - Points to the expected snapshot ID
8587
/// - Does not exist (if snapshot_id is nullopt)
86-
class ICEBERG_EXPORT AssertTableRefSnapshotID : public TableRequirement {
88+
class ICEBERG_EXPORT AssertRefSnapshotID : public TableRequirement {
8789
public:
88-
AssertTableRefSnapshotID(std::string ref_name, std::optional<int64_t> snapshot_id)
90+
AssertRefSnapshotID(std::string ref_name, std::optional<int64_t> snapshot_id)
8991
: ref_name_(std::move(ref_name)), snapshot_id_(snapshot_id) {}
9092

9193
const std::string& ref_name() const { return ref_name_; }
@@ -103,9 +105,9 @@ class ICEBERG_EXPORT AssertTableRefSnapshotID : public TableRequirement {
103105
///
104106
/// This ensures the schema hasn't been modified (by adding fields)
105107
/// since the metadata was read.
106-
class ICEBERG_EXPORT AssertCurrentTableLastAssignedFieldId : public TableRequirement {
108+
class ICEBERG_EXPORT AssertLastAssignedFieldId : public TableRequirement {
107109
public:
108-
explicit AssertCurrentTableLastAssignedFieldId(int32_t last_assigned_field_id)
110+
explicit AssertLastAssignedFieldId(int32_t last_assigned_field_id)
109111
: last_assigned_field_id_(last_assigned_field_id) {}
110112

111113
int32_t last_assigned_field_id() const { return last_assigned_field_id_; }
@@ -120,9 +122,9 @@ class ICEBERG_EXPORT AssertCurrentTableLastAssignedFieldId : public TableRequire
120122
///
121123
/// This ensures the active schema hasn't changed since the
122124
/// metadata was read.
123-
class ICEBERG_EXPORT AssertCurrentTableSchemaID : public TableRequirement {
125+
class ICEBERG_EXPORT AssertCurrentSchemaID : public TableRequirement {
124126
public:
125-
explicit AssertCurrentTableSchemaID(int32_t schema_id) : schema_id_(schema_id) {}
127+
explicit AssertCurrentSchemaID(int32_t schema_id) : schema_id_(schema_id) {}
126128

127129
int32_t schema_id() const { return schema_id_; }
128130

@@ -136,9 +138,9 @@ class ICEBERG_EXPORT AssertCurrentTableSchemaID : public TableRequirement {
136138
///
137139
/// This ensures partition specs haven't been modified since the
138140
/// metadata was read.
139-
class ICEBERG_EXPORT AssertCurrentTableLastAssignedPartitionId : public TableRequirement {
141+
class ICEBERG_EXPORT AssertLastAssignedPartitionId : public TableRequirement {
140142
public:
141-
explicit AssertCurrentTableLastAssignedPartitionId(int32_t last_assigned_partition_id)
143+
explicit AssertLastAssignedPartitionId(int32_t last_assigned_partition_id)
142144
: last_assigned_partition_id_(last_assigned_partition_id) {}
143145

144146
int32_t last_assigned_partition_id() const { return last_assigned_partition_id_; }
@@ -153,9 +155,9 @@ class ICEBERG_EXPORT AssertCurrentTableLastAssignedPartitionId : public TableReq
153155
///
154156
/// This ensures the default partition spec hasn't changed since
155157
/// the metadata was read.
156-
class ICEBERG_EXPORT AssertDefaultTableSpecID : public TableRequirement {
158+
class ICEBERG_EXPORT AssertDefaultSpecID : public TableRequirement {
157159
public:
158-
explicit AssertDefaultTableSpecID(int32_t spec_id) : spec_id_(spec_id) {}
160+
explicit AssertDefaultSpecID(int32_t spec_id) : spec_id_(spec_id) {}
159161

160162
int32_t spec_id() const { return spec_id_; }
161163

@@ -169,9 +171,9 @@ class ICEBERG_EXPORT AssertDefaultTableSpecID : public TableRequirement {
169171
///
170172
/// This ensures the default sort order hasn't changed since
171173
/// the metadata was read.
172-
class ICEBERG_EXPORT AssertDefaultTableSortOrderID : public TableRequirement {
174+
class ICEBERG_EXPORT AssertDefaultSortOrderID : public TableRequirement {
173175
public:
174-
explicit AssertDefaultTableSortOrderID(int32_t sort_order_id)
176+
explicit AssertDefaultSortOrderID(int32_t sort_order_id)
175177
: sort_order_id_(sort_order_id) {}
176178

177179
int32_t sort_order_id() const { return sort_order_id_; }
@@ -182,4 +184,6 @@ class ICEBERG_EXPORT AssertDefaultTableSortOrderID : public TableRequirement {
182184
int32_t sort_order_id_;
183185
};
184186

187+
} // namespace table
188+
185189
} // namespace iceberg

‎src/iceberg/table_update.cc‎

Lines changed: 55 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -25,178 +25,182 @@
2525

2626
namespace iceberg {
2727

28-
// AssignTableUUID
28+
namespace table {
2929

30-
void AssignTableUUID::ApplyTo(TableMetadataBuilder& builder) const {
30+
// AssignUUID
31+
32+
void AssignUUID::ApplyTo(TableMetadataBuilder& builder) const {
3133
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
3234
}
3335

34-
Status AssignTableUUID::GenerateRequirements(TableUpdateContext& context) const {
36+
Status AssignUUID::GenerateRequirements(TableUpdateContext& context) const {
3537
return NotImplemented("AssignTableUUID::GenerateRequirements not implemented");
3638
}
3739

38-
// UpgradeTableFormatVersion
40+
// UpgradeFormatVersion
3941

40-
void UpgradeTableFormatVersion::ApplyTo(TableMetadataBuilder& builder) const {
42+
void UpgradeFormatVersion::ApplyTo(TableMetadataBuilder& builder) const {
4143
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
4244
}
4345

44-
Status UpgradeTableFormatVersion::GenerateRequirements(
46+
Status UpgradeFormatVersion::GenerateRequirements(
4547
TableUpdateContext& context) const {
4648
return NotImplemented(
4749
"UpgradeTableFormatVersion::GenerateRequirements not implemented");
4850
}
4951

50-
// AddTableSchema
52+
// AddSchema
5153

52-
void AddTableSchema::ApplyTo(TableMetadataBuilder& builder) const {
54+
void AddSchema::ApplyTo(TableMetadataBuilder& builder) const {
5355
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
5456
}
5557

56-
Status AddTableSchema::GenerateRequirements(TableUpdateContext& context) const {
58+
Status AddSchema::GenerateRequirements(TableUpdateContext& context) const {
5759
return NotImplemented("AddTableSchema::GenerateRequirements not implemented");
5860
}
5961

60-
// SetCurrentTableSchema
62+
// SetCurrentSchema
6163

62-
void SetCurrentTableSchema::ApplyTo(TableMetadataBuilder& builder) const {
64+
void SetCurrentSchema::ApplyTo(TableMetadataBuilder& builder) const {
6365
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
6466
}
6567

66-
Status SetCurrentTableSchema::GenerateRequirements(TableUpdateContext& context) const {
68+
Status SetCurrentSchema::GenerateRequirements(TableUpdateContext& context) const {
6769
return NotImplemented("SetCurrentTableSchema::GenerateRequirements not implemented");
6870
}
6971

70-
// AddTablePartitionSpec
72+
// AddPartitionSpec
7173

72-
void AddTablePartitionSpec::ApplyTo(TableMetadataBuilder& builder) const {
74+
void AddPartitionSpec::ApplyTo(TableMetadataBuilder& builder) const {
7375
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
7476
}
7577

76-
Status AddTablePartitionSpec::GenerateRequirements(TableUpdateContext& context) const {
78+
Status AddPartitionSpec::GenerateRequirements(TableUpdateContext& context) const {
7779
return NotImplemented("AddTablePartitionSpec::GenerateRequirements not implemented");
7880
}
7981

80-
// SetDefaultTablePartitionSpec
82+
// SetDefaultPartitionSpec
8183

82-
void SetDefaultTablePartitionSpec::ApplyTo(TableMetadataBuilder& builder) const {
84+
void SetDefaultPartitionSpec::ApplyTo(TableMetadataBuilder& builder) const {
8385
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
8486
}
8587

86-
Status SetDefaultTablePartitionSpec::GenerateRequirements(
88+
Status SetDefaultPartitionSpec::GenerateRequirements(
8789
TableUpdateContext& context) const {
8890
return NotImplemented(
8991
"SetDefaultTablePartitionSpec::GenerateRequirements not implemented");
9092
}
9193

92-
// RemoveTablePartitionSpecs
94+
// RemovePartitionSpecs
9395

94-
void RemoveTablePartitionSpecs::ApplyTo(TableMetadataBuilder& builder) const {
96+
void RemovePartitionSpecs::ApplyTo(TableMetadataBuilder& builder) const {
9597
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
9698
}
9799

98-
Status RemoveTablePartitionSpecs::GenerateRequirements(
100+
Status RemovePartitionSpecs::GenerateRequirements(
99101
TableUpdateContext& context) const {
100102
return NotImplemented(
101103
"RemoveTablePartitionSpecs::GenerateRequirements not implemented");
102104
}
103105

104-
// RemoveTableSchemas
106+
// RemoveSchemas
105107

106-
void RemoveTableSchemas::ApplyTo(TableMetadataBuilder& builder) const {
108+
void RemoveSchemas::ApplyTo(TableMetadataBuilder& builder) const {
107109
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
108110
}
109111

110-
Status RemoveTableSchemas::GenerateRequirements(TableUpdateContext& context) const {
112+
Status RemoveSchemas::GenerateRequirements(TableUpdateContext& context) const {
111113
return NotImplemented("RemoveTableSchemas::GenerateRequirements not implemented");
112114
}
113115

114-
// AddTableSortOrder
116+
// AddSortOrder
115117

116-
void AddTableSortOrder::ApplyTo(TableMetadataBuilder& builder) const {
118+
void AddSortOrder::ApplyTo(TableMetadataBuilder& builder) const {
117119
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
118120
}
119121

120-
Status AddTableSortOrder::GenerateRequirements(TableUpdateContext& context) const {
122+
Status AddSortOrder::GenerateRequirements(TableUpdateContext& context) const {
121123
return NotImplemented("AddTableSortOrder::GenerateRequirements not implemented");
122124
}
123125

124-
// SetDefaultTableSortOrder
126+
// SetDefaultSortOrder
125127

126-
void SetDefaultTableSortOrder::ApplyTo(TableMetadataBuilder& builder) const {
128+
void SetDefaultSortOrder::ApplyTo(TableMetadataBuilder& builder) const {
127129
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
128130
}
129131

130-
Status SetDefaultTableSortOrder::GenerateRequirements(TableUpdateContext& context) const {
132+
Status SetDefaultSortOrder::GenerateRequirements(TableUpdateContext& context) const {
131133
return NotImplemented("SetDefaultTableSortOrder::GenerateRequirements not implemented");
132134
}
133135

134-
// AddTableSnapshot
136+
// AddSnapshot
135137

136-
void AddTableSnapshot::ApplyTo(TableMetadataBuilder& builder) const {
138+
void AddSnapshot::ApplyTo(TableMetadataBuilder& builder) const {
137139
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
138140
}
139141

140-
Status AddTableSnapshot::GenerateRequirements(TableUpdateContext& context) const {
142+
Status AddSnapshot::GenerateRequirements(TableUpdateContext& context) const {
141143
return NotImplemented("AddTableSnapshot::GenerateRequirements not implemented");
142144
}
143145

144-
// RemoveTableSnapshots
146+
// RemoveSnapshots
145147

146-
void RemoveTableSnapshots::ApplyTo(TableMetadataBuilder& builder) const {}
148+
void RemoveSnapshots::ApplyTo(TableMetadataBuilder& builder) const {}
147149

148-
Status RemoveTableSnapshots::GenerateRequirements(TableUpdateContext& context) const {
150+
Status RemoveSnapshots::GenerateRequirements(TableUpdateContext& context) const {
149151
return NotImplemented("RemoveTableSnapshots::GenerateRequirements not implemented");
150152
}
151153

152-
// RemoveTableSnapshotRef
154+
// RemoveSnapshotRef
153155

154-
void RemoveTableSnapshotRef::ApplyTo(TableMetadataBuilder& builder) const {
156+
void RemoveSnapshotRef::ApplyTo(TableMetadataBuilder& builder) const {
155157
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
156158
}
157159

158-
Status RemoveTableSnapshotRef::GenerateRequirements(TableUpdateContext& context) const {
160+
Status RemoveSnapshotRef::GenerateRequirements(TableUpdateContext& context) const {
159161
return NotImplemented("RemoveTableSnapshotRef::GenerateRequirements not implemented");
160162
}
161163

162-
// SetTableSnapshotRef
164+
// SetSnapshotRef
163165

164-
void SetTableSnapshotRef::ApplyTo(TableMetadataBuilder& builder) const {
166+
void SetSnapshotRef::ApplyTo(TableMetadataBuilder& builder) const {
165167
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
166168
}
167169

168-
Status SetTableSnapshotRef::GenerateRequirements(TableUpdateContext& context) const {
170+
Status SetSnapshotRef::GenerateRequirements(TableUpdateContext& context) const {
169171
return NotImplemented("SetTableSnapshotRef::GenerateRequirements not implemented");
170172
}
171173

172-
// SetTableProperties
174+
// SetProperties
173175

174-
void SetTableProperties::ApplyTo(TableMetadataBuilder& builder) const {
176+
void SetProperties::ApplyTo(TableMetadataBuilder& builder) const {
175177
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
176178
}
177179

178-
Status SetTableProperties::GenerateRequirements(TableUpdateContext& context) const {
180+
Status SetProperties::GenerateRequirements(TableUpdateContext& context) const {
179181
return NotImplemented("SetTableProperties::GenerateRequirements not implemented");
180182
}
181183

182-
// RemoveTableProperties
184+
// RemoveProperties
183185

184-
void RemoveTableProperties::ApplyTo(TableMetadataBuilder& builder) const {
186+
void RemoveProperties::ApplyTo(TableMetadataBuilder& builder) const {
185187
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
186188
}
187189

188-
Status RemoveTableProperties::GenerateRequirements(TableUpdateContext& context) const {
190+
Status RemoveProperties::GenerateRequirements(TableUpdateContext& context) const {
189191
return NotImplemented("RemoveTableProperties::GenerateRequirements not implemented");
190192
}
191193

192-
// SetTableLocation
194+
// SetLocation
193195

194-
void SetTableLocation::ApplyTo(TableMetadataBuilder& builder) const {
196+
void SetLocation::ApplyTo(TableMetadataBuilder& builder) const {
195197
throw IcebergError(std::format("{} not implemented", __FUNCTION__));
196198
}
197199

198-
Status SetTableLocation::GenerateRequirements(TableUpdateContext& context) const {
200+
Status SetLocation::GenerateRequirements(TableUpdateContext& context) const {
199201
return NotImplemented("SetTableLocation::GenerateRequirements not implemented");
200202
}
201203

204+
} // namespace table
205+
202206
} // namespace iceberg

0 commit comments

Comments
 (0)