/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 |