qgssqlstatement.h

Go to the documentation of this file.

/***************************************************************************
                               qgssqlstatement.h
                             ---------------------
    begin                : April 2016
    copyright            : (C) 2011 by Martin Dobias
    copyright            : (C) 2016 by Even Rouault
    email                : even.rouault at spatialys.com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef QGSSQLSTATEMENT_H
#define QGSSQLSTATEMENT_H

#include <QCoreApplication>
#include "qgis_sip.h"
#include "qgis.h"
#include <QMetaType>
#include <QStringList>
#include <QVariant>
#include <QList>
#include <QSet>

#include "qgis_core.h"

class CORE_EXPORT QgsSQLStatement
{
    Q_DECLARE_TR_FUNCTIONS( QgsSQLStatement )
  public:

    QgsSQLStatement( const QString &statement );

    QgsSQLStatement( const QgsSQLStatement &other );

    QgsSQLStatement &operator=( const QgsSQLStatement &other );
    ~QgsSQLStatement();

    bool hasParserError() const;
    QString parserErrorString() const;

    bool doBasicValidationChecks( QString &errorMsgOut SIP_OUT ) const;

    class Node;

    const QgsSQLStatement::Node *rootNode() const;

    QString statement() const;

    QString dump() const;

    static QString quotedIdentifier( QString name );

    static QString quotedIdentifierIfNeeded( const QString &name );

    static QString stripQuotedIdentifier( QString text );

    static QString quotedString( QString text );

    enum UnaryOperator
    {
      uoNot,
      uoMinus,
    };

    enum BinaryOperator
    {
      // logical
      boOr,
      boAnd,

      // comparison
      boEQ,  // =
      boNE,  // <>
      boLE,  // <=
      boGE,  // >=
      boLT,  // <
      boGT,  // >
      boLike,
      boNotLike,
      boILike,
      boNotILike,
      boIs,
      boIsNot,

      // math
      boPlus,
      boMinus,
      boMul,
      boDiv,
      boIntDiv,
      boMod,
      boPow,

      // strings
      boConcat,
    };

    enum JoinType
    {
      jtDefault,
      jtLeft,
      jtLeftOuter,
      jtRight,
      jtRightOuter,
      jtCross,
      jtInner,
      jtFull
    };

    static const char *BINARY_OPERATOR_TEXT[] SIP_SKIP;

    static const char *UNARY_OPERATOR_TEXT[] SIP_SKIP;

    static const char *JOIN_TYPE_TEXT[] SIP_SKIP;


    class Visitor; // visitor interface is defined below

    enum NodeType
    {
      ntUnaryOperator,
      ntBinaryOperator,
      ntInOperator,
      ntBetweenOperator,
      ntFunction,
      ntLiteral,
      ntColumnRef,
      ntSelectedColumn,
      ntSelect,
      ntTableDef,
      ntJoin,
      ntColumnSorted,
      ntCast
    };

    class CORE_EXPORT Node
    {

#ifdef SIP_RUN
        SIP_CONVERT_TO_SUBCLASS_CODE
        switch ( sipCpp->nodeType() )
        {
          case QgsSQLStatement::ntUnaryOperator:   sipType = sipType_QgsSQLStatement_NodeUnaryOperator; break;
          case QgsSQLStatement::ntBinaryOperator:  sipType = sipType_QgsSQLStatement_NodeBinaryOperator; break;
          case QgsSQLStatement::ntInOperator:      sipType = sipType_QgsSQLStatement_NodeInOperator; break;
          case QgsSQLStatement::ntBetweenOperator: sipType = sipType_QgsSQLStatement_NodeBetweenOperator; break;
          case QgsSQLStatement::ntFunction:        sipType = sipType_QgsSQLStatement_NodeFunction; break;
          case QgsSQLStatement::ntLiteral:         sipType = sipType_QgsSQLStatement_NodeLiteral; break;
          case QgsSQLStatement::ntColumnRef:       sipType = sipType_QgsSQLStatement_NodeColumnRef; break;
          case QgsSQLStatement::ntSelectedColumn:  sipType = sipType_QgsSQLStatement_NodeSelectedColumn; break;
          case QgsSQLStatement::ntSelect:          sipType = sipType_QgsSQLStatement_NodeSelect; break;
          case QgsSQLStatement::ntTableDef:        sipType = sipType_QgsSQLStatement_NodeTableDef; break;
          case QgsSQLStatement::ntJoin:            sipType = sipType_QgsSQLStatement_NodeJoin; break;
          case QgsSQLStatement::ntColumnSorted:    sipType = sipType_QgsSQLStatement_NodeColumnSorted; break;
          case QgsSQLStatement::ntCast:            sipType = sipType_QgsSQLStatement_NodeCast; break;
          default:                               sipType = 0; break;
        }
        SIP_END
#endif

      public:
        virtual ~Node() = default;

        virtual QgsSQLStatement::NodeType nodeType() const = 0;

        virtual QString dump() const = 0;

        virtual QgsSQLStatement::Node *clone() const = 0 SIP_FACTORY;

        virtual void accept( QgsSQLStatement::Visitor &v ) const = 0;
    };

    class CORE_EXPORT NodeList
    {
      public:
        NodeList() = default;
        virtual ~NodeList() { qDeleteAll( mList ); }

        void append( QgsSQLStatement::Node *node SIP_TRANSFER ) { mList.append( node ); }

        QList<QgsSQLStatement::Node *> list() { return mList; }

        int count() const { return mList.count(); }

        void accept( QgsSQLStatement::Visitor &v ) const;

        QgsSQLStatement::NodeList *clone() const SIP_FACTORY;

        virtual QString dump() const;

      protected:
        QList<Node *> mList;
    };

    class CORE_EXPORT NodeUnaryOperator : public QgsSQLStatement::Node
    {
      public:
        NodeUnaryOperator( QgsSQLStatement::UnaryOperator op, QgsSQLStatement::Node *operand SIP_TRANSFER ) : mOp( op ), mOperand( operand ) {}
        ~NodeUnaryOperator() override { delete mOperand; }

        QgsSQLStatement::UnaryOperator op() const { return mOp; }

        QgsSQLStatement::Node *operand() const { return mOperand; }

        QgsSQLStatement::NodeType nodeType() const override { return ntUnaryOperator; }
        QString dump() const override;

        void accept( QgsSQLStatement::Visitor &v ) const override { v.visit( *this ); }
        QgsSQLStatement::Node *clone() const override SIP_FACTORY;

      protected:
        UnaryOperator mOp;
        Node *mOperand = nullptr;
    };

    class CORE_EXPORT NodeBinaryOperator : public QgsSQLStatement::Node
    {
      public:
        NodeBinaryOperator( QgsSQLStatement::BinaryOperator op, QgsSQLStatement::Node *opLeft SIP_TRANSFER, QgsSQLStatement::Node *opRight SIP_TRANSFER )
          : mOp( op )
          , mOpLeft( opLeft )
          , mOpRight( opRight )
        {}
        ~NodeBinaryOperator() override { delete mOpLeft; delete mOpRight; }

        QgsSQLStatement::BinaryOperator op() const { return mOp; }

        QgsSQLStatement::Node *opLeft() const { return mOpLeft; }

        QgsSQLStatement::Node *opRight() const { return mOpRight; }

        QgsSQLStatement::NodeType nodeType() const override { return ntBinaryOperator; }
        QString dump() const override;

        void accept( QgsSQLStatement::Visitor &v ) const override { v.visit( *this ); }
        QgsSQLStatement::Node *clone() const override SIP_FACTORY;

        int precedence() const;

        bool leftAssociative() const;

      protected:

        BinaryOperator mOp;
        Node *mOpLeft = nullptr;
        Node *mOpRight = nullptr;
    };

    class CORE_EXPORT NodeInOperator : public QgsSQLStatement::Node
    {
      public:
        NodeInOperator( QgsSQLStatement::Node *node SIP_TRANSFER, QgsSQLStatement::NodeList *list SIP_TRANSFER, bool notin = false ) : mNode( node ), mList( list ), mNotIn( notin ) {}
        ~NodeInOperator() override { delete mNode; delete mList; }

        QgsSQLStatement::Node *node() const { return mNode; }

        bool isNotIn() const { return mNotIn; }

        QgsSQLStatement::NodeList *list() const { return mList; }

        QgsSQLStatement::NodeType nodeType() const override { return ntInOperator; }
        QString dump() const override;

        void accept( QgsSQLStatement::Visitor &v ) const override { v.visit( *this ); }
        QgsSQLStatement::Node *clone() const override SIP_FACTORY;

      protected:
        Node *mNode = nullptr;
        NodeList *mList = nullptr;
        bool mNotIn;
    };

    class CORE_EXPORT NodeBetweenOperator : public QgsSQLStatement::Node
    {
      public:
        NodeBetweenOperator( QgsSQLStatement::Node *node SIP_TRANSFER, QgsSQLStatement::Node *minVal SIP_TRANSFER, QgsSQLStatement::Node *maxVal SIP_TRANSFER, bool notBetween = false )
          : mNode( node ), mMinVal( minVal ), mMaxVal( maxVal ), mNotBetween( notBetween ) {}
        ~NodeBetweenOperator() override { delete mNode; delete mMinVal; delete mMaxVal; }

        QgsSQLStatement::Node *node() const { return mNode; }

        bool isNotBetween() const { return mNotBetween; }

        QgsSQLStatement::Node *minVal() const { return mMinVal; }

        QgsSQLStatement::Node *maxVal() const { return mMaxVal; }

        QgsSQLStatement::NodeType nodeType() const override { return ntBetweenOperator; }
        QString dump() const override;

        void accept( QgsSQLStatement::Visitor &v ) const override { v.visit( *this ); }
        QgsSQLStatement::Node *clone() const override SIP_FACTORY;

      protected:
        Node *mNode = nullptr;
        Node *mMinVal = nullptr;
        Node *mMaxVal = nullptr;
        bool mNotBetween;
    };

    class CORE_EXPORT NodeFunction : public QgsSQLStatement::Node
    {
      public:
        NodeFunction( const QString &name, QgsSQLStatement::NodeList *args  SIP_TRANSFER ) : mName( name ), mArgs( args ) {}
        ~NodeFunction() override { delete mArgs; }

        QString name() const { return mName; }

        QgsSQLStatement::NodeList *args() const { return mArgs; }

        QgsSQLStatement::NodeType nodeType() const override { return ntFunction; }
        QString dump() const override;

        void accept( QgsSQLStatement::Visitor &v ) const override { v.visit( *this ); }
        QgsSQLStatement::Node *clone() const override SIP_FACTORY;

      protected:
        QString mName;
        NodeList *mArgs = nullptr;

    };

    class CORE_EXPORT NodeLiteral : public QgsSQLStatement::Node
    {
      public:
        NodeLiteral( const QVariant &value ) : mValue( value ) {}

        inline QVariant value() const { return mValue; }

        QgsSQLStatement::NodeType nodeType() const override { return ntLiteral; }
        QString dump() const override;

        void accept( QgsSQLStatement::Visitor &v ) const override { v.visit( *this ); }
        QgsSQLStatement::Node *clone() const override SIP_FACTORY;

      protected:
        QVariant mValue;
    };

    class CORE_EXPORT NodeColumnRef : public QgsSQLStatement::Node
    {
      public:
        NodeColumnRef( const QString &name, bool star ) : mName( name ), mDistinct( false ), mStar( star ) {}
        NodeColumnRef( const QString &tableName, const QString &name, bool star ) : mTableName( tableName ), mName( name ), mDistinct( false ), mStar( star ) {}

        void setDistinct( bool distinct = true ) { mDistinct = distinct; }

        QString tableName() const { return mTableName; }

        QString name() const { return mName; }

        bool star() const { return mStar; }

        bool distinct() const { return mDistinct; }

        QgsSQLStatement::NodeType nodeType() const override { return ntColumnRef; }
        QString dump() const override;

        void accept( QgsSQLStatement::Visitor &v ) const override { v.visit( *this ); }
        QgsSQLStatement::Node *clone() const override SIP_FACTORY;
        QgsSQLStatement::NodeColumnRef *cloneThis() const SIP_FACTORY;

      protected:
        QString mTableName;
        QString mName;
        bool mDistinct;
        bool mStar;
    };

    class CORE_EXPORT NodeSelectedColumn : public QgsSQLStatement::Node
    {
      public:
        NodeSelectedColumn( QgsSQLStatement::Node *node SIP_TRANSFER ) : mColumnNode( node ) {}
        ~NodeSelectedColumn() override { delete mColumnNode; }

        void setAlias( const QString &alias ) { mAlias = alias; }

        QgsSQLStatement::Node *column() const { return mColumnNode; }

        QString alias() const { return mAlias; }

        QgsSQLStatement::NodeType nodeType() const override { return ntSelectedColumn; }
        QString dump() const override;

        void accept( QgsSQLStatement::Visitor &v ) const override { v.visit( *this ); }
        QgsSQLStatement::Node *clone() const override SIP_FACTORY;
        QgsSQLStatement::NodeSelectedColumn *cloneThis() const SIP_FACTORY;

      protected:
        Node *mColumnNode = nullptr;
        QString mAlias;
    };

    class CORE_EXPORT NodeCast : public QgsSQLStatement::Node
    {
      public:
        NodeCast( QgsSQLStatement::Node *node SIP_TRANSFER, const QString &type ) : mNode( node ), mType( type ) {}
        ~NodeCast() override { delete mNode; }

        QgsSQLStatement::Node *node() const { return mNode; }

        QString type() const { return mType; }

        QgsSQLStatement::NodeType nodeType() const override { return ntCast; }
        QString dump() const override;

        void accept( QgsSQLStatement::Visitor &v ) const override { v.visit( *this ); }
        QgsSQLStatement::Node *clone() const override SIP_FACTORY;

      protected:
        Node *mNode = nullptr;
        QString mType;
    };

    class CORE_EXPORT NodeTableDef : public QgsSQLStatement::Node
    {
      public:
        NodeTableDef( const QString &name ) : mName( name ) {}
        NodeTableDef( const QString &name, const QString &alias ) : mName( name ), mAlias( alias ) {}

        QString name() const { return mName; }

        QString alias() const { return mAlias; }

        QgsSQLStatement::NodeType nodeType() const override { return ntTableDef; }
        QString dump() const override;

        void accept( QgsSQLStatement::Visitor &v ) const override { v.visit( *this ); }
        QgsSQLStatement::Node *clone() const override SIP_FACTORY;
        QgsSQLStatement::NodeTableDef *cloneThis() const SIP_FACTORY;

      protected:
        QString mName;
        QString mAlias;
    };

    class CORE_EXPORT NodeJoin : public QgsSQLStatement::Node
    {
      public:
        NodeJoin( QgsSQLStatement::NodeTableDef *tabledef SIP_TRANSFER, QgsSQLStatement::Node *onExpr SIP_TRANSFER, QgsSQLStatement::JoinType type ) : mTableDef( tabledef ), mOnExpr( onExpr ), mType( type ) {}
        NodeJoin( QgsSQLStatement::NodeTableDef *tabledef SIP_TRANSFER, const QList<QString> &usingColumns, QgsSQLStatement::JoinType type ) : mTableDef( tabledef ), mUsingColumns( usingColumns ), mType( type ) {}
        ~NodeJoin() override { delete mTableDef; delete mOnExpr; }

        QgsSQLStatement::NodeTableDef *tableDef() const { return mTableDef; }

        QgsSQLStatement::Node *onExpr() const { return mOnExpr; }

        QList<QString> usingColumns() const { return mUsingColumns; }

        QgsSQLStatement::JoinType type() const { return mType; }

        QgsSQLStatement::NodeType nodeType() const override { return ntJoin; }
        QString dump() const override;

        void accept( QgsSQLStatement::Visitor &v ) const override { v.visit( *this ); }
        QgsSQLStatement::Node *clone() const override SIP_FACTORY;
        QgsSQLStatement::NodeJoin *cloneThis() const SIP_FACTORY;

      protected:
        NodeTableDef *mTableDef = nullptr;
        Node *mOnExpr = nullptr;
        QList<QString> mUsingColumns;
        JoinType mType;
    };

    class CORE_EXPORT NodeColumnSorted : public QgsSQLStatement::Node
    {
      public:
        NodeColumnSorted( QgsSQLStatement::NodeColumnRef *column SIP_TRANSFER, bool asc ) : mColumn( column ), mAsc( asc ) {}
        ~NodeColumnSorted() override { delete mColumn; }

        QgsSQLStatement::NodeColumnRef *column() const { return mColumn; }

        bool ascending() const { return mAsc; }

        QgsSQLStatement::NodeType nodeType() const override { return ntColumnSorted; }
        QString dump() const override;

        void accept( QgsSQLStatement::Visitor &v ) const override { v.visit( *this ); }
        QgsSQLStatement::Node *clone() const override SIP_FACTORY;
        QgsSQLStatement::NodeColumnSorted *cloneThis() const SIP_FACTORY;

      protected:
        NodeColumnRef *mColumn = nullptr;
        bool mAsc;
    };

    class CORE_EXPORT NodeSelect : public QgsSQLStatement::Node
    {
      public:
        NodeSelect( const QList<QgsSQLStatement::NodeTableDef *> &tableList SIP_TRANSFER, const QList<QgsSQLStatement::NodeSelectedColumn *> &columns SIP_TRANSFER, bool distinct ) : mTableList( tableList ), mColumns( columns ), mDistinct( distinct ) {}
        ~NodeSelect() override;

        void setJoins( const QList<QgsSQLStatement::NodeJoin *> &joins SIP_TRANSFER ) { qDeleteAll( mJoins ); mJoins = joins; }
        void appendJoin( QgsSQLStatement::NodeJoin *join SIP_TRANSFER ) { mJoins.append( join ); }
        void setWhere( QgsSQLStatement::Node *where SIP_TRANSFER ) { delete mWhere; mWhere = where; }
        void setOrderBy( const QList<QgsSQLStatement::NodeColumnSorted *> &orderBy SIP_TRANSFER ) { qDeleteAll( mOrderBy ); mOrderBy = orderBy; }

        QList<QgsSQLStatement::NodeTableDef *> tables() const { return mTableList; }
        QList<QgsSQLStatement::NodeSelectedColumn *> columns() const { return mColumns; }
        bool distinct() const { return mDistinct; }
        QList<QgsSQLStatement::NodeJoin *> joins() const { return mJoins; }
        QgsSQLStatement::Node *where() const { return mWhere; }
        QList<QgsSQLStatement::NodeColumnSorted *> orderBy() const { return mOrderBy; }

        QgsSQLStatement::NodeType nodeType() const override { return ntSelect; }
        QString dump() const override;

        void accept( QgsSQLStatement::Visitor &v ) const override { v.visit( *this ); }
        QgsSQLStatement::Node *clone() const override SIP_FACTORY;

      protected:
        QList<NodeTableDef *> mTableList;
        QList<NodeSelectedColumn *> mColumns;
        bool mDistinct;
        QList<NodeJoin *> mJoins;
        Node *mWhere = nullptr;
        QList<NodeColumnSorted *> mOrderBy;
    };


    class CORE_EXPORT Visitor
    {
      public:
        virtual ~Visitor() = default;
        virtual void visit( const QgsSQLStatement::NodeUnaryOperator &n ) = 0;
        virtual void visit( const QgsSQLStatement::NodeBinaryOperator &n ) = 0;
        virtual void visit( const QgsSQLStatement::NodeInOperator &n ) = 0;
        virtual void visit( const QgsSQLStatement::NodeBetweenOperator &n ) = 0;
        virtual void visit( const QgsSQLStatement::NodeFunction &n ) = 0;
        virtual void visit( const QgsSQLStatement::NodeLiteral &n ) = 0;
        virtual void visit( const QgsSQLStatement::NodeColumnRef &n ) = 0;
        virtual void visit( const QgsSQLStatement::NodeSelectedColumn &n ) = 0;
        virtual void visit( const QgsSQLStatement::NodeTableDef &n ) = 0;
        virtual void visit( const QgsSQLStatement::NodeSelect &n ) = 0;
        virtual void visit( const QgsSQLStatement::NodeJoin &n ) = 0;
        virtual void visit( const QgsSQLStatement::NodeColumnSorted &n ) = 0;
        virtual void visit( const QgsSQLStatement::NodeCast &n ) = 0;
    };

    class CORE_EXPORT RecursiveVisitor: public QgsSQLStatement::Visitor
    {
      public:
        RecursiveVisitor() = default;

        void visit( const QgsSQLStatement::NodeUnaryOperator &n ) override { n.operand()->accept( *this ); }
        void visit( const QgsSQLStatement::NodeBinaryOperator &n ) override { n.opLeft()->accept( *this ); n.opRight()->accept( *this ); }
        void visit( const QgsSQLStatement::NodeInOperator &n ) override { n.node()->accept( *this ); n.list()->accept( *this ); }
        void visit( const QgsSQLStatement::NodeBetweenOperator &n ) override { n.node()->accept( *this ); n.minVal()->accept( *this ); n.maxVal()->accept( *this ); }
        void visit( const QgsSQLStatement::NodeFunction &n ) override { n.args()->accept( *this ); }
        void visit( const QgsSQLStatement::NodeLiteral & ) override {}
        void visit( const QgsSQLStatement::NodeColumnRef & ) override { }
        void visit( const QgsSQLStatement::NodeSelectedColumn &n ) override { n.column()->accept( *this ); }
        void visit( const QgsSQLStatement::NodeTableDef & ) override {}
        void visit( const QgsSQLStatement::NodeSelect &n ) override;
        void visit( const QgsSQLStatement::NodeJoin &n ) override;
        void visit( const QgsSQLStatement::NodeColumnSorted &n ) override { n.column()->accept( *this ); }
        void visit( const QgsSQLStatement::NodeCast &n ) override { n.node()->accept( *this ); }
    };

    void acceptVisitor( QgsSQLStatement::Visitor &v ) const;

  protected:
    QgsSQLStatement::Node *mRootNode = nullptr;
    QString mStatement;
    QString mParserErrorString;
};

Q_DECLARE_METATYPE( QgsSQLStatement::Node * )

#endif // QGSSQLSTATEMENT_H