Skip to content

Commit 3e1e8f1

Browse files
garrisonhessgarrisonhess
authored
Comply with clang-tidy's modernize-use-braced-initializers (#265)
1 parent 0e0f4ba commit 3e1e8f1

File tree

15 files changed

+149
-150
lines changed

15 files changed

+149
-150
lines changed

‎.clang-tidy

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,6 @@ Checks: '
4444
-modernize-use-nodiscard,
4545
-modernize-use-default-member-init,
4646
-modernize-use-trailing-return-type,
47-
-modernize-return-braced-init-list,
4847
-readability-convert-member-functions-to-static,
4948
-readability-identifier-length,
5049
-readability-function-cognitive-complexity,

‎src/common/util/string_util.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@ void StringUtil::RTrim(std::string *str) {
3232
str->erase(std::find_if(str->rbegin(), str->rend(), [](int ch) { return std::isspace(ch) == 0; }).base(), str->end());
3333
}
3434

35-
auto StringUtil::Indent(int num_indent) -> std::string { return std::string(num_indent, ' '); }
35+
auto StringUtil::Indent(int num_indent) -> std::string { return std::string(num_indent, ' '); } // NOLINT
3636

3737
auto StringUtil::StartsWith(const std::string &str, const std::string &prefix) -> bool {
3838
return std::equal(prefix.begin(), prefix.end(), str.begin());
@@ -165,7 +165,7 @@ std::string StringUtil::Format(std::string fmt_str, ...) {
165165
break;
166166
}
167167
}
168-
return std::string(formatted.get());
168+
return {formatted.get()};
169169
}
170170

