1 #include "sqliteexpr.h"
2 #include "sqliteraise.h"
3 #include "sqliteselect.h"
4 #include "sqlitecolumntype.h"
5 #include "sqlitefilterover.h"
6 #include "parser/statementtokenbuilder.h"
7 #include "common/utils_sql.h"
8 #include "common/global.h"
9 #include <QDebug>
10
SqliteExpr()11 SqliteExpr::SqliteExpr()
12 {
13 }
14
SqliteExpr(const SqliteExpr & other)15 SqliteExpr::SqliteExpr(const SqliteExpr& other) :
16 SqliteStatement(other),
17 mode(other.mode), literalValue(other.literalValue), literalNull(other.literalNull), bindParam(other.bindParam), database(other.database), table(other.table),
18 column(other.column), unaryOp(other.unaryOp), binaryOp(other.binaryOp), function(other.function), collation(other.collation),
19 ctime(other.ctime), distinctKw(other.distinctKw), allKw(other.allKw), star(other.star), notKw(other.notKw), like(other.like),
20 notNull(other.notNull), possibleDoubleQuotedString(other.possibleDoubleQuotedString)
21 {
22 DEEP_COPY_FIELD(SqliteColumnType, columnType);
23 DEEP_COPY_FIELD(SqliteExpr, expr1);
24 DEEP_COPY_FIELD(SqliteExpr, expr2);
25 DEEP_COPY_FIELD(SqliteExpr, expr3);
26 DEEP_COPY_COLLECTION(SqliteExpr, exprList);
27 DEEP_COPY_FIELD(SqliteSelect, select);
28 DEEP_COPY_FIELD(SqliteRaise, raiseFunction);
29 DEEP_COPY_FIELD(SqliteFilterOver, filterOver);
30 }
31
~SqliteExpr()32 SqliteExpr::~SqliteExpr()
33 {
34 }
35
likeOp(const QString & value)36 SqliteExpr::LikeOp SqliteExpr::likeOp(const QString &value)
37 {
38 QString upper = value.toUpper();
39 if (upper == "LIKE")
40 return SqliteExpr::LikeOp::LIKE;
41 else if (upper == "GLOB")
42 return SqliteExpr::LikeOp::GLOB;
43 else if (upper == "REGEXP")
44 return SqliteExpr::LikeOp::REGEXP;
45 else if (upper == "MATCH")
46 return SqliteExpr::LikeOp::MATCH;
47 else
48 return SqliteExpr::LikeOp::null;
49 }
50
likeOp(SqliteExpr::LikeOp value)51 QString SqliteExpr::likeOp(SqliteExpr::LikeOp value)
52 {
53 switch (value)
54 {
55 case SqliteExpr::LikeOp::LIKE:
56 return "LIKE";
57 case SqliteExpr::LikeOp::GLOB:
58 return "GLOB";
59 case SqliteExpr::LikeOp::REGEXP:
60 return "REGEXP";
61 case SqliteExpr::LikeOp::MATCH:
62 return "MATCH";
63 default:
64 return QString();
65 }
66 }
67
notNullOp(const QString & value)68 SqliteExpr::NotNull SqliteExpr::notNullOp(const QString &value)
69 {
70 QString upper = value.toUpper();
71 if (upper == "ISNULL")
72 return SqliteExpr::NotNull::ISNULL;
73 else if (upper == "NOTNULL")
74 return SqliteExpr::NotNull::NOTNULL;
75 else if (upper == "NOT NULL")
76 return SqliteExpr::NotNull::NOT_NULL;
77 else
78 return SqliteExpr::NotNull::null;
79 }
80
notNullOp(SqliteExpr::NotNull value)81 QString SqliteExpr::notNullOp(SqliteExpr::NotNull value)
82 {
83 switch (value)
84 {
85 case SqliteExpr::NotNull::ISNULL:
86 return "ISNULL";
87 case SqliteExpr::NotNull::NOT_NULL:
88 return "NOT NULL";
89 case SqliteExpr::NotNull::NOTNULL:
90 return "NOTNULL";
91 default:
92 return QString();
93 }
94 }
95
clone()96 SqliteStatement* SqliteExpr::clone()
97 {
98 return new SqliteExpr(*this);
99 }
100
initLiteral(const QVariant & value)101 void SqliteExpr::initLiteral(const QVariant &value)
102 {
103 mode = SqliteExpr::Mode::LITERAL_VALUE;
104 if (value.isNull())
105 initNull();
106
107 literalValue = value;
108 }
109
initNull()110 void SqliteExpr::initNull()
111 {
112 literalNull = true;
113 }
114
initCTime(const QString & name)115 void SqliteExpr::initCTime(const QString &name)
116 {
117 mode = SqliteExpr::Mode::CTIME;
118 ctime = name;
119 }
120
initSubExpr(SqliteExpr * expr)121 void SqliteExpr::initSubExpr(SqliteExpr *expr)
122 {
123 mode = SqliteExpr::Mode::SUB_EXPR;
124 expr1 = expr;
125 if (expr)
126 expr->setParent(this);
127 }
128
initRowValue(const QList<SqliteExpr * > & exprList)129 void SqliteExpr::initRowValue(const QList<SqliteExpr*> &exprList)
130 {
131 if (exprList.size() == 1)
132 {
133 initSubExpr(exprList.first());
134 return;
135 }
136
137 mode = SqliteExpr::Mode::ROW_VALUE;
138 this->exprList = exprList;
139
140 for (SqliteExpr* expr : exprList)
141 expr->setParent(this);
142 }
143
initBindParam(const QString & value)144 void SqliteExpr::initBindParam(const QString& value)
145 {
146 mode = SqliteExpr::Mode::BIND_PARAM;
147 bindParam = value;
148 }
149
initCollate(SqliteExpr * expr,const QString & value)150 void SqliteExpr::initCollate(SqliteExpr *expr, const QString& value)
151 {
152 mode = SqliteExpr::Mode::COLLATE;
153 expr1 = expr;
154 collation = value;
155 if (expr)
156 expr->setParent(this);
157 }
158
initCast(SqliteExpr * expr,SqliteColumnType * type)159 void SqliteExpr::initCast(SqliteExpr *expr, SqliteColumnType *type)
160 {
161 mode = SqliteExpr::Mode::CAST;
162 expr1 = expr;
163 columnType = type;
164 if (expr)
165 expr->setParent(this);
166 }
167
initFunction(const QString & fnName,int distinct,const QList<SqliteExpr * > & exprList)168 void SqliteExpr::initFunction(const QString& fnName, int distinct, const QList<SqliteExpr*>& exprList)
169 {
170 mode = SqliteExpr::Mode::FUNCTION;
171 function = fnName;
172 this->exprList = exprList;
173 initDistinct(distinct);
174
175 for (SqliteExpr* expr : exprList)
176 expr->setParent(this);
177 }
178
initFunction(const QString & fnName,bool star)179 void SqliteExpr::initFunction(const QString& fnName, bool star)
180 {
181 mode = SqliteExpr::Mode::FUNCTION;
182 function = fnName;
183 this->star = star;
184 }
185
initWindowFunction(const QString & fnName,int distinct,const QList<SqliteExpr * > & exprList,SqliteFilterOver * filterOver)186 void SqliteExpr::initWindowFunction(const QString& fnName, int distinct, const QList<SqliteExpr*>& exprList, SqliteFilterOver* filterOver)
187 {
188 mode = SqliteExpr::Mode::WINDOW_FUNCTION;
189 this->function = fnName;
190 this->exprList = exprList;
191 initDistinct(distinct);
192 this->filterOver = filterOver;
193
194 for (SqliteExpr* expr : exprList)
195 expr->setParent(this);
196
197 if (filterOver)
198 filterOver->setParent(this);
199 }
200
initWindowFunction(const QString & fnName,SqliteFilterOver * filterOver)201 void SqliteExpr::initWindowFunction(const QString& fnName, SqliteFilterOver* filterOver)
202 {
203 mode = SqliteExpr::Mode::WINDOW_FUNCTION;
204 this->function = fnName;
205 this->star = true;
206 this->filterOver = filterOver;
207
208 if (filterOver)
209 filterOver->setParent(this);
210 }
211
initBinOp(SqliteExpr * expr1,const QString & op,SqliteExpr * expr2)212 void SqliteExpr::initBinOp(SqliteExpr *expr1, const QString& op, SqliteExpr *expr2)
213 {
214 mode = SqliteExpr::Mode::BINARY_OP;
215 this->expr1 = expr1;
216 this->expr2 = expr2;
217 binaryOp = op;
218 if (expr1)
219 expr1->setParent(this);
220
221 if (expr2)
222 expr2->setParent(this);
223 }
224
initUnaryOp(SqliteExpr * expr,const QString & op)225 void SqliteExpr::initUnaryOp(SqliteExpr *expr, const QString& op)
226 {
227 mode = SqliteExpr::Mode::UNARY_OP;
228 expr1 = expr;
229 unaryOp = op;
230 if (expr)
231 expr->setParent(this);
232 }
233
initLike(SqliteExpr * expr1,bool notKw,LikeOp likeOp,SqliteExpr * expr2,SqliteExpr * expr3)234 void SqliteExpr::initLike(SqliteExpr *expr1, bool notKw, LikeOp likeOp, SqliteExpr *expr2, SqliteExpr *expr3)
235 {
236 mode = SqliteExpr::Mode::LIKE;
237 this->expr1 = expr1;
238 this->expr2 = expr2;
239 this->expr3 = expr3;
240 this->notKw = notKw;
241 this->like = likeOp;
242 if (expr1)
243 expr1->setParent(this);
244
245 if (expr2)
246 expr2->setParent(this);
247
248 if (expr3)
249 expr3->setParent(this);
250 }
251
initNull(SqliteExpr * expr,const QString & value)252 void SqliteExpr::initNull(SqliteExpr *expr, const QString& value)
253 {
254 mode = SqliteExpr::Mode::NOTNULL;
255 expr1 = expr;
256 notNull = notNullOp(value);
257 if (expr)
258 expr->setParent(this);
259 }
260
initIs(SqliteExpr * expr1,bool notKw,SqliteExpr * expr2)261 void SqliteExpr::initIs(SqliteExpr *expr1, bool notKw, SqliteExpr *expr2)
262 {
263 mode = SqliteExpr::Mode::IS;
264 this->expr1 = expr1;
265 this->notKw = notKw;
266 this->expr2 = expr2;
267 if (expr1)
268 expr1->setParent(this);
269
270 if (expr2)
271 expr2->setParent(this);
272 }
273
initBetween(SqliteExpr * expr1,bool notKw,SqliteExpr * expr2,SqliteExpr * expr3)274 void SqliteExpr::initBetween(SqliteExpr *expr1, bool notKw, SqliteExpr *expr2, SqliteExpr *expr3)
275 {
276 mode = SqliteExpr::Mode::BETWEEN;
277 this->expr1 = expr1;
278 this->expr2 = expr2;
279 this->expr3 = expr3;
280 this->notKw = notKw;
281 if (expr1)
282 expr1->setParent(this);
283
284 if (expr2)
285 expr2->setParent(this);
286
287 if (expr3)
288 expr3->setParent(this);
289 }
290
initIn(SqliteExpr * expr,bool notKw,const QList<SqliteExpr * > & exprList)291 void SqliteExpr::initIn(SqliteExpr *expr, bool notKw, const QList<SqliteExpr*>& exprList)
292 {
293 mode = SqliteExpr::Mode::IN;
294 expr1 = expr;
295 this->notKw = notKw;
296 this->exprList = exprList;
297 for (SqliteExpr* expr : exprList)
298 expr->setParent(this);
299 }
300
initIn(SqliteExpr * expr,bool notKw,SqliteSelect * select)301 void SqliteExpr::initIn(SqliteExpr *expr, bool notKw, SqliteSelect *select)
302 {
303 mode = SqliteExpr::Mode::IN;
304 expr1 = expr;
305 this->notKw = notKw;
306 this->select = select;
307 if (expr)
308 expr->setParent(this);
309
310 if (select)
311 select->setParent(this);
312 }
313
initIn(SqliteExpr * expr,bool notKw,const QString & name1,const QString & name2)314 void SqliteExpr::initIn(SqliteExpr *expr, bool notKw, const QString& name1, const QString& name2)
315 {
316 mode = SqliteExpr::Mode::IN;
317 expr1 = expr;
318 this->notKw = notKw;
319 if (!name2.isNull())
320 {
321 database = name1;
322 table = name2;
323 }
324 else
325 table = name1;
326
327 if (expr)
328 expr->setParent(this);
329 }
330
initExists(SqliteSelect * select)331 void SqliteExpr::initExists(SqliteSelect *select)
332 {
333 mode = SqliteExpr::Mode::EXISTS;
334 this->select = select;
335 if (select)
336 select->setParent(this);
337 }
338
initSubSelect(SqliteSelect * select)339 void SqliteExpr::initSubSelect(SqliteSelect *select)
340 {
341 mode = SqliteExpr::Mode::SUB_SELECT;
342 this->select = select;
343 if (select)
344 select->setParent(this);
345 }
346
initCase(SqliteExpr * expr1,const QList<SqliteExpr * > & exprList,SqliteExpr * expr2)347 void SqliteExpr::initCase(SqliteExpr *expr1, const QList<SqliteExpr*>& exprList, SqliteExpr *expr2)
348 {
349 mode = SqliteExpr::Mode::CASE;
350 this->expr1 = expr1;
351 this->expr2 = expr2;
352 this->exprList = exprList;
353 if (expr1)
354 expr1->setParent(this);
355
356 if (expr2)
357 expr2->setParent(this);
358
359 for (SqliteExpr* expr : exprList)
360 expr->setParent(this);
361 }
362
initRaise(const QString & type,const QString & text)363 void SqliteExpr::initRaise(const QString& type, const QString& text)
364 {
365 mode = SqliteExpr::Mode::RAISE;
366 raiseFunction = new SqliteRaise(type, text);
367 }
368
detectDoubleQuotes(bool recursively)369 void SqliteExpr::detectDoubleQuotes(bool recursively)
370 {
371 if (doubleQuotesChecked)
372 return;
373
374 doubleQuotesChecked = true;
375
376 if (tokens.size() > 0)
377 {
378 QString val = tokens.first()->value;
379 if (val[0] == '"' && val[0] == val[val.length() - 1])
380 possibleDoubleQuotedString = true;
381 }
382
383 for (SqliteStatement* stmt : childStatements())
384 {
385 SqliteExpr* subExpr = dynamic_cast<SqliteExpr*>(stmt);
386 if (subExpr)
387 subExpr->detectDoubleQuotes(recursively);
388 }
389 }
390
replace(SqliteExpr * toBeReplaced,SqliteExpr * replaceWith)391 bool SqliteExpr::replace(SqliteExpr* toBeReplaced, SqliteExpr* replaceWith)
392 {
393 if (expr1 == toBeReplaced)
394 {
395 expr1 = replaceWith;
396 return true;
397 }
398
399 if (expr2 == toBeReplaced)
400 {
401 expr2 = replaceWith;
402 return true;
403 }
404
405 if (expr3 == toBeReplaced)
406 {
407 expr3 = replaceWith;
408 return true;
409 }
410
411 int idx = exprList.indexOf(toBeReplaced);
412 if (idx > -1)
413 {
414 exprList.replace(idx, replaceWith);
415 return true;
416 }
417
418 return false;
419 }
420
getColumnsInStatement()421 QStringList SqliteExpr::getColumnsInStatement()
422 {
423 return getStrListFromValue(column);
424 }
425
getTablesInStatement()426 QStringList SqliteExpr::getTablesInStatement()
427 {
428 return getStrListFromValue(table);
429 }
430
getDatabasesInStatement()431 QStringList SqliteExpr::getDatabasesInStatement()
432 {
433 return getStrListFromValue(database);
434 }
435
getColumnTokensInStatement()436 TokenList SqliteExpr::getColumnTokensInStatement()
437 {
438 TokenList list;
439 if (!column.isNull())
440 {
441 if (!table.isNull())
442 {
443 if (!database.isNull())
444 list << tokens[4];
445 else
446 list << tokens[2];
447 }
448 else
449 list << tokens[0];
450 }
451 return list;
452 }
453
getTableTokensInStatement()454 TokenList SqliteExpr::getTableTokensInStatement()
455 {
456 TokenList list;
457 if (!table.isNull())
458 {
459 if (!database.isNull())
460 list << tokens[2];
461 else
462 list << tokens[0];
463 }
464
465 return list;
466 }
467
getDatabaseTokensInStatement()468 TokenList SqliteExpr::getDatabaseTokensInStatement()
469 {
470 TokenList list;
471 if (!database.isNull())
472 list << tokens[0];
473
474 return list;
475 }
476
getFullObjectsInStatement()477 QList<SqliteStatement::FullObject> SqliteExpr::getFullObjectsInStatement()
478 {
479 QList<FullObject> result;
480 if (mode != Mode::ID)
481 return result;
482
483 if (!table.isNull())
484 {
485 if (!database.isNull())
486 {
487 FullObject dbFullObject = getDbFullObject(tokens[0]);
488 result << dbFullObject;
489 dbTokenForFullObjects = dbFullObject.database;
490
491 result << getFullObject(FullObject::TABLE, dbTokenForFullObjects, tokens[2]);
492 }
493 else
494 result << getFullObject(FullObject::TABLE, dbTokenForFullObjects, tokens[0]);
495 }
496
497 return result;
498 }
499
initId(const QString & db,const QString & table,const QString & column)500 void SqliteExpr::initId(const QString &db, const QString &table, const QString &column)
501 {
502 mode = SqliteExpr::Mode::ID;
503 database = db;
504 this->table = table;
505 this->column = column;
506 }
507
initId(const QString & table,const QString & column)508 void SqliteExpr::initId(const QString& table, const QString& column)
509 {
510 mode = SqliteExpr::Mode::ID;
511 this->table = table;
512 this->column = column;
513 }
514
initId(const QString & column)515 void SqliteExpr::initId(const QString& column)
516 {
517 mode = SqliteExpr::Mode::ID;
518 this->column = column;
519 }
520
rebuildTokensFromContents()521 TokenList SqliteExpr::rebuildTokensFromContents()
522 {
523 StatementTokenBuilder builder;
524
525 switch (mode)
526 {
527 case SqliteExpr::Mode::null:
528 break;
529 case SqliteExpr::Mode::LITERAL_VALUE:
530 {
531 if (literalNull)
532 builder.withKeyword("NULL");
533 else
534 builder.withLiteralValue(literalValue);
535 break;
536 }
537 case SqliteExpr::Mode::CTIME:
538 builder.withKeyword(ctime.toUpper());
539 break;
540 case SqliteExpr::Mode::BIND_PARAM:
541 builder.withBindParam(bindParam);
542 break;
543 case SqliteExpr::Mode::ID:
544 builder.withTokens(rebuildId());
545 break;
546 case SqliteExpr::Mode::UNARY_OP:
547 builder.withOperator(unaryOp).withSpace().withStatement(expr1);
548 break;
549 case SqliteExpr::Mode::BINARY_OP:
550 builder.withStatement(expr1).withSpace().withOperator(binaryOp).withSpace().withStatement(expr2);
551 break;
552 case SqliteExpr::Mode::FUNCTION:
553 builder.withOther(function).withParLeft();
554 if (distinctKw)
555 builder.withKeyword("DISTINCT");
556 else if (allKw)
557 builder.withKeyword("DISTINCT");
558
559 if (star)
560 builder.withOperator("*").withParRight();
561 else
562 builder.withStatementList(exprList).withParRight();
563
564 break;
565 case SqliteExpr::Mode::WINDOW_FUNCTION:
566 builder.withOther(function).withParLeft();
567 if (distinctKw)
568 builder.withKeyword("DISTINCT");
569 else if (allKw)
570 builder.withKeyword("DISTINCT");
571
572 if (star)
573 builder.withOperator("*").withParRight();
574 else
575 builder.withStatementList(exprList).withParRight();
576
577 builder.withSpace().withStatement(filterOver);
578 break;
579 case SqliteExpr::Mode::SUB_EXPR:
580 builder.withParLeft().withStatement(expr1).withParRight();
581 break;
582 case SqliteExpr::Mode::CAST:
583 builder.withKeyword("CAST").withSpace().withParLeft().withStatement(expr1).withSpace().withKeyword("AS")
584 .withStatement(columnType).withParRight();
585 break;
586 case SqliteExpr::Mode::COLLATE:
587 builder.withStatement(expr1).withSpace().withKeyword("COLLATE").withSpace().withOther(collation);
588 break;
589 case SqliteExpr::Mode::LIKE:
590 builder.withTokens(rebuildLike());
591 break;
592 case SqliteExpr::Mode::NULL_:
593 builder.withKeyword("NULL");
594 break;
595 case SqliteExpr::Mode::NOTNULL:
596 builder.withStatement(expr1).withSpace().withTokens(rebuildNotNull());
597 break;
598 case SqliteExpr::Mode::IS:
599 builder.withTokens(rebuildIs());
600 break;
601 case SqliteExpr::Mode::BETWEEN:
602 builder.withTokens(rebuildBetween());
603 break;
604 case SqliteExpr::Mode::IN:
605 builder.withTokens(rebuildIn());
606 break;
607 case SqliteExpr::Mode::ROW_VALUE:
608 builder.withParLeft().withStatementList(exprList).withParRight();
609 break;
610 case SqliteExpr::Mode::EXISTS:
611 builder.withKeyword("EXISTS").withParLeft().withStatement(select).withParRight();
612 break;
613 case SqliteExpr::Mode::CASE:
614 builder.withTokens(rebuildCase());
615 break;
616 case SqliteExpr::Mode::SUB_SELECT:
617 builder.withParLeft().withStatement(select).withParRight();
618 break;
619 case SqliteExpr::Mode::RAISE:
620 builder.withStatement(raiseFunction);
621 break;
622 }
623
624 return builder.build();
625 }
626
evaluatePostParsing()627 void SqliteExpr::evaluatePostParsing()
628 {
629 detectDoubleQuotes(false); // not recursively, as SqliteStatement will take care of recursiveness
630 }
631
rebuildId()632 TokenList SqliteExpr::rebuildId()
633 {
634 StatementTokenBuilder builder;
635 if (!database.isNull())
636 builder.withOther(database).withOperator(".");
637
638 if (!table.isNull())
639 builder.withOther(table).withOperator(".");
640
641 if (table.isNull() && possibleDoubleQuotedString)
642 builder.withStringPossiblyOther(column);
643 else
644 builder.withOther(column);
645
646 return builder.build();
647 }
648
rebuildLike()649 TokenList SqliteExpr::rebuildLike()
650 {
651 StatementTokenBuilder builder;
652 builder.withStatement(expr1).withSpace();
653 if (notKw)
654 builder.withKeyword("NOT").withSpace();
655
656 builder.withKeyword(likeOp(like)).withSpace().withStatement(expr2);
657 if (expr3)
658 builder.withSpace().withKeyword("ESCAPE").withStatement(expr3);
659
660 return builder.build();
661 }
662
rebuildNotNull()663 TokenList SqliteExpr::rebuildNotNull()
664 {
665 StatementTokenBuilder builder;
666 switch (notNull)
667 {
668 case SqliteExpr::NotNull::ISNULL:
669 builder.withKeyword("ISNULL");
670 break;
671 case SqliteExpr::NotNull::NOT_NULL:
672 builder.withKeyword("NOT").withSpace().withKeyword("NULL");
673 break;
674 case SqliteExpr::NotNull::NOTNULL:
675 builder.withKeyword("NOTNULL");
676 break;
677 case SqliteExpr::NotNull::null:
678 break;
679 }
680 return builder.build();
681 }
682
rebuildIs()683 TokenList SqliteExpr::rebuildIs()
684 {
685 StatementTokenBuilder builder;
686 builder.withStatement(expr1).withSpace().withKeyword("IS");
687 if (notKw)
688 builder.withSpace().withKeyword("NOT");
689
690 builder.withStatement(expr2);
691 return builder.build();
692 }
693
rebuildBetween()694 TokenList SqliteExpr::rebuildBetween()
695 {
696 StatementTokenBuilder builder;
697 builder.withStatement(expr1);
698
699 if (notKw)
700 builder.withSpace().withKeyword("NOT");
701
702 builder.withSpace().withKeyword("BETWEEN").withStatement(expr2).withSpace().withKeyword("AND").withStatement(expr3);
703 return builder.build();
704 }
705
rebuildIn()706 TokenList SqliteExpr::rebuildIn()
707 {
708 StatementTokenBuilder builder;
709 builder.withStatement(expr1);
710
711 if (notKw)
712 builder.withSpace().withKeyword("NOT");
713
714 builder.withSpace().withKeyword("IN").withSpace();
715 if (select)
716 {
717 builder.withParLeft().withStatement(select).withParRight();
718 }
719 else if (exprList.size() > 0)
720 {
721 builder.withParLeft().withStatementList(exprList).withParRight();
722 }
723 else
724 {
725 if (!database.isNull())
726 builder.withOther(database).withOperator(".");
727
728 builder.withOther(table);
729 }
730 return builder.build();
731 }
732
rebuildCase()733 TokenList SqliteExpr::rebuildCase()
734 {
735 StatementTokenBuilder builder;
736 builder.withKeyword("CASE");
737 if (expr1)
738 builder.withStatement(expr1);
739
740 builder.withSpace();
741
742 bool then = false;
743 for (SqliteExpr* expr : exprList)
744 {
745 if (then)
746 builder.withKeyword("THEN");
747 else
748 builder.withKeyword("WHEN");
749
750 builder.withStatement(expr).withSpace();
751 then = !then;
752 }
753
754 if (expr2)
755 builder.withKeyword("ELSE").withStatement(expr2).withSpace();
756
757 builder.withKeyword("END");
758 return builder.build();
759 }
760
initDistinct(int distinct)761 void SqliteExpr::initDistinct(int distinct)
762 {
763 if (distinct == 1)
764 distinctKw = true;
765 else if (distinct == 2)
766 allKw = true;
767 }
768