expression.h

/* This file is part of the KDE project
   Copyright (C) 2003-2007 Jaroslaw Staniek <js@iidea.pl>
 
   Design based on nexp.h : Parser module of Python-like language
   (C) 2001 Jaroslaw Staniek, MIMUW (www.mimuw.edu.pl)
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
 
#ifndef KEXIDB_EXPRESSION_H
#define KEXIDB_EXPRESSION_H
 
#include "field.h"
#include "queryschema.h"
 
#include <kdebug.h>
#include "global.h"
 
namespace KexiDB {

#define KexiDBExpr_Unknown 0
#define KexiDBExpr_Unary 1
#define KexiDBExpr_Arithm 2
#define KexiDBExpr_Logical 3
#define KexiDBExpr_Relational 4
#define KexiDBExpr_SpecialBinary 5
#define KexiDBExpr_Const 6
#define KexiDBExpr_Variable 7
#define KexiDBExpr_Function 8
#define KexiDBExpr_Aggregation 9
#define KexiDBExpr_TableList 10
#define KexiDBExpr_QueryParameter 11

//#define KEXIDB_CUSTOM_TOKEN 0x1000

KEXI_DB_EXPORT TQString exprClassName(int c);
 
class ParseInfo;
class NArgExpr;
class UnaryExpr;
class BinaryExpr;
class ConstExpr;
class VariableExpr;
class FunctionExpr;
class QueryParameterExpr;
class QuerySchemaParameterValueListIterator;
//class QuerySchemaParameterList;

class KEXI_DB_EXPORT BaseExpr
{
public:
    typedef TQPtrList<BaseExpr> List;
    typedef TQPtrListIterator<BaseExpr> ListIterator;
 
    BaseExpr(int token);
    virtual ~BaseExpr();

    virtual BaseExpr* copy() const = 0;
 
    int token() const { return m_token; }
    
    virtual Field::Type type();
    
    BaseExpr* parent() const { return m_par; }
    
    virtual void setParent(BaseExpr *p) { m_par = p; }
    
    virtual bool validate(ParseInfo& parseInfo);

    virtual TQString toString(QuerySchemaParameterValueListIterator* params = 0) = 0;

    virtual void getQueryParameters(QuerySchemaParameterList& params) = 0;
    
    inline void debug() { KexiDBDbg << debugString() << endl; }
    
    virtual TQString debugString();
    
    inline TQString tokenToDebugString() { return tokenToDebugString(m_token); }
 
    static TQString tokenToDebugString(int token);

    virtual TQString tokenToString();
 
    int exprClass() const { return m_cl; }

    NArgExpr* toNArg();
    UnaryExpr* toUnary();
    BinaryExpr* toBinary();
    ConstExpr* toConst();
    VariableExpr* toVariable();
    FunctionExpr* toFunction();
    QueryParameterExpr* toQueryParameter();
 
protected:
    int m_cl; 
    BaseExpr *m_par; 
    int m_token;
};

class KEXI_DB_EXPORT NArgExpr : public BaseExpr
{
public:
    NArgExpr(int aClass, int token);
    NArgExpr(const NArgExpr& expr);
    virtual ~NArgExpr();
    virtual NArgExpr* copy() const;
    void add(BaseExpr *expr);
    void prepend(BaseExpr *expr);
    BaseExpr *arg(int n);
    int args();
    virtual TQString debugString();
    virtual TQString toString(QuerySchemaParameterValueListIterator* params = 0);
    virtual void getQueryParameters(QuerySchemaParameterList& params);
    virtual bool validate(ParseInfo& parseInfo);
    BaseExpr::List list;
};

class KEXI_DB_EXPORT UnaryExpr : public BaseExpr
{
public:
    UnaryExpr(int token, BaseExpr *arg);
    UnaryExpr(const UnaryExpr& expr);
    virtual ~UnaryExpr();
    virtual UnaryExpr* copy() const;
    virtual Field::Type type();
    virtual TQString debugString();
    virtual TQString toString(QuerySchemaParameterValueListIterator* params = 0);
    virtual void getQueryParameters(QuerySchemaParameterList& params);
    BaseExpr *arg() const { return m_arg; }
    virtual bool validate(ParseInfo& parseInfo);
 
    BaseExpr *m_arg;
};

class KEXI_DB_EXPORT BinaryExpr : public BaseExpr
{
public:
    BinaryExpr(int aClass, BaseExpr *left_expr, int token, BaseExpr *right_expr);
    BinaryExpr(const BinaryExpr& expr);
    virtual ~BinaryExpr();
    virtual BinaryExpr* copy() const;
    virtual Field::Type type();
    virtual TQString debugString();
    virtual TQString toString(QuerySchemaParameterValueListIterator* params = 0);
    virtual void getQueryParameters(QuerySchemaParameterList& params);
    BaseExpr *left() const { return m_larg; }
    BaseExpr *right() const { return m_rarg; }
    virtual bool validate(ParseInfo& parseInfo);
    virtual TQString tokenToString();
 
    BaseExpr *m_larg;
    BaseExpr *m_rarg;
};

class KEXI_DB_EXPORT ConstExpr : public BaseExpr
{
public:
    ConstExpr(int token, const TQVariant& val);
    ConstExpr(const ConstExpr& expr);
    virtual ~ConstExpr();
    virtual ConstExpr* copy() const;
    virtual Field::Type type();
    virtual TQString debugString();
    virtual TQString toString(QuerySchemaParameterValueListIterator* params = 0);
    virtual void getQueryParameters(QuerySchemaParameterList& params);
    virtual bool validate(ParseInfo& parseInfo);
    TQVariant value;
};

class KEXI_DB_EXPORT QueryParameterExpr : public ConstExpr
{
public:
    QueryParameterExpr(const TQString& message);
    QueryParameterExpr(const QueryParameterExpr& expr);
    virtual ~QueryParameterExpr();
    virtual QueryParameterExpr* copy() const;
    virtual Field::Type type();
    void setType(Field::Type type);
    virtual TQString debugString();
    virtual TQString toString(QuerySchemaParameterValueListIterator* params = 0);
    virtual void getQueryParameters(QuerySchemaParameterList& params);
    virtual bool validate(ParseInfo& parseInfo);
protected:
    Field::Type m_type;
};

class KEXI_DB_EXPORT VariableExpr : public BaseExpr
{
public:
    VariableExpr(const TQString& _name);
    VariableExpr(const VariableExpr& expr);
    virtual ~VariableExpr();
    virtual VariableExpr* copy() const;
    virtual Field::Type type();
    virtual TQString debugString();
    virtual TQString toString(QuerySchemaParameterValueListIterator* params = 0);
    virtual void getQueryParameters(QuerySchemaParameterList& params);

    virtual bool validate(ParseInfo& parseInfo);

    TQString name;
 
    /* NULL by default. After successful validate() it will point to a field,
     if the variable is of a form "tablename.fieldname" or "fieldname", 
     otherwise (eg. for asterisks) -still NULL.
     Only meaningful for column expressions within a query. */
    Field *field;
 
    /* -1 by default. After successful validate() it will contain a position of a table
     within query that needs to be bound to the field. 
     This value can be either be -1 if no binding is needed.
     This value is used in the Parser to call 
      QuerySchema::addField(Field* field, int bindToTable);
     Only meaningful for column expressions within a query. */
    int tablePositionForField;

    TableSchema *tableForQueryAsterisk;
};

class KEXI_DB_EXPORT FunctionExpr : public BaseExpr
{
public:
    FunctionExpr(const TQString& _name, NArgExpr* args_ = 0);
    FunctionExpr(const FunctionExpr& expr);
    virtual ~FunctionExpr();
    virtual FunctionExpr* copy() const;
    virtual Field::Type type();
    virtual TQString debugString();
    virtual TQString toString(QuerySchemaParameterValueListIterator* params = 0);
    virtual void getQueryParameters(QuerySchemaParameterList& params);
    virtual bool validate(ParseInfo& parseInfo);
 
    static TQValueList<TQCString> builtInAggregates();
    static bool isBuiltInAggregate(const TQCString& fname);
 
    TQString name;
    NArgExpr* args;
};
 
} //namespace KexiDB
 
#endif