Coverage Report

Created: 2024-02-25 06:14

/src/sql-parser/src/sql/statements.cpp
Line
Count
Source (jump to first uncovered line)
1
#include "statements.h"
2
#include "AlterStatement.h"
3
4
namespace hsql {
5
6
// KeyConstraints
7
TableConstraint::TableConstraint(ConstraintType type, std::vector<char*>* columnNames)
8
58.6k
    : type(type), columnNames(columnNames) {}
9
10
58.6k
TableConstraint::~TableConstraint() {
11
58.8k
  for (char* def : *columnNames) {
12
58.8k
    free(def);
13
58.8k
  }
14
58.6k
  delete columnNames;
15
58.6k
}
16
17
// ColumnDefinition
18
ColumnDefinition::ColumnDefinition(char* name, ColumnType type, std::unordered_set<ConstraintType>* column_constraints)
19
347k
    : column_constraints(column_constraints), name(name), type(type), nullable(true) {}
20
21
347k
ColumnDefinition::~ColumnDefinition() {
22
347k
  free(name);
23
347k
  delete column_constraints;
24
347k
}
25
26
ColumnType::ColumnType(DataType data_type, int64_t length, int64_t precision, int64_t scale)
27
3.42M
    : data_type(data_type), length(length), precision(precision), scale(scale) {}
28
29
0
bool operator==(const ColumnType& lhs, const ColumnType& rhs) {
30
0
  if (lhs.data_type != rhs.data_type) return false;
31
0
  return lhs.length == rhs.length && lhs.precision == rhs.precision && lhs.scale == rhs.scale;
32
0
}
33
34
0
bool operator!=(const ColumnType& lhs, const ColumnType& rhs) { return !(lhs == rhs); }
35
36
0
std::ostream& operator<<(std::ostream& stream, const ColumnType& column_type) {
37
0
  switch (column_type.data_type) {
38
0
    case DataType::UNKNOWN:
39
0
      stream << "UNKNOWN";
40
0
      break;
41
0
    case DataType::INT:
42
0
      stream << "INT";
43
0
      break;
44
0
    case DataType::BIGINT:
45
0
      stream << "BIGINT";
46
0
      break;
47
0
    case DataType::LONG:
48
0
      stream << "LONG";
49
0
      break;
50
0
    case DataType::FLOAT:
51
0
      stream << "FLOAT";
52
0
      break;
53
0
    case DataType::DOUBLE:
54
0
      stream << "DOUBLE";
55
0
      break;
56
0
    case DataType::REAL:
57
0
      stream << "REAL";
58
0
      break;
59
0
    case DataType::CHAR:
60
0
      stream << "CHAR(" << column_type.length << ")";
61
0
      break;
62
0
    case DataType::VARCHAR:
63
0
      stream << "VARCHAR(" << column_type.length << ")";
64
0
      break;
65
0
    case DataType::DECIMAL:
66
0
      stream << "DECIMAL";
67
0
      break;
68
0
    case DataType::TEXT:
69
0
      stream << "TEXT";
70
0
      break;
71
0
    case DataType::DATETIME:
72
0
      stream << "DATETIME";
73
0
      break;
74
0
    case DataType::DATE:
75
0
      stream << "DATE";
76
0
      break;
77
0
    case DataType::TIME:
78
0
      stream << "TIME";
79
0
      break;
80
0
    case DataType::SMALLINT:
81
0
      stream << "SMALLINT";
82
0
      break;
83
0
    case DataType::BOOLEAN:
84
0
      stream << "BOOLEAN";
85
0
      break;
86
0
  }
87
0
  return stream;
88
0
}
89
90
// DeleteStatement
91
1.85k
DeleteStatement::DeleteStatement() : SQLStatement(kStmtDelete), schema(nullptr), tableName(nullptr), expr(nullptr) {}
92
93
1.85k
DeleteStatement::~DeleteStatement() {
94
1.85k
  free(schema);
95
1.85k
  free(tableName);
96
1.85k
  delete expr;
97
1.85k
}
98
99
// DropStatement
100
DropStatement::DropStatement(DropType type)
101
3.19k
    : SQLStatement(kStmtDrop), type(type), schema(nullptr), name(nullptr), indexName(nullptr) {}
102
103
3.19k
DropStatement::~DropStatement() {
104
3.19k
  free(schema);
105
3.19k
  free(name);
106
3.19k
  free(indexName);
107
3.19k
}
108
109
// AlterStatement and supportive classes
110
111
0
AlterAction::AlterAction(ActionType type) : type(type) {}
112
113
0
AlterAction::~AlterAction() = default;
114
115
DropColumnAction::DropColumnAction(char* column_name)
116
0
    : AlterAction(ActionType::DropColumn), columnName(column_name), ifExists(false) {}
117
118
0
DropColumnAction::~DropColumnAction() { free(columnName); }
119
120
AlterStatement::AlterStatement(char* name, AlterAction* action)
121
0
    : SQLStatement(kStmtAlter), schema(nullptr), ifTableExists(false), name(name), action(action) {}
122
123
0
AlterStatement::~AlterStatement() {
124
0
  free(schema);
125
0
  free(name);
126
0
  delete action;
127
0
}
128
129
// TransactionStatement
130
TransactionStatement::TransactionStatement(TransactionCommand command)
131
67.4k
    : SQLStatement(kStmtTransaction), command(command) {}
132
133
67.4k
TransactionStatement::~TransactionStatement() {}
134
135
// ExecuteStatement
136
2.37k
ExecuteStatement::ExecuteStatement() : SQLStatement(kStmtExecute), name(nullptr), parameters(nullptr) {}
137
138
2.37k
ExecuteStatement::~ExecuteStatement() {
139
2.37k
  free(name);
140
141
2.37k
  if (parameters) {
142
327
    for (Expr* param : *parameters) {
143
327
      delete param;
144
327
    }
145
80
    delete parameters;
146
80
  }
147
2.37k
}
148
149
// ExportStatement
150
ExportStatement::ExportStatement(ImportType type)
151
1.85k
    : SQLStatement(kStmtExport), type(type), filePath(nullptr), schema(nullptr), tableName(nullptr), select(nullptr) {}
152
153
1.85k
ExportStatement::~ExportStatement() {
154
1.85k
  free(filePath);
155
1.85k
  free(schema);
156
1.85k
  free(tableName);
157
1.85k
  delete select;
158
1.85k
}
159
160
// ImportStatement
161
ImportStatement::ImportStatement(ImportType type)
162
    : SQLStatement(kStmtImport),
163
      type(type),
164
      filePath(nullptr),
165
      schema(nullptr),
166
      tableName(nullptr),
167
562
      whereClause(nullptr) {}
168
169
562
ImportStatement::~ImportStatement() {
170
562
  free(filePath);
171
562
  free(schema);
172
562
  free(tableName);
173
562
  delete whereClause;
174
562
}
175
176
// InsertStatement
177
InsertStatement::InsertStatement(InsertType type)
178
    : SQLStatement(kStmtInsert),
179
      type(type),
180
      schema(nullptr),
181
      tableName(nullptr),
182
      columns(nullptr),
183
      values(nullptr),
184
1.57k
      select(nullptr) {}
185
186
1.57k
InsertStatement::~InsertStatement() {
187
1.57k
  free(schema);
188
1.57k
  free(tableName);
189
1.57k
  delete select;
190
191
1.57k
  if (columns) {
192
442
    for (char* column : *columns) {
193
442
      free(column);
194
442
    }
195
248
    delete columns;
196
248
  }
197
198
1.57k
  if (values) {
199
972
    for (Expr* expr : *values) {
200
972
      delete expr;
201
972
    }
202
605
    delete values;
203
605
  }
204
1.57k
}
205
206
// ShowStatament
207
2.49k
ShowStatement::ShowStatement(ShowType type) : SQLStatement(kStmtShow), type(type), schema(nullptr), name(nullptr) {}
208
209
2.49k
ShowStatement::~ShowStatement() {
210
2.49k
  free(schema);
211
2.49k
  free(name);
212
2.49k
}
213
214
// SelectStatement.h
215
216
// OrderDescription
217
71.8k
OrderDescription::OrderDescription(OrderType type, Expr* expr) : type(type), expr(expr) {}
218
219
71.8k
OrderDescription::~OrderDescription() { delete expr; }
220
221
// LimitDescription
222
4.46k
LimitDescription::LimitDescription(Expr* limit, Expr* offset) : limit(limit), offset(offset) {}
223
224
4.46k
LimitDescription::~LimitDescription() {
225
4.46k
  delete limit;
226
4.46k
  delete offset;
227
4.46k
}
228
229
// GroypByDescription
230
1.27k
GroupByDescription::GroupByDescription() : columns(nullptr), having(nullptr) {}
231
232
1.27k
GroupByDescription::~GroupByDescription() {
233
1.27k
  delete having;
234
235
1.27k
  if (columns) {
236
1.66k
    for (Expr* expr : *columns) {
237
1.66k
      delete expr;
238
1.66k
    }
239
1.27k
    delete columns;
240
1.27k
  }
241
1.27k
}
242
243
1.55k
WithDescription::~WithDescription() {
244
1.55k
  free(alias);
245
1.55k
  delete select;
246
1.55k
}
247
248
// SelectStatement
249
SelectStatement::SelectStatement()
250
    : SQLStatement(kStmtSelect),
251
      fromTable(nullptr),
252
      selectDistinct(false),
253
      selectList(nullptr),
254
      whereClause(nullptr),
255
      groupBy(nullptr),
256
      setOperations(nullptr),
257
      order(nullptr),
258
      withDescriptions(nullptr),
259
      limit(nullptr),
260
22.5k
      lockings(nullptr) {}
261
262
22.3k
SelectStatement::~SelectStatement() {
263
22.3k
  delete fromTable;
264
22.3k
  delete whereClause;
265
22.3k
  delete groupBy;
266
22.3k
  delete limit;
267
268
  // Delete each element in the select list.
269
22.3k
  if (selectList) {
270
87.9k
    for (Expr* expr : *selectList) {
271
87.9k
      delete expr;
272
87.9k
    }
273
22.3k
    delete selectList;
274
22.3k
  }
275
276
22.3k
  if (order) {
277
3.59k
    for (OrderDescription* desc : *order) {
278
3.59k
      delete desc;
279
3.59k
    }
280
865
    delete order;
281
865
  }
282
283
22.3k
  if (withDescriptions) {
284
1.55k
    for (WithDescription* desc : *withDescriptions) {
285
1.55k
      delete desc;
286
1.55k
    }
287
364
    delete withDescriptions;
288
364
  }
289
290
22.3k
  if (setOperations) {
291
2.63k
    for (SetOperation* setOperation : *setOperations) {
292
2.63k
      delete setOperation;
293
2.63k
    }
294
2.36k
    delete setOperations;
295
2.36k
  }
296
297
22.3k
  if (lockings) {
298
6.54k
    for (LockingClause* lockingClause : *lockings) {
299
6.54k
      if (lockingClause->tables) {
300
536
        for (char* dtable : *lockingClause->tables) {
301
536
          free(dtable);
302
536
        }
303
206
        delete lockingClause->tables;
304
206
      }
305
6.54k
      delete lockingClause;
306
6.54k
    }
307
450
    delete lockings;
308
450
  }
309
22.3k
}
310
311
// UpdateStatement
312
922
UpdateStatement::UpdateStatement() : SQLStatement(kStmtUpdate), table(nullptr), updates(nullptr), where(nullptr) {}
313
314
922
UpdateStatement::~UpdateStatement() {
315
922
  delete table;
316
922
  delete where;
317
318
922
  if (updates) {
319
133k
    for (UpdateClause* update : *updates) {
320
133k
      free(update->column);
321
133k
      delete update->value;
322
133k
      delete update;
323
133k
    }
324
922
    delete updates;
325
922
  }
326
922
}
327
328
// Alias
329
7.93k
Alias::Alias(char* name, std::vector<char*>* columns) : name(name), columns(columns) {}
330
331
7.93k
Alias::~Alias() {
332
7.93k
  free(name);
333
7.93k
  if (columns) {
334
913
    for (char* column : *columns) {
335
913
      free(column);
336
913
    }
337
317
    delete columns;
338
317
  }
339
7.93k
}
340
341
// TableRef
342
TableRef::TableRef(TableRefType type)
343
264k
    : type(type), schema(nullptr), name(nullptr), alias(nullptr), select(nullptr), list(nullptr), join(nullptr) {}
344
345
264k
TableRef::~TableRef() {
346
264k
  free(schema);
347
264k
  free(name);
348
349
264k
  delete select;
350
264k
  delete join;
351
264k
  delete alias;
352
353
264k
  if (list) {
354
5.33k
    for (TableRef* table : *list) {
355
5.33k
      delete table;
356
5.33k
    }
357
802
    delete list;
358
802
  }
359
264k
}
360
361
0
bool TableRef::hasSchema() const { return schema != nullptr; }
362
363
4.65k
const char* TableRef::getName() const {
364
4.65k
  if (alias)
365
368
    return alias->name;
366
4.28k
  else
367
4.28k
    return name;
368
4.65k
}
369
370
// JoinDefinition
371
111k
JoinDefinition::JoinDefinition() : left(nullptr), right(nullptr), condition(nullptr), type(kJoinInner) {}
372
373
111k
JoinDefinition::~JoinDefinition() {
374
111k
  delete left;
375
111k
  delete right;
376
111k
  delete condition;
377
111k
}
378
379
3.47k
SetOperation::SetOperation() : nestedSelectStatement(nullptr), resultOrder(nullptr), resultLimit(nullptr) {}
380
381
3.47k
SetOperation::~SetOperation() {
382
3.47k
  delete nestedSelectStatement;
383
3.47k
  delete resultLimit;
384
385
3.47k
  if (resultOrder) {
386
2.01k
    for (OrderDescription* desc : *resultOrder) {
387
2.01k
      delete desc;
388
2.01k
    }
389
655
    delete resultOrder;
390
655
  }
391
3.47k
}
392
393
}  // namespace hsql