File: queryexecutororder.cpp

package info (click to toggle)
sqlitestudio 3.4.21%2Bds-1
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 54,880 kB
  • sloc: ansic: 406,208; cpp: 123,872; yacc: 2,692; tcl: 497; sh: 462; xml: 426; makefile: 19
file content (83 lines) | stat: -rw-r--r-- 2,471 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include "queryexecutororder.h"
#include "common/utils_sql.h"
#include "parser/parser.h"
#include <QDebug>

bool QueryExecutorOrder::exec()
{
    SqliteSelectPtr select = getSelect();
    if (!select || select->explain)
        return true;

    QueryExecutor::SortList sortOrder = queryExecutor->getSortOrder();
    if (sortOrder.size() == 0)
        return true; // no sorting requested

    if (select->tokens.size() < 1)
        return true; // shouldn't happen, but if happens, leave gracefully

    TokenList tokens = getOrderTokens(sortOrder);
    if (tokens.size() == 0)
    {
        // happens in cases like #4819
        queryExecutor->setSortOrder(QueryExecutor::SortList());
        return true;
    }

    static_qstring(selectTpl, "SELECT * FROM (%1) ORDER BY %2");
    QString newSelect = selectTpl.arg(select->detokenize(), tokens.detokenize());

    Parser parser;
    if (!parser.parse(newSelect) || parser.getQueries().size() == 0)
    {
        qWarning() << "Could not parse SELECt after applying order. Tried to parse query:\n" << newSelect;
        return false;
    }

    context->parsedQueries.removeLast();
    context->parsedQueries << parser.getQueries().first();

    updateQueries();
    return true;
}

TokenList QueryExecutorOrder::getOrderTokens(const QueryExecutor::SortList& sortOrder)
{
    TokenList tokens;
    QueryExecutor::ResultColumnPtr resCol;
    bool next = false;
    for (const QueryExecutor::Sort& sort : sortOrder)
    {
        if (sort.column >= context->resultColumns.size())
        {
            qCritical() << "There is less result columns in query executor context than index of requested sort column";
            return TokenList();
        }

        if (next)
        {
            tokens << TokenPtr::create(Token::OPERATOR, ",");
            tokens << TokenPtr::create(Token::SPACE, " ");
        }
        else
            next = true;

        resCol = context->resultColumns[sort.column];

        tokens << TokenPtr::create(Token::OTHER, resCol->queryExecutorAlias);
        tokens << TokenPtr::create(Token::SPACE, " ");

        if (sort.order == QueryExecutor::Sort::DESC)
        {
            tokens << TokenPtr::create(Token::KEYWORD, "DESC");
            tokens << TokenPtr::create(Token::SPACE, " ");
        }
        else
        {
            tokens << TokenPtr::create(Token::KEYWORD, "ASC");
            tokens << TokenPtr::create(Token::SPACE, " ");
        }
    }

    return tokens;
}