171171
auto StringUtil::Split(const std::string &input, const std::string &split) -> std::vector<std::string> {

‎src/include/type/value_factory.h

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -38,25 +38,25 @@ class ValueFactory {
3838
return src.Copy();
3939
}
4040

41-
static inline auto GetTinyIntValue(int8_t value) -> Value { return Value(TypeId::TINYINT, value); }
41+
static inline auto GetTinyIntValue(int8_t value) -> Value { return {TypeId::TINYINT, value}; }
4242

43-
static inline auto GetSmallIntValue(int16_t value) -> Value { return Value(TypeId::SMALLINT, value); }
43+
static inline auto GetSmallIntValue(int16_t value) -> Value { return {TypeId::SMALLINT, value}; }
4444

45-
static inline auto GetIntegerValue(int32_t value) -> Value { return Value(TypeId::INTEGER, value); }
45+
static inline auto GetIntegerValue(int32_t value) -> Value { return {TypeId::INTEGER, value}; }
4646

47-
static inline auto GetBigIntValue(int64_t value) -> Value { return Value(TypeId::BIGINT, value); }
47+
static inline auto GetBigIntValue(int64_t value) -> Value { return {TypeId::BIGINT, value}; }
4848

49-
static inline auto GetTimestampValue(int64_t value) -> Value { return Value(TypeId::TIMESTAMP, value); }
49+
static inline auto GetTimestampValue(int64_t value) -> Value { return {TypeId::TIMESTAMP, value}; }
5050

51-
static inline auto GetDecimalValue(double value) -> Value { return Value(TypeId::DECIMAL, value); }
51+
static inline auto GetDecimalValue(double value) -> Value { return {TypeId::DECIMAL, value}; }
5252

5353
static inline auto GetBooleanValue(CmpBool value) -> Value {
54-
return Value(TypeId::BOOLEAN, value == CmpBool::CmpNull ? BUSTUB_BOOLEAN_NULL : static_cast<int8_t>(value));
54+
return {TypeId::BOOLEAN, value == CmpBool::CmpNull ? BUSTUB_BOOLEAN_NULL : static_cast<int8_t>(value)};
5555
}
5656

57-
static inline auto GetBooleanValue(bool value) -> Value { return Value(TypeId::BOOLEAN, static_cast<int8_t>(value)); }
57+
static inline auto GetBooleanValue(bool value) -> Value { return {TypeId::BOOLEAN, static_cast<int8_t>(value)}; }
5858

59-
static inline auto GetBooleanValue(int8_t value) -> Value { return Value(TypeId::BOOLEAN, value); }
59+
static inline auto GetBooleanValue(int8_t value) -> Value { return {TypeId::BOOLEAN, value}; }
6060

6161
static inline auto GetVarcharValue(const char *value, bool manage_data,
6262
__attribute__((__unused__)) AbstractPool *pool = nullptr) -> Value {
@@ -66,12 +66,12 @@ class ValueFactory {
6666

6767
static inline auto GetVarcharValue(const char *value, uint32_t len, bool manage_data,
6868
__attribute__((__unused__)) AbstractPool *pool = nullptr) -> Value {
69-
return Value(TypeId::VARCHAR, value, len, manage_data);
69+
return {TypeId::VARCHAR, value, len, manage_data};
7070
}
7171

7272
static inline auto GetVarcharValue(const std::string &value, __attribute__((__unused__)) AbstractPool *pool = nullptr)
7373
-> Value {
74-
return Value(TypeId::VARCHAR, value);
74+
return {TypeId::VARCHAR, value};
7575
}
7676

7777
static inline auto GetNullValueByType(TypeId type_id) -> Value {

‎src/storage/table/table_heap.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -186,9 +186,9 @@ auto TableHeap::Begin(Transaction *txn) -> TableIterator {
186186
}
187187
page_id = page->GetNextPageId();
188188
}
189-
return TableIterator(this, rid, txn);
189+
return {this, rid, txn};
190190
}
191191

192-
auto TableHeap::End() -> TableIterator { return TableIterator(this, RID(INVALID_PAGE_ID, 0), nullptr); }
192+
auto TableHeap::End() -> TableIterator { return {this, RID(INVALID_PAGE_ID, 0), nullptr}; }
193193

194194
} // namespace bustub

‎src/storage/table/tuple.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -103,7 +103,7 @@ auto Tuple::KeyFromTuple(const Schema &schema, const Schema &key_schema, const s
103103
for (auto idx : key_attrs) {
104104
values.emplace_back(this->GetValue(&schema, idx));
105105
}
106-
return Tuple(values, &key_schema);
106+
return {values, &key_schema};
107107
}
108108

109109
auto Tuple::GetDataPtr(const Schema *schema, const uint32_t column_idx) const -> const char * {

‎src/type/bigint_type.cpp

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -139,7 +139,7 @@ auto BigintType::Modulo(const Value &left, const Value &right) const -> Value {
139139
case TypeId::BIGINT:
140140
return ModuloValue<int64_t, int64_t>(left, right);
141141
case TypeId::DECIMAL:
142-
return Value(TypeId::DECIMAL, ValMod(left.value_.bigint_, right.GetAs<double>()));
142+
return {TypeId::DECIMAL, ValMod(left.value_.bigint_, right.GetAs<double>())};
143143
case TypeId::VARCHAR: {
144144
auto r_value = right.CastAs(TypeId::BIGINT);
145145
return ModuloValue<int64_t, int64_t>(left, r_value);
@@ -153,13 +153,13 @@ auto BigintType::Modulo(const Value &left, const Value &right) const -> Value {
153153
auto BigintType::Sqrt(const Value &val) const -> Value {
154154
assert(val.CheckInteger());
155155
if (val.IsNull()) {
156-
return Value(TypeId::DECIMAL, BUSTUB_DECIMAL_NULL);
156+
return {TypeId::DECIMAL, BUSTUB_DECIMAL_NULL};
157157
}
158158

159159
if (val.value_.bigint_ < 0) {
160160
throw Exception(ExceptionType::DECIMAL, "Cannot take square root of a negative number.");
161161
}
162-
return Value(TypeId::DECIMAL, std::sqrt(val.value_.bigint_));
162+
return {TypeId::DECIMAL, std::sqrt(val.value_.bigint_)};
163163
}
164164

165165
auto BigintType::OperateNull(const Value &left __attribute__((unused)), const Value &right) const -> Value {
@@ -168,9 +168,9 @@ auto BigintType::OperateNull(const Value &left __attribute__((unused)), const Va
168168
case TypeId::SMALLINT:
169169
case TypeId::INTEGER:
170170
case TypeId::BIGINT:
171-
return Value(TypeId::BIGINT, static_cast<int64_t>(BUSTUB_INT64_NULL));
171+
return {TypeId::BIGINT, static_cast<int64_t>(BUSTUB_INT64_NULL)};
172172
case TypeId::DECIMAL:
173-
return Value(TypeId::DECIMAL, static_cast<double>(BUSTUB_DECIMAL_NULL));
173+
return {TypeId::DECIMAL, static_cast<double>(BUSTUB_DECIMAL_NULL)};
174174
default:
175175
break;
176176
}
@@ -265,60 +265,60 @@ void BigintType::SerializeTo(const Value &val, char *storage) const {
265265
// Deserialize a value of the given type from the given storage space.
266266
auto BigintType::DeserializeFrom(const char *storage) const -> Value {
267267
int64_t val = *reinterpret_cast<const int64_t *>(storage);
268-
return Value(type_id_, val);
268+
return {type_id_, val};
269269
}
270270

271-
auto BigintType::Copy(const Value &val) const -> Value { return Value(TypeId::BIGINT, val.value_.bigint_); }
271+
auto BigintType::Copy(const Value &val) const -> Value { return {TypeId::BIGINT, val.value_.bigint_}; }
272272

273273
auto BigintType::CastAs(const Value &val, const TypeId type_id) const -> Value {
274274
switch (type_id) {
275275
case TypeId::TINYINT: {
276276
if (val.IsNull()) {
277-
return Value(type_id, BUSTUB_INT8_NULL);
277+
return {type_id, BUSTUB_INT8_NULL};
278278
}
279279
if (val.GetAs<int64_t>() > BUSTUB_INT8_MAX || val.GetAs<int64_t>() < BUSTUB_INT8_MIN) {
280280
throw Exception(ExceptionType::OUT_OF_RANGE, "Numeric value out of range.");
281281
}
282-
return Value(type_id, static_cast<int8_t>(val.GetAs<int64_t>()));
282+
return {type_id, static_cast<int8_t>(val.GetAs<int64_t>())};
283283
}
284284
case TypeId::SMALLINT: {
285285
if (val.IsNull()) {
286-
return Value(type_id, BUSTUB_INT16_NULL);
286+
return {type_id, BUSTUB_INT16_NULL};
287287
}
288288
if (val.GetAs<int64_t>() > BUSTUB_INT16_MAX || val.GetAs<int64_t>() < BUSTUB_INT16_MIN) {
289289
throw Exception(ExceptionType::OUT_OF_RANGE, "Numeric value out of range.");
290290
}
291-
return Value(type_id, static_cast<int16_t>(val.GetAs<int64_t>()));
291+
return {type_id, static_cast<int16_t>(val.GetAs<int64_t>())};
292292
}
293293
case TypeId::INTEGER: {
294294
if (val.IsNull()) {
295-
return Value(type_id, BUSTUB_INT32_NULL);
295+
return {type_id, BUSTUB_INT32_NULL};
296296
}
297297
if (val.GetAs<int64_t>() > BUSTUB_INT32_MAX || val.GetAs<int64_t>() < BUSTUB_INT32_MIN) {
298298
throw Exception(ExceptionType::OUT_OF_RANGE, "Numeric value out of range.");
299299
}
300-
return Value(type_id, static_cast<int32_t>(val.GetAs<int64_t>()));
300+
return {type_id, static_cast<int32_t>(val.GetAs<int64_t>())};
301301
}
302302

303303
case TypeId::BIGINT: {
304304
if (val.IsNull()) {
305-
return Value(type_id, BUSTUB_INT64_NULL);
305+
return {type_id, BUSTUB_INT64_NULL};
306306
}
307307
return Copy(val);
308308
}
309309

310310
case TypeId::DECIMAL: {
311311
if (val.IsNull()) {
312-
return Value(type_id, BUSTUB_DECIMAL_NULL);
312+
return {type_id, BUSTUB_DECIMAL_NULL};
313313
}
314-
return Value(type_id, static_cast<double>(val.GetAs<int64_t>()));
314+
return {type_id, static_cast<double>(val.GetAs<int64_t>())};
315315
}
316316

317317
case TypeId::VARCHAR: {
318318
if (val.IsNull()) {
319-
return Value(TypeId::VARCHAR, nullptr, 0, false);
319+
return {TypeId::VARCHAR, nullptr, 0, false};
320320
}
321-
return Value(TypeId::VARCHAR, val.ToString());
321+
return {TypeId::VARCHAR, val.ToString()};
322322
}
323323
default:
324324
break;

‎src/type/boolean_type.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -92,20 +92,20 @@ void BooleanType::SerializeTo(const Value &val, char *storage) const {
9292
// Deserialize a value of the given type from the given storage space.
9393
auto BooleanType::DeserializeFrom(const char *storage) const -> Value {
9494
int8_t val = *reinterpret_cast<const int8_t *>(storage);
95-
return Value(TypeId::BOOLEAN, val);
95+
return {TypeId::BOOLEAN, val};
9696
}
9797

98-
auto BooleanType::Copy(const Value &val) const -> Value { return Value(TypeId::BOOLEAN, val.value_.boolean_); }
98+
auto BooleanType::Copy(const Value &val) const -> Value { return {TypeId::BOOLEAN, val.value_.boolean_}; }
9999

100100
auto BooleanType::CastAs(const Value &val, const TypeId type_id) const -> Value {
101101
switch (type_id) {
102102
case TypeId::BOOLEAN:
103103
return Copy(val);
104104
case TypeId::VARCHAR: {
105105
if (val.IsNull()) {
106-
return Value(TypeId::VARCHAR, nullptr, 0, false);
106+
return {TypeId::VARCHAR, nullptr, 0, false};
107107
}
108-
return Value(TypeId::VARCHAR, val.ToString());
108+
return {TypeId::VARCHAR, val.ToString()};
109109
}
110110
default:
111111
break;

‎src/type/decimal_type.cpp

Lines changed: 21 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -132,18 +132,18 @@ auto DecimalType::Modulo(const Value &left, const Value &right) const -> Value {
132132
}
133133
switch (right.GetTypeId()) {
134134
case TypeId::TINYINT:
135-
return Value(TypeId::DECIMAL, ValMod(left.value_.decimal_, right.GetAs<int8_t>()));
135+
return {TypeId::DECIMAL, ValMod(left.value_.decimal_, right.GetAs<int8_t>())};
136136
case TypeId::SMALLINT:
137-
return Value(TypeId::DECIMAL, ValMod(left.value_.decimal_, right.GetAs<int16_t>()));
137+
return {TypeId::DECIMAL, ValMod(left.value_.decimal_, right.GetAs<int16_t>())};
138138
case TypeId::INTEGER:
139-
return Value(TypeId::DECIMAL, ValMod(left.value_.decimal_, right.GetAs<int32_t>()));
139+
return {TypeId::DECIMAL, ValMod(left.value_.decimal_, right.GetAs<int32_t>())};
140140
case TypeId::BIGINT:
141-
return Value(TypeId::DECIMAL, ValMod(left.value_.decimal_, right.GetAs<int64_t>()));
141+
return {TypeId::DECIMAL, ValMod(left.value_.decimal_, right.GetAs<int64_t>())};
142142
case TypeId::DECIMAL:
143-
return Value(TypeId::DECIMAL, ValMod(left.value_.decimal_, right.GetAs<double>()));
143+
return {TypeId::DECIMAL, ValMod(left.value_.decimal_, right.GetAs<double>())};
144144
case TypeId::VARCHAR: {
145145
auto r_value = right.CastAs(TypeId::DECIMAL);
146-
return Value(TypeId::DECIMAL, ValMod(left.value_.decimal_, r_value.GetAs<double>()));
146+
return {TypeId::DECIMAL, ValMod(left.value_.decimal_, r_value.GetAs<double>())};
147147
}
148148
default:
149149
break;
@@ -180,17 +180,17 @@ auto DecimalType::Max(const Value &left, const Value &right) const -> Value {
180180
auto DecimalType::Sqrt(const Value &val) const -> Value {
181181
assert(GetTypeId() == TypeId::DECIMAL);
182182
if (val.IsNull()) {
183-
return Value(TypeId::DECIMAL, BUSTUB_DECIMAL_NULL);
183+
return {TypeId::DECIMAL, BUSTUB_DECIMAL_NULL};
184184
}
185185
if (val.value_.decimal_ < 0) {
186186
throw Exception(ExceptionType::DECIMAL, "Cannot take square root of a negative number.");
187187
}
188-
return Value(TypeId::DECIMAL, std::sqrt(val.value_.decimal_));
188+
return {TypeId::DECIMAL, std::sqrt(val.value_.decimal_)};
189189
}
190190

191191
auto DecimalType::OperateNull(const Value &left __attribute__((unused)),
192192
const Value &right __attribute__((unused))) const -> Value {
193-
return Value(TypeId::DECIMAL, BUSTUB_DECIMAL_NULL);
193+
return {TypeId::DECIMAL, BUSTUB_DECIMAL_NULL};
194194
}
195195

196196
auto DecimalType::CompareEquals(const Value &left, const Value &right) const -> CmpBool {
@@ -269,48 +269,48 @@ auto DecimalType::CastAs(const Value &val, const TypeId type_id) const -> Value
269269
switch (type_id) {
270270
case TypeId::TINYINT: {
271271
if (val.IsNull()) {
272-
return Value(type_id, BUSTUB_INT8_NULL);
272+
return {type_id, BUSTUB_INT8_NULL};
273273
}
274274
if (val.GetAs<double>() > BUSTUB_INT8_MAX || val.GetAs<double>() < BUSTUB_INT8_MIN) {
275275
throw Exception(ExceptionType::OUT_OF_RANGE, "Numeric value out of range.");
276276
}
277-
return Value(type_id, static_cast<int8_t>(val.GetAs<double>()));
277+
return {type_id, static_cast<int8_t>(val.GetAs<double>())};
278278
}
279279
case TypeId::SMALLINT: {
280280
if (val.IsNull()) {
281-
return Value(type_id, BUSTUB_INT16_NULL);
281+
return {type_id, BUSTUB_INT16_NULL};
282282
}
283283
if (val.GetAs<double>() > BUSTUB_INT16_MAX || val.GetAs<double>() < BUSTUB_INT16_MIN) {
284284
throw Exception(ExceptionType::OUT_OF_RANGE, "Numeric value out of range.");
285285
}
286-
return Value(type_id, static_cast<int16_t>(val.GetAs<double>()));
286+
return {type_id, static_cast<int16_t>(val.GetAs<double>())};
287287
}
288288
case TypeId::INTEGER: {
289289
if (val.IsNull()) {
290-
return Value(type_id, BUSTUB_INT32_NULL);
290+
return {type_id, BUSTUB_INT32_NULL};
291291
}
292292
if (val.GetAs<double>() > BUSTUB_INT32_MAX || val.GetAs<double>() < BUSTUB_INT32_MIN) {
293293
throw Exception(ExceptionType::OUT_OF_RANGE, "Numeric value out of range.");
294294
}
295-
return Value(type_id, static_cast<int32_t>(val.GetAs<double>()));
295+
return {type_id, static_cast<int32_t>(val.GetAs<double>())};
296296
}
297297
case TypeId::BIGINT: {
298298
if (val.IsNull()) {
299-
return Value(type_id, BUSTUB_INT64_NULL);
299+
return {type_id, BUSTUB_INT64_NULL};
300300
}
301301
if (val.GetAs<double>() >= static_cast<double>(BUSTUB_INT64_MAX) ||
302302
val.GetAs<double>() < static_cast<double>(BUSTUB_INT64_MIN)) {
303303
throw Exception(ExceptionType::OUT_OF_RANGE, "Numeric value out of range.");
304304
}
305-
return Value(type_id, static_cast<int64_t>(val.GetAs<double>()));
305+
return {type_id, static_cast<int64_t>(val.GetAs<double>())};
306306
}
307307
case TypeId::DECIMAL:
308308
return val.Copy();
309309
case TypeId::VARCHAR: {
310310
if (val.IsNull()) {
311-
return Value(TypeId::VARCHAR, nullptr, 0, false);
311+
return {TypeId::VARCHAR, nullptr, 0, false};
312312
}
313-
return Value(TypeId::VARCHAR, val.ToString());
313+
return {TypeId::VARCHAR, val.ToString()};
314314
}
315315
default:
316316
break;
@@ -332,8 +332,8 @@ void DecimalType::SerializeTo(const Value &val, char *storage) const {
332332
// Deserialize a value of the given type from the given storage space.
333333
auto DecimalType::DeserializeFrom(const char *storage) const -> Value {
334334
double val = *reinterpret_cast<const double *>(storage);
335-
return Value(type_id_, val);
335+
return {type_id_, val};
336336
}
337337

338-
auto DecimalType::Copy(const Value &val) const -> Value { return Value(TypeId::DECIMAL, val.value_.decimal_); }
338+
auto DecimalType::Copy(const Value &val) const -> Value { return {TypeId::DECIMAL, val.value_.decimal_}; }
339339
} // namespace bustub

0 commit comments

Comments
 (0)