kexi

expression.h

00001 /* This file is part of the KDE project
00002    Copyright (C) 2003-2007 Jaroslaw Staniek <js@iidea.pl>
00003 
00004    Design based on nexp.h : Parser module of Python-like language
00005    (C) 2001 Jaroslaw Staniek, MIMUW (www.mimuw.edu.pl)
00006 
00007    This library is free software; you can redistribute it and/or
00008    modify it under the terms of the GNU Library General Public
00009    License as published by the Free Software Foundation; either
00010    version 2 of the License, or (at your option) any later version.
00011 
00012    This library is distributed in the hope that it will be useful,
00013    but WITHOUT ANY WARRANTY; without even the implied warranty of
00014    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015    Library General Public License for more details.
00016 
00017    You should have received a copy of the GNU Library General Public License
00018    along with this library; see the file COPYING.LIB.  If not, write to
00019    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00020  * Boston, MA 02110-1301, USA.
00021 */
00022 
00023 #ifndef KEXIDB_EXPRESSION_H
00024 #define KEXIDB_EXPRESSION_H
00025 
00026 #include "field.h"
00027 #include "queryschema.h"
00028 
00029 #include <kdebug.h>
00030 #include "global.h"
00031 
00032 namespace KexiDB {
00033 
00035 #define KexiDBExpr_Unknown 0
00036 #define KexiDBExpr_Unary 1
00037 #define KexiDBExpr_Arithm 2
00038 #define KexiDBExpr_Logical 3
00039 #define KexiDBExpr_Relational 4
00040 #define KexiDBExpr_SpecialBinary 5
00041 #define KexiDBExpr_Const 6
00042 #define KexiDBExpr_Variable 7
00043 #define KexiDBExpr_Function 8
00044 #define KexiDBExpr_Aggregation 9
00045 #define KexiDBExpr_TableList 10
00046 #define KexiDBExpr_QueryParameter 11
00047 
00049 //#define KEXIDB_CUSTOM_TOKEN 0x1000
00050 
00052 KEXI_DB_EXPORT QString exprClassName(int c);
00053 
00054 class ParseInfo;
00055 class NArgExpr;
00056 class UnaryExpr;
00057 class BinaryExpr;
00058 class ConstExpr;
00059 class VariableExpr;
00060 class FunctionExpr;
00061 class QueryParameterExpr;
00062 class QuerySchemaParameterValueListIterator;
00063 //class QuerySchemaParameterList;
00064 
00066 class KEXI_DB_EXPORT BaseExpr
00067 {
00068 public:
00069     typedef QPtrList<BaseExpr> List;
00070     typedef QPtrListIterator<BaseExpr> ListIterator;
00071 
00072     BaseExpr(int token);
00073     virtual ~BaseExpr();
00074 
00077     virtual BaseExpr* copy() const = 0;
00078 
00079     int token() const { return m_token; }
00080     
00081     virtual Field::Type type();
00082     
00083     BaseExpr* parent() const { return m_par; }
00084     
00085     virtual void setParent(BaseExpr *p) { m_par = p; }
00086     
00087     virtual bool validate(ParseInfo& parseInfo);
00088 
00092     virtual QString toString(QuerySchemaParameterValueListIterator* params = 0) = 0;
00093 
00096     virtual void getQueryParameters(QuerySchemaParameterList& params) = 0;
00097     
00098     inline void debug() { KexiDBDbg << debugString() << endl; }
00099     
00100     virtual QString debugString();
00101     
00104     inline QString tokenToDebugString() { return tokenToDebugString(m_token); }
00105 
00106     static QString tokenToDebugString(int token);
00107 
00109     virtual QString tokenToString();
00110 
00111     int exprClass() const { return m_cl; }
00112 
00114     NArgExpr* toNArg();
00115     UnaryExpr* toUnary();
00116     BinaryExpr* toBinary();
00117     ConstExpr* toConst();
00118     VariableExpr* toVariable();
00119     FunctionExpr* toFunction();
00120     QueryParameterExpr* toQueryParameter();
00121 
00122 protected:
00123     int m_cl; 
00124     BaseExpr *m_par; 
00125     int m_token;
00126 };
00127 
00129 class KEXI_DB_EXPORT NArgExpr : public BaseExpr
00130 {
00131 public:
00132     NArgExpr(int aClass, int token);
00133     NArgExpr(const NArgExpr& expr);
00134     virtual ~NArgExpr();
00136     virtual NArgExpr* copy() const;
00137     void add(BaseExpr *expr);
00138     void prepend(BaseExpr *expr);
00139     BaseExpr *arg(int n);
00140     int args();
00141     virtual QString debugString();
00142     virtual QString toString(QuerySchemaParameterValueListIterator* params = 0);
00143     virtual void getQueryParameters(QuerySchemaParameterList& params);
00144     virtual bool validate(ParseInfo& parseInfo);
00145     BaseExpr::List list;
00146 };
00147 
00149 class KEXI_DB_EXPORT UnaryExpr : public BaseExpr
00150 {
00151 public:
00152     UnaryExpr(int token, BaseExpr *arg);
00153     UnaryExpr(const UnaryExpr& expr);
00154     virtual ~UnaryExpr();
00156     virtual UnaryExpr* copy() const;
00157     virtual Field::Type type();
00158     virtual QString debugString();
00159     virtual QString toString(QuerySchemaParameterValueListIterator* params = 0);
00160     virtual void getQueryParameters(QuerySchemaParameterList& params);
00161     BaseExpr *arg() const { return m_arg; }
00162     virtual bool validate(ParseInfo& parseInfo);
00163 
00164     BaseExpr *m_arg;
00165 };
00166 
00175 class KEXI_DB_EXPORT BinaryExpr : public BaseExpr
00176 {
00177 public:
00178     BinaryExpr(int aClass, BaseExpr *left_expr, int token, BaseExpr *right_expr);
00179     BinaryExpr(const BinaryExpr& expr);
00180     virtual ~BinaryExpr();
00182     virtual BinaryExpr* copy() const;
00183     virtual Field::Type type();
00184     virtual QString debugString();
00185     virtual QString toString(QuerySchemaParameterValueListIterator* params = 0);
00186     virtual void getQueryParameters(QuerySchemaParameterList& params);
00187     BaseExpr *left() const { return m_larg; }
00188     BaseExpr *right() const { return m_rarg; }
00189     virtual bool validate(ParseInfo& parseInfo);
00190     virtual QString tokenToString();
00191 
00192     BaseExpr *m_larg;
00193     BaseExpr *m_rarg;
00194 };
00195 
00199 class KEXI_DB_EXPORT ConstExpr : public BaseExpr
00200 {
00201 public:
00202     ConstExpr(int token, const QVariant& val);
00203     ConstExpr(const ConstExpr& expr);
00204     virtual ~ConstExpr();
00206     virtual ConstExpr* copy() const;
00207     virtual Field::Type type();
00208     virtual QString debugString();
00209     virtual QString toString(QuerySchemaParameterValueListIterator* params = 0);
00210     virtual void getQueryParameters(QuerySchemaParameterList& params);
00211     virtual bool validate(ParseInfo& parseInfo);
00212     QVariant value;
00213 };
00214 
00217 class KEXI_DB_EXPORT QueryParameterExpr : public ConstExpr
00218 {
00219 public:
00220     QueryParameterExpr(const QString& message);
00221     QueryParameterExpr(const QueryParameterExpr& expr);
00222     virtual ~QueryParameterExpr();
00224     virtual QueryParameterExpr* copy() const;
00225     virtual Field::Type type();
00234     void setType(Field::Type type);
00235     virtual QString debugString();
00236     virtual QString toString(QuerySchemaParameterValueListIterator* params = 0);
00237     virtual void getQueryParameters(QuerySchemaParameterList& params);
00238     virtual bool validate(ParseInfo& parseInfo);
00239 protected:
00240     Field::Type m_type;
00241 };
00242 
00244 class KEXI_DB_EXPORT VariableExpr : public BaseExpr
00245 {
00246 public:
00247     VariableExpr(const QString& _name);
00248     VariableExpr(const VariableExpr& expr);
00249     virtual ~VariableExpr();
00251     virtual VariableExpr* copy() const;
00252     virtual Field::Type type();
00253     virtual QString debugString();
00254     virtual QString toString(QuerySchemaParameterValueListIterator* params = 0);
00255     virtual void getQueryParameters(QuerySchemaParameterList& params);
00256 
00260     virtual bool validate(ParseInfo& parseInfo);
00261 
00263     QString name;
00264 
00265     /* NULL by default. After successful validate() it will point to a field,
00266      if the variable is of a form "tablename.fieldname" or "fieldname", 
00267      otherwise (eg. for asterisks) -still NULL.
00268      Only meaningful for column expressions within a query. */
00269     Field *field;
00270 
00271     /* -1 by default. After successful validate() it will contain a position of a table
00272      within query that needs to be bound to the field. 
00273      This value can be either be -1 if no binding is needed.
00274      This value is used in the Parser to call 
00275       QuerySchema::addField(Field* field, int bindToTable);
00276      Only meaningful for column expressions within a query. */
00277     int tablePositionForField;
00278 
00282     TableSchema *tableForQueryAsterisk;
00283 };
00284 
00288 class KEXI_DB_EXPORT FunctionExpr : public BaseExpr
00289 {
00290 public:
00291     FunctionExpr(const QString& _name, NArgExpr* args_ = 0);
00292     FunctionExpr(const FunctionExpr& expr);
00293     virtual ~FunctionExpr();
00295     virtual FunctionExpr* copy() const;
00296     virtual Field::Type type();
00297     virtual QString debugString();
00298     virtual QString toString(QuerySchemaParameterValueListIterator* params = 0);
00299     virtual void getQueryParameters(QuerySchemaParameterList& params);
00300     virtual bool validate(ParseInfo& parseInfo);
00301 
00302     static QValueList<QCString> builtInAggregates();
00303     static bool isBuiltInAggregate(const QCString& fname);
00304 
00305     QString name;
00306     NArgExpr* args;
00307 };
00308 
00309 } //namespace KexiDB
00310 
00311 #endif
KDE Home | KDE Accessibility Home | Description of Access Keys