looqs/shared/sqlitesearch.cpp

#include <QStack>
#include <QRegularExpression>
#include <QSqlQuery>
#include <QSqlError>
#include <QStringList>
#include <QDebug>
#include "sqlitesearch.h"
#include "qssgeneralexception.h"

SqliteSearch::SqliteSearch(QSqlDatabase &db)
{
    this->db = &db;
}

QVector<SqliteSearch::Token> SqliteSearch::tokenize(QString expression)
{
    if(!checkParanthesis(expression))
    {
        throw QSSGeneralException("Invalid paranthesis");
    }
    //TODO: merge lonewords
    QVector<SqliteSearch::Token> result;
    QRegularExpression rx("((?<filtername>(\\.|\\w)+):(?<args>\\((?<innerargs>[^\\)]+)\\)|([\\w,])+)|(?<boolean>AND|OR|!)|(?<bracket>\\(|\\))|(?<loneword>\\w+))");
    QRegularExpressionMatchIterator i = rx.globalMatch(expression);
    auto isSort = [](QString &key) { return key == "sort"; };
    auto isBool = [](QString &key) { return key == "AND" || key == "OR" || key == "!"; };
    while(i.hasNext())
    {
        QRegularExpressionMatch m = i.next();
        QString boolean = m.captured("boolean");
        QString filtername = m.captured("filtername");
        QString bracket = m.captured("bracket");
        QString loneword = m.captured("loneword");

        if(boolean != "")
        {
            result.append(Token(boolean));
        }

        if(!result.empty())
        {
            QString &lastKey = result.last().key;
            if(!isBool(lastKey) && !isSort(lastKey) && !isSort(filtername))
            {
                result.append(Token("AND"));
            }
        }

        if(bracket != "")
        {
           if(bracket == "(")
           {
               result.append(Token("AND"));
           }
          result.append(Token(bracket));
        }


        if(loneword != "")
        {
            result.append(Token("path.contains", loneword));
        }

        if(filtername != "")
        {
            QString value = m.captured("innerargs");
            if(value == "")
            {
                value = m.captured("args");
            }
            result.append(Token(filtername, value));
        }

    }
    return result;
}


QString SqliteSearch::fieldToColumn(QString field)
{
    if(field == "mtime" || field == "file.mtime")
    {
        return "file.mtime";
    }
    else if(field == "page" || field == "content.page")
    {
        return "content.page";
    }
    else if(field == "path" || field == "file.path")
    {
        return "file.path";
    }
    else if(field == "size" || field == "file.size")
    {
        return "file.size";
    }
    return "";
}


QString SqliteSearch::createSortSql(const SqliteSearch::Token &token)
{
    //sort:(mtime desc, page asc)
    if(token.key == "sort")
    {
        QString sortsql;
        QStringList splitted_inner = token.value.split(",");
        for(int i = 0; i < splitted_inner.length(); i++)
        {
            QStringList splitted = splitted_inner[i].split(" ");
            if(splitted.length() < 1 || splitted.length() > 2)
            {
                throw QSSGeneralException("sort specifier must have format [field] (asc|desc)");
            }

            QString field = splitted[0];
            field = fieldToColumn(field);
            if(field == "")
            {
                throw QSSGeneralException("Unknown sort field supplied");
            }

            QString order;
            if(splitted.length() == 2)
            {
                order = splitted[1];
                if(order.compare("asc", Qt::CaseInsensitive) == 0)
                {
                    order = "ASC";
                }
                else if(order.compare("desc", Qt::CaseInsensitive) == 0)
                {
                    order = "DESC";
                }
                else
                {
                    throw QSSGeneralException("Unknown order specifier: " + order);
                }

            }
            else
            {
                order = "ASC";
            }

            sortsql += field + " " + order;
            if(splitted_inner.length() - i > 1)
            {
                sortsql += ", ";
            }
        }
        return " ORDER BY " + sortsql;

    }
    return "";
}

