firebird/firebird-mirror
firebird/firebird-mirror
8
0
Fork 1
mirror of https://github.com/FirebirdSQL/firebird.git synced 2025-02-01 07:23:02 +01:00
Code Issues
443f0a64bd
firebird-mirror/src/dsql/ExprNodes.h

930 lines
34 KiB
C
Raw Normal View History

Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
/*
* The contents of this file are subject to the Initial
* Developer's Public License Version 1.0 (the "License");
* you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
* http://www.ibphoenix.com/main.nfs?a=ibphoenix&page=ibp_idpl.
*
* Software distributed under the License is distributed AS IS,
* WITHOUT WARRANTY OF ANY KIND, either express or implied.
* See the License for the specific language governing rights
* and limitations under the License.
*
* The Original Code was created by Adriano dos Santos Fernandes
* for the Firebird Open Source RDBMS project.
*
* Copyright (c) 2010 Adriano dos Santos Fernandes <adrianosf@gmail.com>
* and all contributors signed below.
*
* All Rights Reserved.
* Contributor(s): ______________________________________.
*/
#ifndef DSQL_EXPR_NODES_H
#define DSQL_EXPR_NODES_H
Moved some more .h-files to common from jrd as Vlad suggested
2010-10-13 12:39:52 +02:00
#include "../common/common.h"
Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
#include "../jrd/blr.h"
#include "../dsql/Nodes.h"
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
class SysFunction;
Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
namespace Jrd {
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
struct ItemInfo;
Refactor blr_via, blr_from, blr_maximum, blr_minimum, blr_count, blr_average and blr_total
2010-11-07 03:18:58 +01:00
class RecordSource;
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
class ArithmeticNode : public TypedNode<ValueExprNode, ExprNode::TYPE_ARITHMETIC>
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
{
public:
ArithmeticNode(MemoryPool& pool, UCHAR aBlrOp, bool aDialect1,
dsql_nod* aArg1 = NULL, dsql_nod* aArg2 = NULL);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void setParameterName(dsql_par* parameter) const;
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
dsql_nod* node, bool forceVarChar);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
1) Refactor nod_value_if. 2) Created ExprNode::expressionEqual method to replace a new big and ugly switch. 3) Make boolean referencers use BoolExprNode instead of jrd_nod, except nod_validate for now. This includes BinaryBoolNode and NotBoolNode working without jrd_nod references. 4) Rework in the impure allocation code (replace "csb_impure += ..." by CMP_impure calls).
2010-09-20 18:07:50 +02:00
virtual bool expressionEqual(thread_db* tdbb, CompilerScratch* csb, /*const*/ ExprNode* other,
USHORT stream) /*const*/;
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
// add and add2 are used in somewhat obscure way in aggregation.
static dsc* add(const dsc* desc, impure_value* value, const jrd_nod* node, UCHAR blrOp);
static dsc* add2(const dsc* desc, impure_value* value, const jrd_nod* node, UCHAR blrOp);
private:
dsc* multiply(const dsc* desc, impure_value* value) const;
dsc* multiply2(const dsc* desc, impure_value* value) const;
dsc* divide2(const dsc* desc, impure_value* value) const;
dsc* addDateTime(const dsc* desc, impure_value* value) const;
dsc* addSqlDate(const dsc* desc, impure_value* value) const;
dsc* addSqlTime(const dsc* desc, impure_value* value) const;
dsc* addTimeStamp(const dsc* desc, impure_value* value) const;
private:
void makeDialect1(dsc* desc, dsc& desc1, dsc& desc2);
void makeDialect3(dsc* desc, dsc& desc1, dsc& desc2);
void getDescDialect1(thread_db* tdbb, dsc* desc, dsc& desc1, dsc& desc2);
void getDescDialect3(thread_db* tdbb, dsc* desc, dsc& desc1, dsc& desc2);
public:
UCHAR blrOp;
bool dialect1;
Firebird::string label;
dsql_nod* dsqlArg1;
dsql_nod* dsqlArg2;
NestConst<jrd_nod> arg1;
NestConst<jrd_nod> arg2;
};
1) Refactor CAST. 2) Fixed CORE-3204 - Constraint violation error of CAST is not raised inside views
2010-11-02 00:57:31 +01:00
class CastNode : public TypedNode<ValueExprNode, ExprNode::TYPE_CAST>
{
public:
CastNode(MemoryPool& pool, dsql_nod* aDsqlSource = NULL, dsql_fld* aDsqlField = NULL);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual void setParameterName(dsql_par* parameter) const;
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
1) Refactor CAST. 2) Fixed CORE-3204 - Constraint violation error of CAST is not raised inside views
2010-11-02 00:57:31 +01:00
dsql_nod* node, bool forceVarChar);
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
1) Refactor CAST. 2) Fixed CORE-3204 - Constraint violation error of CAST is not raised inside views
2010-11-02 00:57:31 +01:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
virtual bool expressionEqual(thread_db* tdbb, CompilerScratch* csb, /*const*/ ExprNode* other,
USHORT stream) /*const*/;
virtual ExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
dsql_nod* dsqlSource;
dsql_fld* dsqlField;
dsc castDesc;
NestConst<jrd_nod> source;
NestConst<Format> format;
NestConst<ItemInfo> itemInfo;
};
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
class ConcatenateNode : public TypedNode<ValueExprNode, ExprNode::TYPE_CONCATENATE>
Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
{
public:
explicit ConcatenateNode(MemoryPool& pool, dsql_nod* aArg1 = NULL, dsql_nod* aArg2 = NULL);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
virtual void setParameterName(dsql_par* parameter) const;
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
dsql_nod* node, bool forceVarChar);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
dsql_nod* dsqlArg1;
dsql_nod* dsqlArg2;
Const correction for EVL, EXE and they subsystems. Adjustments to CMP and OPT.
2010-08-09 17:48:51 +02:00
NestConst<jrd_nod> arg1;
NestConst<jrd_nod> arg2;
Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
};
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
class CurrentDateNode : public TypedNode<ValueExprNode, ExprNode::TYPE_CURRENT_DATE>
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
{
public:
Misc.
2010-09-23 11:48:42 +02:00
explicit CurrentDateNode(MemoryPool& pool)
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
: TypedNode<ValueExprNode, ExprNode::TYPE_CURRENT_DATE>(pool)
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
{
}
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual void setParameterName(dsql_par* parameter) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
};
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
class CurrentTimeNode : public TypedNode<ValueExprNode, ExprNode::TYPE_CURRENT_TIME>
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
{
public:
CurrentTimeNode(MemoryPool& pool, unsigned aPrecision)
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
: TypedNode<ValueExprNode, ExprNode::TYPE_CURRENT_TIME>(pool),
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
precision(aPrecision)
{
}
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void setParameterName(dsql_par* parameter) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
unsigned precision;
};
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
class CurrentTimeStampNode : public TypedNode<ValueExprNode, ExprNode::TYPE_CURRENT_TIMESTAMP>
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
{
public:
CurrentTimeStampNode(MemoryPool& pool, unsigned aPrecision)
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
: TypedNode<ValueExprNode, ExprNode::TYPE_CURRENT_TIMESTAMP>(pool),
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
precision(aPrecision)
{
}
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void setParameterName(dsql_par* parameter) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
unsigned precision;
};
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
class CurrentRoleNode : public TypedNode<ValueExprNode, ExprNode::TYPE_CURRENT_ROLE>
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
{
public:
Misc.
2010-09-23 11:48:42 +02:00
explicit CurrentRoleNode(MemoryPool& pool)
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
: TypedNode<ValueExprNode, ExprNode::TYPE_CURRENT_ROLE>(pool)
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
{
}
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void setParameterName(dsql_par* parameter) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
};
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
class CurrentUserNode : public TypedNode<ValueExprNode, ExprNode::TYPE_CURRENT_USER>
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
{
public:
Misc.
2010-09-23 11:48:42 +02:00
explicit CurrentUserNode(MemoryPool& pool)
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
: TypedNode<ValueExprNode, ExprNode::TYPE_CURRENT_USER>(pool)
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
{
}
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void setParameterName(dsql_par* parameter) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
};
Refactor EXTRACT
2010-10-16 20:53:25 +02:00
class ExtractNode : public TypedNode<ValueExprNode, ExprNode::TYPE_EXTRACT>
{
public:
ExtractNode(MemoryPool& pool, UCHAR aBlrSubOp, dsql_nod* aArg = NULL);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual void setParameterName(dsql_par* parameter) const;
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
Refactor EXTRACT
2010-10-16 20:53:25 +02:00
dsql_nod* node, bool forceVarChar);
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor EXTRACT
2010-10-16 20:53:25 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
virtual bool expressionEqual(thread_db* tdbb, CompilerScratch* csb, /*const*/ ExprNode* other,
USHORT stream) /*const*/;
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
UCHAR blrSubOp;
dsql_nod* dsqlArg;
NestConst<jrd_nod> arg;
};
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
class GenIdNode : public TypedNode<ValueExprNode, ExprNode::TYPE_GEN_ID>
{
public:
GenIdNode(MemoryPool& pool, bool aDialect1, const Firebird::MetaName& aName,
dsql_nod* aArg = NULL);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual void setParameterName(dsql_par* parameter) const;
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
dsql_nod* node, bool forceVarChar) const;
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
virtual bool jrdVisit(JrdNodeVisitor& visitor)
{
return false;
}
virtual bool jrdUnmappedNodeGetter(UnmappedNodeGetter& visitor)
{
return false;
}
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
virtual bool expressionEqual(thread_db* tdbb, CompilerScratch* csb, /*const*/ ExprNode* other,
USHORT stream) /*const*/;
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
public:
bool dialect1;
Firebird::MetaName name;
dsql_nod* dsqlArg;
NestConst<jrd_nod> arg;
SLONG id;
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
};
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
class InternalInfoNode : public TypedNode<ValueExprNode, ExprNode::TYPE_INTERNAL_INFO>
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
{
public:
// Constants stored in BLR.
enum InfoType
{
INFO_TYPE_UNKNOWN = 0,
INFO_TYPE_CONNECTION_ID = 1,
INFO_TYPE_TRANSACTION_ID = 2,
INFO_TYPE_GDSCODE = 3,
INFO_TYPE_SQLCODE = 4,
INFO_TYPE_ROWS_AFFECTED = 5,
INFO_TYPE_TRIGGER_ACTION = 6,
INFO_TYPE_SQLSTATE = 7,
MAX_INFO_TYPE
};
struct InfoAttr
{
const char* alias;
unsigned mask;
};
static const InfoAttr INFO_TYPE_ATTRIBUTES[MAX_INFO_TYPE];
Misc.
2010-09-23 11:48:42 +02:00
explicit InternalInfoNode(MemoryPool& pool, dsql_nod* aArg = NULL);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void setParameterName(dsql_par* parameter) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
dsql_nod* dsqlArg;
NestConst<jrd_nod> arg;
};
Refactor literal values.
2010-10-24 02:26:00 +02:00
class LiteralNode : public TypedNode<ValueExprNode, ExprNode::TYPE_LITERAL>
{
public:
LiteralNode(MemoryPool& pool);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
static void genConstant(DsqlCompilerScratch* dsqlScratch, const dsc* desc, bool negateValue);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual void setParameterName(dsql_par* parameter) const;
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
Refactor literal values.
2010-10-24 02:26:00 +02:00
dsql_nod* node, bool forceVarChar);
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor literal values.
2010-10-24 02:26:00 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
virtual bool expressionEqual(thread_db* tdbb, CompilerScratch* csb, /*const*/ ExprNode* other,
USHORT stream) /*const*/;
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
SLONG getSlong() const
{
fb_assert(litDesc.dsc_dtype == dtype_long);
return *reinterpret_cast<SLONG*>(litDesc.dsc_address);
}
public:
dsql_str* dsqlStr;
dsc litDesc;
};
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
class NegateNode : public TypedNode<ValueExprNode, ExprNode::TYPE_NEGATE>
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
{
public:
Misc.
2010-09-23 11:48:42 +02:00
explicit NegateNode(MemoryPool& pool, dsql_nod* aArg = NULL);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void setParameterName(dsql_par* parameter) const;
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
dsql_nod* node, bool forceVarChar);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Refactor a number of expression nodes: nod_add, nod_divide, nod_multiply, nod_negate, nod_user_name, nod_subtract, nod_current_date, nod_current_time, nod_current_timestamp, nod_add2, nod_subtract2, nod_multiply2, nod_divide2, nod_current_role, nod_internal_info
2010-09-04 23:36:41 +02:00
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
dsql_nod* dsqlArg;
NestConst<jrd_nod> arg;
};
Refactor NULL expression
2010-10-22 17:00:22 +02:00
class NullNode : public TypedNode<ValueExprNode, ExprNode::TYPE_NULL>
{
public:
explicit NullNode(MemoryPool& pool)
: TypedNode<ValueExprNode, ExprNode::TYPE_NULL>(pool)
{
}
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual void setParameterName(dsql_par* parameter) const;
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor NULL expression
2010-10-22 17:00:22 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
};
Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
// OVER is used only in DSQL. In the engine, normal aggregate functions are used in partitioned
// maps.
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
class OverNode : public TypedNode<ValueExprNode, ExprNode::TYPE_OVER>
Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
{
public:
explicit OverNode(MemoryPool& pool, dsql_nod* aAggExpr = NULL, dsql_nod* aPartition = NULL,
dsql_nod* aOrder = NULL);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
virtual bool dsqlAggregateFinder(AggregateFinder& visitor);
virtual bool dsqlAggregate2Finder(Aggregate2Finder& visitor);
virtual bool dsqlInvalidReferenceFinder(InvalidReferenceFinder& visitor);
virtual bool dsqlSubSelectFinder(SubSelectFinder& visitor);
virtual bool dsqlFieldRemapper(FieldRemapper& visitor);
virtual void setParameterName(dsql_par* parameter) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
dsql_nod* dsqlAggExpr;
dsql_nod* dsqlPartition;
dsql_nod* dsqlOrder;
};
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
class ParameterNode : public TypedNode<ValueExprNode, ExprNode::TYPE_PARAMETER>
{
private:
// CVC: This is a guess for the length of the parameter for LIKE and others, when the
// original dtype isn't string and force_varchar is true.
static const int LIKE_PARAM_LEN = 30;
public:
ParameterNode(MemoryPool& pool);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual void setParameterName(dsql_par* parameter) const
{
}
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
dsql_nod* node, bool forceVarChar);
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
virtual bool jrdVisit(JrdNodeVisitor& visitor)
{
return false;
}
virtual bool jrdUnmappedNodeGetter(UnmappedNodeGetter& visitor)
{
return false;
}
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
USHORT dsqlParameterIndex;
dsql_par* dsqlParameter;
NestConst<jrd_nod> message;
USHORT argNumber;
NestConst<jrd_nod> argFlag;
NestConst<jrd_nod> argIndicator;
NestConst<ItemInfo> argInfo;
};
1) Refactored LOWER, UPPER and TRIM. 2) Fixed CORE-3174 - Expression index with TRIM may lead to incorrect indexed lookup
2010-10-09 20:39:45 +02:00
class StrCaseNode : public TypedNode<ValueExprNode, ExprNode::TYPE_STR_CASE>
{
public:
StrCaseNode(MemoryPool& pool, UCHAR aBlrOp, dsql_nod* aArg = NULL);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual void setParameterName(dsql_par* parameter) const;
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
1) Refactored LOWER, UPPER and TRIM. 2) Fixed CORE-3174 - Expression index with TRIM may lead to incorrect indexed lookup
2010-10-09 20:39:45 +02:00
dsql_nod* node, bool forceVarChar);
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
1) Refactored LOWER, UPPER and TRIM. 2) Fixed CORE-3174 - Expression index with TRIM may lead to incorrect indexed lookup
2010-10-09 20:39:45 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
virtual bool expressionEqual(thread_db* tdbb, CompilerScratch* csb, /*const*/ ExprNode* other,
USHORT stream) /*const*/;
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
UCHAR blrOp;
dsql_nod* dsqlArg;
NestConst<jrd_nod> arg;
};
Refactor *_LENGTH functions
2010-10-16 20:17:00 +02:00
class StrLenNode : public TypedNode<ValueExprNode, ExprNode::TYPE_STR_LEN>
{
public:
StrLenNode(MemoryPool& pool, UCHAR aBlrSubOp, dsql_nod* aArg = NULL);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual void setParameterName(dsql_par* parameter) const;
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
Refactor *_LENGTH functions
2010-10-16 20:17:00 +02:00
dsql_nod* node, bool forceVarChar);
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor *_LENGTH functions
2010-10-16 20:17:00 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
virtual bool expressionEqual(thread_db* tdbb, CompilerScratch* csb, /*const*/ ExprNode* other,
USHORT stream) /*const*/;
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
UCHAR blrSubOp;
dsql_nod* dsqlArg;
NestConst<jrd_nod> arg;
};
Refactor blr_via, blr_from, blr_maximum, blr_minimum, blr_count, blr_average and blr_total
2010-11-07 03:18:58 +01:00
// This node is used for DSQL subqueries and for legacy (BLR-only) functionality.
class SubQueryNode : public TypedNode<ValueExprNode, ExprNode::TYPE_SUBQUERY>
{
public:
explicit SubQueryNode(MemoryPool& pool, UCHAR aBlrOp, dsql_nod* aDsqlRse = NULL,
dsql_nod* aValue1 = NULL, dsql_nod* aValue2 = NULL);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual void setParameterName(dsql_par* parameter) const;
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor blr_via, blr_from, blr_maximum, blr_minimum, blr_count, blr_average and blr_total
2010-11-07 03:18:58 +01:00
virtual bool dsqlAggregateFinder(AggregateFinder& visitor);
virtual bool dsqlAggregate2Finder(Aggregate2Finder& visitor);
virtual bool dsqlSubSelectFinder(SubSelectFinder& visitor);
virtual bool dsqlFieldFinder(FieldFinder& visitor);
virtual bool dsqlFieldRemapper(FieldRemapper& visitor);
virtual bool jrdVisit(JrdNodeVisitor& visitor)
{
return false;
}
virtual bool jrdUnmappedNodeGetter(UnmappedNodeGetter& visitor)
{
return false;
}
virtual bool jrdPossibleUnknownFinder(PossibleUnknownFinder& /*visitor*/)
{
return true;
}
virtual bool jrdStreamFinder(StreamFinder& visitor);
virtual bool jrdStreamsCollector(StreamsCollector& visitor);
virtual bool computable(CompilerScratch* csb, SSHORT stream, bool idxUse,
bool allowOnlyCurrentStream);
virtual void findDependentFromStreams(const OptimizerRetrieval* optRet,
SortedStreamList* streamList);
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
virtual bool expressionEqual(thread_db* tdbb, CompilerScratch* csb, /*const*/ ExprNode* other,
USHORT stream) /*const*/;
virtual ExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
UCHAR blrOp;
dsql_nod* dsqlRse;
dsql_nod* dsqlValue1;
dsql_nod* dsqlValue2;
NestConst<jrd_nod> rse;
NestConst<jrd_nod> value1;
NestConst<jrd_nod> value2;
NestConst<RecordSource> rsb;
};
Refactor SUBSTRING
2010-10-16 19:42:04 +02:00
class SubstringNode : public TypedNode<ValueExprNode, ExprNode::TYPE_SUBSTRING>
{
public:
explicit SubstringNode(MemoryPool& pool, dsql_nod* aExpr = NULL,
dsql_nod* aStart = NULL, dsql_nod* aLength = NULL);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual void setParameterName(dsql_par* parameter) const;
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
Refactor SUBSTRING
2010-10-16 19:42:04 +02:00
dsql_nod* node, bool forceVarChar);
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor SUBSTRING
2010-10-16 19:42:04 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
static dsc* perform(thread_db* tdbb, impure_value* impure, const dsc* valueDsc,
const dsc* startDsc, const dsc* lengthDsc);
public:
dsql_nod* dsqlExpr;
dsql_nod* dsqlStart;
dsql_nod* dsqlLength;
NestConst<jrd_nod> expr;
NestConst<jrd_nod> start;
NestConst<jrd_nod> length;
};
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
class SubstringSimilarNode : public TypedNode<ValueExprNode, ExprNode::TYPE_SUBSTRING_SIMILAR>
Feature CORE-2006 - SUBSTRING with regular expression (SIMILAR TO) capability
2010-02-21 02:47:54 +01:00
{
public:
explicit SubstringSimilarNode(MemoryPool& pool, dsql_nod* aExpr = NULL,
dsql_nod* aPattern = NULL, dsql_nod* aEscape = NULL);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
Feature CORE-2006 - SUBSTRING with regular expression (SIMILAR TO) capability
2010-02-21 02:47:54 +01:00
virtual void setParameterName(dsql_par* parameter) const;
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
dsql_nod* node, bool forceVarChar);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Feature CORE-2006 - SUBSTRING with regular expression (SIMILAR TO) capability
2010-02-21 02:47:54 +01:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Feature CORE-2006 - SUBSTRING with regular expression (SIMILAR TO) capability
2010-02-21 02:47:54 +01:00
virtual ExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
dsql_nod* dsqlExpr;
dsql_nod* dsqlPattern;
dsql_nod* dsqlEscape;
Const correction for EVL, EXE and they subsystems. Adjustments to CMP and OPT.
2010-08-09 17:48:51 +02:00
NestConst<jrd_nod> expr;
NestConst<jrd_nod> pattern;
NestConst<jrd_nod> escape;
Feature CORE-2006 - SUBSTRING with regular expression (SIMILAR TO) capability
2010-02-21 02:47:54 +01:00
};
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
class SysFuncCallNode : public TypedNode<ValueExprNode, ExprNode::TYPE_SYSFUNC_CALL>
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
{
public:
explicit SysFuncCallNode(MemoryPool& pool, const Firebird::MetaName& aName,
dsql_nod* aArgs = NULL);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
virtual void setParameterName(dsql_par* parameter) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
1) Refactor nod_value_if. 2) Created ExprNode::expressionEqual method to replace a new big and ugly switch. 3) Make boolean referencers use BoolExprNode instead of jrd_nod, except nod_validate for now. This includes BinaryBoolNode and NotBoolNode working without jrd_nod references. 4) Rework in the impure allocation code (replace "csb_impure += ..." by CMP_impure calls).
2010-09-20 18:07:50 +02:00
virtual bool expressionEqual(thread_db* tdbb, CompilerScratch* csb, /*const*/ ExprNode* other,
USHORT stream) /*const*/;
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
Firebird::MetaName name;
dsql_nod* dsqlArgs;
bool dsqlSpecialSyntax;
Const correction for EVL, EXE and they subsystems. Adjustments to CMP and OPT.
2010-08-09 17:48:51 +02:00
NestConst<jrd_nod> args;
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
const SysFunction* function;
};
1) Refactored LOWER, UPPER and TRIM. 2) Fixed CORE-3174 - Expression index with TRIM may lead to incorrect indexed lookup
2010-10-09 20:39:45 +02:00
class TrimNode : public TypedNode<ValueExprNode, ExprNode::TYPE_TRIM>
{
public:
explicit TrimNode(MemoryPool& pool, UCHAR aWhere,
dsql_nod* aValue = NULL, dsql_nod* aTrimChars = NULL);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual void setParameterName(dsql_par* parameter) const;
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
1) Refactored LOWER, UPPER and TRIM. 2) Fixed CORE-3174 - Expression index with TRIM may lead to incorrect indexed lookup
2010-10-09 20:39:45 +02:00
dsql_nod* node, bool forceVarChar);
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
1) Refactored LOWER, UPPER and TRIM. 2) Fixed CORE-3174 - Expression index with TRIM may lead to incorrect indexed lookup
2010-10-09 20:39:45 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
virtual bool expressionEqual(thread_db* tdbb, CompilerScratch* csb, /*const*/ ExprNode* other,
USHORT stream) /*const*/;
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
UCHAR where;
dsql_nod* dsqlValue;
dsql_nod* dsqlTrimChars; // may be NULL
NestConst<jrd_nod> value;
NestConst<jrd_nod> trimChars; // may be NULL
};
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
class UdfCallNode : public TypedNode<ValueExprNode, ExprNode::TYPE_UDF_CALL>
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
{
public:
explicit UdfCallNode(MemoryPool& pool, const Firebird::QualifiedName& aName,
dsql_nod* aArgs = NULL);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
virtual void setParameterName(dsql_par* parameter) const;
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
1) Refactor all types of boolean nodes. 2) Remove the scratch from the nodes.
2010-09-17 05:15:32 +02:00
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
1) Refactor nod_value_if. 2) Created ExprNode::expressionEqual method to replace a new big and ugly switch. 3) Make boolean referencers use BoolExprNode instead of jrd_nod, except nod_validate for now. This includes BinaryBoolNode and NotBoolNode working without jrd_nod references. 4) Rework in the impure allocation code (replace "csb_impure += ..." by CMP_impure calls).
2010-09-20 18:07:50 +02:00
virtual bool expressionEqual(thread_db* tdbb, CompilerScratch* csb, /*const*/ ExprNode* other,
USHORT stream) /*const*/;
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
virtual ExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
Firebird::QualifiedName name;
dsql_nod* dsqlArgs;
Const correction for EVL, EXE and they subsystems. Adjustments to CMP and OPT.
2010-08-09 17:48:51 +02:00
NestConst<jrd_nod> args;
Better internal handling of dependencies
2010-08-11 04:59:33 +02:00
NestConst<Function> function;
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
private:
dsql_udf* dsqlFunction;
};
1) Refactor nod_value_if. 2) Created ExprNode::expressionEqual method to replace a new big and ugly switch. 3) Make boolean referencers use BoolExprNode instead of jrd_nod, except nod_validate for now. This includes BinaryBoolNode and NotBoolNode working without jrd_nod references. 4) Rework in the impure allocation code (replace "csb_impure += ..." by CMP_impure calls).
2010-09-20 18:07:50 +02:00
class ValueIfNode : public TypedNode<ValueExprNode, ExprNode::TYPE_VALUE_IF>
{
public:
Misc.
2010-09-23 11:48:42 +02:00
explicit ValueIfNode(MemoryPool& pool, dsql_nod* aCondition = NULL, dsql_nod* aTrueValue = NULL,
1) Refactor nod_value_if. 2) Created ExprNode::expressionEqual method to replace a new big and ugly switch. 3) Make boolean referencers use BoolExprNode instead of jrd_nod, except nod_validate for now. This includes BinaryBoolNode and NotBoolNode working without jrd_nod references. 4) Rework in the impure allocation code (replace "csb_impure += ..." by CMP_impure calls).
2010-09-20 18:07:50 +02:00
dsql_nod* aFalseValue = NULL);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual void setParameterName(dsql_par* parameter) const;
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
dsql_nod* node, bool forceVarChar);
1) Refactor nod_value_if. 2) Created ExprNode::expressionEqual method to replace a new big and ugly switch. 3) Make boolean referencers use BoolExprNode instead of jrd_nod, except nod_validate for now. This includes BinaryBoolNode and NotBoolNode working without jrd_nod references. 4) Rework in the impure allocation code (replace "csb_impure += ..." by CMP_impure calls).
2010-09-20 18:07:50 +02:00
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
1) Refactor nod_value_if. 2) Created ExprNode::expressionEqual method to replace a new big and ugly switch. 3) Make boolean referencers use BoolExprNode instead of jrd_nod, except nod_validate for now. This includes BinaryBoolNode and NotBoolNode working without jrd_nod references. 4) Rework in the impure allocation code (replace "csb_impure += ..." by CMP_impure calls).
2010-09-20 18:07:50 +02:00
virtual bool jrdPossibleUnknownFinder(PossibleUnknownFinder& /*visitor*/)
{
return true;
}
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
dsql_nod* dsqlCondition;
dsql_nod* dsqlTrueValue;
dsql_nod* dsqlFalseValue;
NestConst<BoolExprNode> condition;
NestConst<jrd_nod> trueValue;
NestConst<jrd_nod> falseValue;
};
Refactor variables
2010-11-02 18:05:01 +01:00
class VariableNode : public TypedNode<ValueExprNode, ExprNode::TYPE_VARIABLE>
{
public:
VariableNode(MemoryPool& pool);
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual void setParameterName(dsql_par* parameter) const;
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
Cleanup: removed thisNode parameter from make and setParameterType methods
2010-11-07 04:03:41 +01:00
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Refactor variables
2010-11-02 18:05:01 +01:00
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
virtual bool jrdVisit(JrdNodeVisitor& visitor)
{
return false;
}
virtual bool jrdUnmappedNodeGetter(UnmappedNodeGetter& visitor)
{
return false;
}
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
virtual ExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
dsql_var* dsqlVar;
dsc varDesc;
USHORT varId;
NestConst<jrd_nod> varDecl;
NestConst<ItemInfo> varInfo;
};
Create ExprNode class hierarchy. Convert CONCATENATE and aggregate functions to it. Fix some bugs: - select sum(n) over (order by n2), sum(n) over (), n, n2 from x1; - select (select 1 from x1 b where list(1, a.n) = 1) from x1 a;
2010-02-13 21:29:29 +01:00
} // namespace
#endif // DSQL_EXPR_NODES_H
Copy Permalink