Kexi API Documentation (2.0 alpha)
	Overview Class Hierarchy Classes Classes (annotated) Members Source Files

expression.h

Go to the documentation of this file.

/* This file is part of the KDE project
   Copyright (C) 2003-2006 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

KEXI_DB_EXPORT QString 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 QPtrList<BaseExpr> List;
    typedef QPtrListIterator<BaseExpr> ListIterator;

    BaseExpr(int token);
    virtual ~BaseExpr();
    
    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 QString toString(QuerySchemaParameterValueListIterator* params = 0) = 0;

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

    static QString tokenToDebugString(int token);

    virtual QString 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);
    virtual ~NArgExpr();
    void add(BaseExpr *expr);
    void prepend(BaseExpr *expr);
    BaseExpr *arg(int n);
    int args();
    virtual QString debugString();
    virtual QString 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);
    virtual ~UnaryExpr();
    virtual Field::Type type();
    virtual QString debugString();
    virtual QString 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);
    virtual ~BinaryExpr();
    virtual Field::Type type();
    virtual QString debugString();
    virtual QString 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 QString tokenToString();

    BaseExpr *m_larg;
    BaseExpr *m_rarg;
};

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

class KEXI_DB_EXPORT QueryParameterExpr : public ConstExpr
{
public:
    QueryParameterExpr(const QString& message);
    virtual ~QueryParameterExpr();
    virtual Field::Type type();
    void setType(Field::Type type);
    virtual QString debugString();
    virtual QString 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 QString& _name);
    virtual ~VariableExpr();
    virtual Field::Type type();
    virtual QString debugString();
    virtual QString toString(QuerySchemaParameterValueListIterator* params = 0);
    virtual void getQueryParameters(QuerySchemaParameterList& params);

    virtual bool validate(ParseInfo& parseInfo);

    QString 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 QString& _name, NArgExpr* args_ = 0);
    virtual ~FunctionExpr();
    virtual Field::Type type();
    virtual QString debugString();
    virtual QString toString(QuerySchemaParameterValueListIterator* params = 0);
    virtual void getQueryParameters(QuerySchemaParameterList& params);
    virtual bool validate(ParseInfo& parseInfo);

    static QValueList<QCString> builtInAggregates();
    static bool isBuiltInAggregate(const QCString& fname);

    QString name;
    NArgExpr* args;
};

} //namespace KexiDB

#endif

This file is part of the documentation for Kexi 2.0 alpha.

Documentation copyright © 2002-2007 the Kexi Team.
Generated on Tue Apr 1 20:48:01 2008 by doxygen 1.4.2 written by Dimitri van Heesch, © 1997-2003