QPair<QString, QVector<QString>> SqliteSearch::createSql(const SqliteSearch::Token &token)
{
    QPair<QString, QVector<QString>> result;

    QString key = token.key;
    QString value = token.value;
    value = value.replace("'", "\\'");
    if(key == "AND" || key == "OR" || key == "(" || key == ")")
    {
        return { " " + key + " ", QVector<QString>() };
    }
    if(key == "!")
    {
        return { " NOT ", QVector<QString>() };
    }
    if(key == "path.starts")
    {
        return { " file.path LIKE ? || '%' ", { value } };
    }
    if(key == "path.ends")
    {
        return { " file.path LIKE '%' || ? ", { value } };
    }
    if(key == "path.contains" || key == "inpath")
    {
        return { " file.path LIKE '%' || ? || '%' ", { value } } ;
    }
    if(key == "page")
    {
        return { " content.page = ?", { value } };
    }
    if(key == "contains" || key == "c")
    {
        return { " content.id IN (SELECT content_fts.ROWID FROM content_fts WHERE content_fts.content MATCH ?) " , { value } };
    }
    throw QSSGeneralException("Unknown token: " + key);
}

QSqlQuery SqliteSearch::makeSqlQuery(const QVector<SqliteSearch::Token> &tokens)
{
    QString whereSql;
    QString limitSql;
    QString sortSql;
    QVector<QString> bindValues;
    bool isContentSearch = false;
    for(const Token &c : tokens)
    {
        if(c.key == "sort")
        {
            if(sortSql != "")
            {
                throw QSSGeneralException("Invalid input: Two seperate sort statements are invalid");
            }
            sortSql = createSortSql(c);
        }
        else
        {
            if(c.key == "c" || c.key == "contains")
            {
                isContentSearch = true;
            }
            auto sql = createSql(c);
            whereSql += sql.first;
            bindValues.append(sql.second);
        }
    }

    QString prepSql;
    if(whereSql.isEmpty())
    {
        throw QSSGeneralException("Nothing to search for supplied");
    }
    if(isContentSearch)
    {
        if(sortSql.isEmpty())
        {
            sortSql =  "ORDER BY file.mtime DESC, content.page ASC";
        }
        prepSql = "SELECT file.path AS path, group_concat(content.page) AS pages, file.mtime AS mtime, file.size AS size, file.filetype AS filetype FROM file INNER JOIN content ON file.id = content.fileid WHERE 1=1 AND " + whereSql + " GROUP BY file.path  " + sortSql;
    }
    else
    {
        if(sortSql.isEmpty())
        {
            sortSql =  "ORDER BY file.mtime DESC";
        }
        if(sortSql.contains("content."))
        {
            throw QSSGeneralException("Cannot sort for content fields when not doing a content search");
        }

        prepSql = "SELECT file.path AS path, '0' as pages,  file.mtime AS mtime, file.size AS size, file.filetype AS filetype FROM file WHERE  1=1 AND " + whereSql + " " + sortSql;
    }

    QSqlQuery dbquery(*db);
    dbquery.prepare(prepSql);

    for(const QString &value : bindValues)
    {
        if(value != "")
        {
            dbquery.addBindValue(value);
        }
    }
   return dbquery;
}



QVector<SearchResult> SqliteSearch::search(const QString &query)
{
    QVector<SearchResult> results;
    QSqlQuery dbQuery = makeSqlQuery(tokenize(query));
    bool success = dbQuery.exec();
    if(!success)
    {

        qDebug() << dbQuery.lastError();
        qDebug() << dbQuery.executedQuery();
        throw QSSGeneralException("SQL Error: " + dbQuery.lastError().text());
    }

    while(dbQuery.next())
    {
        SearchResult result;
        result.fileData.absPath = dbQuery.value("path").toString();
        result.fileData.mtime = dbQuery.value("mtime").toUInt();
        result.fileData.size = dbQuery.value("size").toUInt();
        result.fileData.filetype = dbQuery.value("filetype").toChar();
        QString pages = dbQuery.value("pages").toString();
        QStringList pagesList = pages.split(",");
        for(QString &page : pagesList)
        {
            if(page != "")
            {
                result.pages.append(page.toUInt());
            }
        }
        results.append(result);
    }
    return results;
}

bool SqliteSearch::checkParanthesis(QString expression)
{
    QStack<QChar> open;
    QStack<QChar> close;

    for(QChar &c : expression)
    {
        if(c == '(')
        {
            open.push(c);
        }
        if(c == ')')
        {
            close.push(c);
        }
    }
    if(open.size() != close.size())
    {
        return false;
    }
    while(!open.empty() && !close.empty())
    {
        QChar o = open.pop();
        QChar c = close.pop();
        if(o != '(' && c != ')' )
        {
            return false;
        }
    }
    return true;
}