qgsexpressionnodeimpl.h

Go to the documentation of this file.

/***************************************************************************
                               qgsexpressionnodeimpl.h
                             -------------------
    begin                : May 2017
    copyright            : (C) 2017 Matthias Kuhn
    email                : [email protected]
 ***************************************************************************
 *                                                                         *
 *   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 QGSEXPRESSIONNODEIMPL_H
#define QGSEXPRESSIONNODEIMPL_H
 
#include "qgsexpressionnode.h"
#include "qgsinterval.h"
 
#include <QString>
 
using namespace Qt::StringLiterals;

class CORE_EXPORT QgsExpressionNodeUnaryOperator : public QgsExpressionNode
{
  public:
    enum UnaryOperator
    {
      uoNot,
      uoMinus,
    };

    QgsExpressionNodeUnaryOperator( QgsExpressionNodeUnaryOperator::UnaryOperator op, QgsExpressionNode *operand SIP_TRANSFER )
      : mOp( op )
      , mOperand( operand )
    {}
 
    // clang-format off
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode QString str = u"<QgsExpressionNodeUnaryOperator: %1>"_s.arg( sipCpp->text() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif
 
        // clang-format on
 

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

    QgsExpressionNode *operand() const { return mOperand.get(); }
 
    QgsExpressionNode::NodeType nodeType() const override;
    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QString dump() const override;
 
    QSet<QString> referencedColumns() const override;
    QSet<QString> referencedVariables() const override;
    QSet<QString> referencedFunctions() const override;
    QList<const QgsExpressionNode *> nodes() const override SIP_SKIP;
    bool needsGeometry() const override;
    QgsExpressionNode *clone() const override SIP_FACTORY;
 
    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;

    QString text() const;
 
  private:
    QgsExpressionNodeUnaryOperator( const QgsExpressionNodeUnaryOperator &other ) = delete;
    QgsExpressionNodeUnaryOperator &operator=( const QgsExpressionNodeUnaryOperator &other ) = delete;
 
#ifdef SIP_RUN
    QgsExpressionNodeUnaryOperator( const QgsExpressionNodeUnaryOperator &other );
#endif
 
    UnaryOperator mOp;
    std::unique_ptr<QgsExpressionNode> mOperand;
 
    static const char *UNARY_OPERATOR_TEXT[];
};

class CORE_EXPORT QgsExpressionNodeBinaryOperator : public QgsExpressionNode
{
  public:
    enum BinaryOperator
    {
      // logical
      boOr,
      boAnd,
 
      // comparison
      boEQ, 
      boNE, 
      boLE, 
      boGE, 
      boLT, 
      boGT, 
      boRegexp,
      boLike,
      boNotLike,
      boILike,
      boNotILike,
      boIs,
      boIsNot,
 
      // math
      boPlus,
      boMinus,
      boMul,
      boDiv,
      boIntDiv,
      boMod,
      boPow,
 
      // strings
      boConcat,
    };

    QgsExpressionNodeBinaryOperator( QgsExpressionNodeBinaryOperator::BinaryOperator op, QgsExpressionNode *opLeft SIP_TRANSFER, QgsExpressionNode *opRight SIP_TRANSFER )
      : mOp( op )
      , mOpLeft( opLeft )
      , mOpRight( opRight )
    {}
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode QString str = u"<QgsExpressionNodeBinaryOperator: %1>"_s.arg( sipCpp->text() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif

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

    QgsExpressionNode *opLeft() const { return mOpLeft.get(); }

    QgsExpressionNode *opRight() const { return mOpRight.get(); }
 
    QgsExpressionNode::NodeType nodeType() const override;
    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QString dump() const override;
 
    QSet<QString> referencedColumns() const override;
    QSet<QString> referencedVariables() const override;
    QSet<QString> referencedFunctions() const override;
    QList<const QgsExpressionNode *> nodes() const override SIP_SKIP;
 
    bool needsGeometry() const override;
    QgsExpressionNode *clone() const override SIP_FACTORY;
    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;

    int precedence() const;

    bool leftAssociative() const;

    QString text() const;
 
  private:
    QgsExpressionNodeBinaryOperator( const QgsExpressionNodeBinaryOperator &other ) = delete;
    QgsExpressionNodeBinaryOperator &operator=( const QgsExpressionNodeBinaryOperator &other ) = delete;
 
#ifdef SIP_RUN
    QgsExpressionNodeBinaryOperator( const QgsExpressionNodeBinaryOperator &other );
#endif
    qlonglong computeInt( qlonglong x, qlonglong y );
    double computeDouble( double x, double y );

    QDateTime computeDateTimeFromInterval( const QDateTime &d, QgsInterval *i );

    static QVariant compareNonNullValues( QgsExpression *parent, const QgsExpressionContext *context, const QVariant &vL, const QVariant &vR, BinaryOperator op );
 
    BinaryOperator mOp;
    std::unique_ptr<QgsExpressionNode> mOpLeft;
    std::unique_ptr<QgsExpressionNode> mOpRight;
 
    static const char *BINARY_OPERATOR_TEXT[];
};

class CORE_EXPORT QgsExpressionNodeIndexOperator : public QgsExpressionNode
{
  public:
    QgsExpressionNodeIndexOperator( QgsExpressionNode *container SIP_TRANSFER, QgsExpressionNode *index SIP_TRANSFER )
      : mContainer( container )
      , mIndex( index )
    {}

    QgsExpressionNode *container() const { return mContainer.get(); }

    QgsExpressionNode *index() const { return mIndex.get(); }
 
    QgsExpressionNode::NodeType nodeType() const override;
    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QString dump() const override;
 
    QSet<QString> referencedColumns() const override;
    QSet<QString> referencedVariables() const override;
    QSet<QString> referencedFunctions() const override;
    QList<const QgsExpressionNode *> nodes() const override SIP_SKIP;
 
    bool needsGeometry() const override;
    QgsExpressionNode *clone() const override SIP_FACTORY;
    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;
 
  private:
    QgsExpressionNodeIndexOperator( const QgsExpressionNodeIndexOperator &other ) = delete;
    QgsExpressionNodeIndexOperator &operator=( const QgsExpressionNodeIndexOperator &other ) = delete;
 
#ifdef SIP_RUN
    QgsExpressionNodeIndexOperator( const QgsExpressionNodeIndexOperator &other );
#endif
 
    std::unique_ptr<QgsExpressionNode> mContainer;
    std::unique_ptr<QgsExpressionNode> mIndex;
};

class CORE_EXPORT QgsExpressionNodeBetweenOperator : public QgsExpressionNode
{
  public:
    QgsExpressionNodeBetweenOperator( QgsExpressionNode *node SIP_TRANSFER, QgsExpressionNode *nodeLowerBound SIP_TRANSFER, QgsExpressionNode *nodeHigherBound SIP_TRANSFER, bool negate = false )
      : mNode( node )
      , mLowerBound( nodeLowerBound )
      , mHigherBound( nodeHigherBound )
      , mNegate( negate )
    {}
 
    ~QgsExpressionNodeBetweenOperator() override;

    QgsExpressionNode *node() const { return mNode.get(); }
 
 
    QgsExpressionNode::NodeType nodeType() const override;
    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QString dump() const override;
 
    QSet<QString> referencedColumns() const override;
    QSet<QString> referencedVariables() const override;
    QSet<QString> referencedFunctions() const override;
    QList<const QgsExpressionNode *> nodes() const override SIP_SKIP;
    bool needsGeometry() const override;
    QgsExpressionNode *clone() const override SIP_FACTORY;
    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;

    QgsExpressionNode *lowerBound() const;

    QgsExpressionNode *higherBound() const;

    bool negate() const;
 
  private:
    QgsExpressionNodeBetweenOperator( const QgsExpressionNodeBetweenOperator &other ) = delete;
    QgsExpressionNodeBetweenOperator &operator=( const QgsExpressionNodeBetweenOperator &other ) = delete;
 
#ifdef SIP_RUN
    QgsExpressionNodeBetweenOperator( const QgsExpressionNodeBetweenOperator &other );
#endif
 
 
    std::unique_ptr<QgsExpressionNode> mNode;
    std::unique_ptr<QgsExpressionNode> mLowerBound;
    std::unique_ptr<QgsExpressionNode> mHigherBound;
    bool mNegate = false;
};

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

    QgsExpressionNode *node() const { return mNode.get(); }

    bool isNotIn() const { return mNotIn; }

    QgsExpressionNode::NodeList *list() const { return mList.get(); }
 
    QgsExpressionNode::NodeType nodeType() const override;
    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QString dump() const override;
 
    QSet<QString> referencedColumns() const override;
    QSet<QString> referencedVariables() const override;
    QSet<QString> referencedFunctions() const override;
    QList<const QgsExpressionNode *> nodes() const override SIP_SKIP;
    bool needsGeometry() const override;
    QgsExpressionNode *clone() const override SIP_FACTORY;
    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;
 
  private:
    QgsExpressionNodeInOperator( const QgsExpressionNodeInOperator &other ) = delete;
    QgsExpressionNodeInOperator &operator=( const QgsExpressionNodeInOperator &other ) = delete;
 
#ifdef SIP_RUN
    QgsExpressionNodeInOperator( const QgsExpressionNodeInOperator &other );
#endif
 
    std::unique_ptr<QgsExpressionNode> mNode;
    std::unique_ptr<QgsExpressionNodeInOperator::NodeList> mList;
    bool mNotIn;
};

class CORE_EXPORT QgsExpressionNodeFunction : public QgsExpressionNode
{
  public:
    QgsExpressionNodeFunction( int fnIndex, QgsExpressionNode::NodeList *args SIP_TRANSFER );
 
    ~QgsExpressionNodeFunction() override;
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode QString function;
    if ( QgsExpressionFunction *fd = QgsExpression::QgsExpression::Functions()[sipCpp->fnIndex()] )
    {
      function = fd->name();
    }
    else
    {
      function = QString::number( sipCpp->fnIndex() );
    }
 
    QString str = u"<QgsExpressionNodeFunction: %1>"_s.arg( function );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif

      int fnIndex() const
    {
      return mFnIndex;
    }

    QgsExpressionNode::NodeList *args() const { return mArgs.get(); }
 
    QgsExpressionNode::NodeType nodeType() const override;
    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QString dump() const override;
 
    QSet<QString> referencedColumns() const override;
    QSet<QString> referencedVariables() const override;
    QSet<QString> referencedFunctions() const override;
 
    QList<const QgsExpressionNode *> nodes() const override SIP_SKIP;
    bool needsGeometry() const override;
    QgsExpressionNode *clone() const override SIP_FACTORY;
    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;

    static bool validateParams( int fnIndex, QgsExpressionNode::NodeList *args, QString &error );
 
  private:
    QgsExpressionNodeFunction( const QgsExpressionNodeFunction &other ) = delete;
    QgsExpressionNodeFunction &operator=( const QgsExpressionNodeFunction &other ) = delete;
 
#ifdef SIP_RUN
    QgsExpressionNodeFunction( const QgsExpressionNodeFunction &other );
#endif
 
 
    int mFnIndex;
    std::unique_ptr<NodeList> mArgs;
};

class CORE_EXPORT QgsExpressionNodeLiteral : public QgsExpressionNode
{
  public:
    QgsExpressionNodeLiteral( const QVariant &value )
      : mValue( value )
    {}
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode QString str = u"<QgsExpressionNodeLiteral: %1>"_s.arg( sipCpp->valueAsString() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif

      inline QVariant value() const
    {
      return mValue;
    }
 
    QgsExpressionNode::NodeType nodeType() const override;
    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QString dump() const override;
 
    QSet<QString> referencedColumns() const override;
    QSet<QString> referencedVariables() const override;
    QSet<QString> referencedFunctions() const override;
 
    QList<const QgsExpressionNode *> nodes() const override SIP_SKIP;
    bool needsGeometry() const override;
    QgsExpressionNode *clone() const override SIP_FACTORY;
    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;

    QString valueAsString() const;
 
  private:
    QVariant mValue;
};

class CORE_EXPORT QgsExpressionNodeColumnRef : public QgsExpressionNode
{
  public:
    QgsExpressionNodeColumnRef( const QString &name )
      : mName( name )
    {}
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode QString str = u"<QgsExpressionNodeColumnRef: \"%1\">"_s.arg( sipCpp->name() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif

        QString name() const
    {
      return mName;
    }
 
    QgsExpressionNode::NodeType nodeType() const override;
    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QString dump() const override;
 
    QSet<QString> referencedColumns() const override;
    QSet<QString> referencedVariables() const override;
    QSet<QString> referencedFunctions() const override;
    QList<const QgsExpressionNode *> nodes() const override SIP_SKIP;
 
    bool needsGeometry() const override;
 
    QgsExpressionNode *clone() const override SIP_FACTORY;
    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;
 
  private:
    QString mName;
    int mIndex = -1;
};

class CORE_EXPORT QgsExpressionNodeCondition : public QgsExpressionNode
{
  public:
    class CORE_EXPORT WhenThen
    {
      public:
        WhenThen( QgsExpressionNode *whenExp, QgsExpressionNode *thenExp );
        ~WhenThen();
 
        WhenThen( const WhenThen &rh ) = delete;
        WhenThen &operator=( const WhenThen &rh ) = delete;

        QgsExpressionNodeCondition::WhenThen *clone() const SIP_FACTORY;

        QgsExpressionNode *whenExp() const { return mWhenExp.get(); }

 
        QgsExpressionNode *thenExp() const { return mThenExp.get(); }
 
      private:
#ifdef SIP_RUN
        WhenThen( const QgsExpressionNodeCondition::WhenThen &rh );
#endif
        std::unique_ptr<QgsExpressionNode> mWhenExp;
        std::unique_ptr<QgsExpressionNode> mThenExp;
 
        friend class QgsExpressionNodeCondition;
    };
    typedef QList<QgsExpressionNodeCondition::WhenThen *> WhenThenList;

    QgsExpressionNodeCondition( QgsExpressionNodeCondition::WhenThenList *conditions, QgsExpressionNode *elseExp = nullptr );

    QgsExpressionNodeCondition( const QgsExpressionNodeCondition::WhenThenList &conditions, QgsExpressionNode *elseExp = nullptr ) SIP_SKIP : mConditions( conditions ), mElseExp( elseExp ) {}
 
    ~QgsExpressionNodeCondition() override;
 
    QgsExpressionNode::NodeType nodeType() const override;
    QVariant evalNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    bool prepareNode( QgsExpression *parent, const QgsExpressionContext *context ) override;
    QString dump() const override;

    WhenThenList conditions() const { return mConditions; }

    QgsExpressionNode *elseExp() const { return mElseExp.get(); }
 
    QSet<QString> referencedColumns() const override;
    QSet<QString> referencedVariables() const override;
    QSet<QString> referencedFunctions() const override;
 
    QList<const QgsExpressionNode *> nodes() const override SIP_SKIP;
 
    bool needsGeometry() const override;
    QgsExpressionNode *clone() const override SIP_FACTORY;
    bool isStatic( QgsExpression *parent, const QgsExpressionContext *context ) const override;
 
  private:
    QgsExpressionNodeCondition( const QgsExpressionNodeCondition &other ) = delete;
    QgsExpressionNodeCondition &operator=( const QgsExpressionNodeCondition &other ) = delete;
 
#ifdef SIP_RUN
    QgsExpressionNodeCondition( const QgsExpressionNodeCondition &other );
#endif
 
 
    WhenThenList mConditions;
    std::unique_ptr<QgsExpressionNode> mElseExp;
};
 
 
#endif // QGSEXPRESSIONNODEIMPL_H