querybuilder.h

/*
    SPDX-FileCopyrightText: 2007 Volker Krause <[email protected]>

    SPDX-License-Identifier: LGPL-2.0-or-later
*/

#ifndef AKONADI_QUERYBUILDER_H
#define AKONADI_QUERYBUILDER_H

#include "query.h"
#include "dbtype.h"

#include <QPair>
#include <QString>
#include <QStringList>
#include <QVariant>
#include <QVector>
#include <QSqlQuery>

#ifdef QUERYBUILDER_UNITTEST
class QueryBuilderTest;
#endif

namespace Akonadi
{
namespace Server
{

class QueryBuilder
{
public:
    enum QueryType {
        Select,
        Insert,
        Update,
        Delete
    };

    enum JoinType {
        InnerJoin,
        LeftJoin
    };

    enum ConditionType {
        WhereCondition,
        HavingCondition,

        NUM_CONDITIONS
    };

    explicit QueryBuilder(const QString &table, QueryType type = Select);

    void setDatabaseType(DbType::Type type);

    void addJoin(JoinType joinType, const QString &table, const Query::Condition &condition);

    void addJoin(JoinType joinType, const QString &table, const QString &col1, const QString &col2);

    void addColumns(const QStringList &cols);

    void addColumn(const QString &col);

    void addColumn(const Query::Case &caseStmt);

    void addAggregation(const QString &col, const QString &aggregate);

    void addAggregation(const Query::Case &caseStmt, const QString &aggregate);

    void addValueCondition(const QString &column, Query::CompareOperator op, const QVariant &value, ConditionType type = WhereCondition);

    void addColumnCondition(const QString &column, Query::CompareOperator op, const QString &column2, ConditionType type = WhereCondition);

    void addCondition(const Query::Condition &condition, ConditionType type = WhereCondition);

    void setSubQueryMode(Query::LogicOperator op, ConditionType type = WhereCondition);

    void addSortColumn(const QString &column, Query::SortOrder order = Query::Ascending);

    void addGroupColumn(const QString &column);

    void addGroupColumns(const QStringList &columns);

    void setColumnValue(const QString &column, const QVariant &value);

    void setDistinct(bool distinct);

    void setLimit(int limit);

    void setIdentificationColumn(const QString &column);

    QSqlQuery &query();

    bool exec();

    qint64 insertId();

    void setForUpdate(bool forUpdate = true);

private:
    void buildQuery(QString *query);
    void bindValue(QString *query, const QVariant &value);
    void buildWhereCondition(QString *query, const Query::Condition &cond);
    void buildCaseStatement(QString *query, const Query::Case &caseStmt);

    void sqliteAdaptUpdateJoin(Query::Condition &cond);

private:
    QString mTable;
    DbType::Type mDatabaseType;
    Query::Condition mRootCondition[NUM_CONDITIONS];
    QSqlQuery mQuery;
    QueryType mType;
    QStringList mColumns;
    QVector<QVariant> mBindValues;
    QVector<QPair<QString, Query::SortOrder> > mSortColumns;
    QStringList mGroupColumns;
    QVector<QPair<QString, QVariant> > mColumnValues;
    QString mIdentificationColumn;

    // we must make sure that the tables are joined in the correct order
    // QMap sorts by key which might invalidate the queries
    QStringList mJoinedTables;
    QMap< QString, QPair< JoinType, Query::Condition > > mJoins;
    int mLimit;
    bool mDistinct;
    bool mForUpdate = false;
#ifdef QUERYBUILDER_UNITTEST
    QString mStatement;
    friend class ::QueryBuilderTest;
#endif
};

} // namespace Server
} // namespace Akonadi

#endif