firebird/firebird-mirror
firebird/firebird-mirror
8
0
Fork 1
mirror of https://github.com/FirebirdSQL/firebird.git synced 2025-01-24 22:03:04 +01:00
Code Issues
746c032c90
firebird-mirror/src/dsql/ExprNodes.h

480 lines
18 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
#include "../jrd/common.h"
#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 {
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;
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
dsql_nod* node, bool forceVarChar) 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);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc, dsql_nod* nullReplacement);
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 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;
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
dsql_nod* node, bool forceVarChar) 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);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc, dsql_nod* nullReplacement);
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);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc, dsql_nod* nullReplacement);
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);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc, dsql_nod* nullReplacement);
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);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc, dsql_nod* nullReplacement);
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);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc, dsql_nod* nullReplacement);
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);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc, dsql_nod* nullReplacement);
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 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);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc, dsql_nod* nullReplacement);
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;
};
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;
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
dsql_nod* node, bool forceVarChar) 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);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc, dsql_nod* nullReplacement);
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;
};
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);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc, dsql_nod* nullReplacement);
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;
};
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;
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
dsql_nod* node, bool forceVarChar) 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);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc, dsql_nod* nullReplacement);
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);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc, dsql_nod* nullReplacement);
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) 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);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc, dsql_nod* nullReplacement);
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;
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
dsql_nod* node, bool forceVarChar) const;
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc, dsql_nod* nullReplacement);
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;
};
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