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
9d8720a198
firebird-mirror/src/dsql/ExprNodes.h

1358 lines
46 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;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
class ValueListNode;
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*/;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
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 dsc* execute(thread_db* tdbb, jrd_req* request) const;
// add and add2 are used in somewhat obscure way in aggregation.
Remove dependency of jrd_nod in ExprNode
2010-11-14 23:31:42 +01:00
static dsc* add(const dsc* desc, impure_value* value, const ValueExprNode* node, UCHAR blrOp);
static dsc* add2(const dsc* desc, impure_value* value, const ValueExprNode* node, UCHAR blrOp);
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
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;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> arg1;
NestConst<ValueExprNode> arg2;
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 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*/;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
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 dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
dsql_nod* dsqlSource;
dsql_fld* dsqlField;
dsc castDesc;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> source;
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
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);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
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* dsqlArg1;
dsql_nod* dsqlArg2;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> arg1;
NestConst<ValueExprNode> 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);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
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 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);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
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 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);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
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 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);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
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 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);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
};
Refactor blr_derived_expr
2010-11-07 23:12:14 +01:00
class DerivedExprNode : public TypedNode<ValueExprNode, ExprNode::TYPE_DERIVED_EXPR>
{
public:
Refactor blr_index (nod_scalar)
2010-11-09 00:17:01 +01:00
DerivedExprNode(MemoryPool& pool)
: TypedNode<ValueExprNode, ExprNode::TYPE_DERIVED_EXPR>(pool),
arg(NULL),
streamList(pool)
{
addChildNode(arg);
}
Refactor blr_derived_expr
2010-11-07 23:12:14 +01:00
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
// This is a non-DSQL node.
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const
{
fb_assert(false);
}
virtual void setParameterName(dsql_par* parameter) const
{
fb_assert(false);
}
virtual void genBlr(DsqlCompilerScratch* dsqlScratch)
{
fb_assert(false);
}
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc)
{
fb_assert(false);
}
virtual bool computable(CompilerScratch* csb, SSHORT stream, bool idxUse,
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
bool allowOnlyCurrentStream, ValueExprNode* value);
Refactor blr_derived_expr
2010-11-07 23:12:14 +01:00
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);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactor blr_derived_expr
2010-11-07 23:12:14 +01:00
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> arg;
Refactor blr_derived_expr
2010-11-07 23:12:14 +01:00
Firebird::Array<USHORT> streamList;
};
Refactor nod_domain_validation
2010-11-07 21:26:11 +01:00
class DomainValidationNode : public TypedNode<ValueExprNode, ExprNode::TYPE_DOMAIN_VALIDATION>
{
public:
explicit DomainValidationNode(MemoryPool& pool)
: TypedNode<ValueExprNode, ExprNode::TYPE_DOMAIN_VALIDATION>(pool)
{
domDesc.clear();
}
// This is a non-DSQL node.
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const
{
fb_assert(false);
}
virtual void setParameterName(dsql_par* parameter) const
{
fb_assert(false);
}
virtual void genBlr(DsqlCompilerScratch* dsqlScratch)
{
fb_assert(false);
}
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc)
{
fb_assert(false);
}
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactor nod_domain_validation
2010-11-07 21:26:11 +01:00
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
dsc domDesc;
};
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*/;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactor EXTRACT
2010-10-16 20:53:25 +02:00
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
UCHAR blrSubOp;
dsql_nod* dsqlArg;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> arg;
Refactor EXTRACT
2010-10-16 20:53:25 +02:00
};
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
class FieldNode : public TypedNode<ValueExprNode, ExprNode::TYPE_FIELD>
{
public:
explicit FieldNode(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);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
virtual bool expressionEqual(thread_db* tdbb, CompilerScratch* csb, /*const*/ ExprNode* other,
USHORT stream) /*const*/;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual bool jrdPossibleUnknownFinder()
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
{
return false;
}
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual bool jrdStreamFinder(CompilerScratch* /*csb*/, UCHAR findStream)
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
{
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
return fieldStream == findStream;
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
}
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual void jrdStreamsCollector(Firebird::SortedArray<int>& streamList)
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
{
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
if (!streamList.exist(fieldStream))
streamList.add(fieldStream);
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
}
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual bool jrdUnmappableNode(const MapNode* mapNode, UCHAR shellStream)
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
{
return true;
}
virtual bool computable(CompilerScratch* csb, SSHORT stream, bool idxUse,
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
bool allowOnlyCurrentStream, ValueExprNode* value);
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
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);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
bool byId;
USHORT fieldStream;
USHORT fieldId;
const Format* format;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> defaultValue;
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
};
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
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual bool jrdUnmappableNode(const MapNode* mapNode, UCHAR shellStream)
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
{
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*/;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
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 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;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> arg;
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
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);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
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 dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
dsql_nod* dsqlArg;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> arg;
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
};
Refactor literal values.
2010-10-24 02:26:00 +02:00
class LiteralNode : public TypedNode<ValueExprNode, ExprNode::TYPE_LITERAL>
{
public:
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
explicit LiteralNode(MemoryPool& pool);
Refactor literal values.
2010-10-24 02:26:00 +02:00
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*/;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactor literal values.
2010-10-24 02:26:00 +02:00
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;
};
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
class DsqlMapNode : public TypedNode<ValueExprNode, ExprNode::TYPE_MAP>
{
public:
DsqlMapNode(MemoryPool& pool, dsql_ctx* aContext, dsql_map* aMap);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual bool dsqlAggregateFinder(AggregateFinder& visitor);
virtual bool dsqlAggregate2Finder(Aggregate2Finder& visitor);
virtual bool dsqlInvalidReferenceFinder(InvalidReferenceFinder& visitor);
virtual bool dsqlSubSelectFinder(SubSelectFinder& visitor);
virtual bool dsqlFieldFinder(FieldFinder& visitor);
virtual bool dsqlFieldRemapper(FieldRemapper& visitor);
virtual void setParameterName(dsql_par* parameter) const;
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc)
{
fb_assert(false);
}
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier)
{
fb_assert(false);
return NULL;
}
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const
{
fb_assert(false);
return NULL;
}
public:
dsql_ctx* context;
dsql_map* map;
};
class DerivedFieldNode : public TypedNode<ValueExprNode, ExprNode::TYPE_DERIVED_FIELD>
{
public:
DerivedFieldNode(MemoryPool& pool, const Firebird::MetaName& aName, USHORT aScope,
dsql_nod* aDsqlValue);
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const;
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual bool dsqlAggregateFinder(AggregateFinder& visitor);
virtual bool dsqlAggregate2Finder(Aggregate2Finder& visitor);
virtual bool dsqlInvalidReferenceFinder(InvalidReferenceFinder& visitor);
virtual bool dsqlSubSelectFinder(SubSelectFinder& visitor);
virtual bool dsqlFieldFinder(FieldFinder& visitor);
virtual bool dsqlFieldRemapper(FieldRemapper& visitor);
virtual void setParameterName(dsql_par* parameter) const;
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc)
{
fb_assert(false);
}
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier)
{
fb_assert(false);
return NULL;
}
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const
{
fb_assert(false);
return NULL;
}
public:
Firebird::MetaName name;
USHORT scope;
dsql_nod* dsqlValue;
dsql_ctx* context;
};
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);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
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 dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
dsql_nod* dsqlArg;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> arg;
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
};
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);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactor NULL expression
2010-10-22 17:00:22 +02:00
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:
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
explicit ParameterNode(MemoryPool& pool);
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +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 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;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual bool jrdUnmappableNode(const MapNode* mapNode, UCHAR shellStream)
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
{
return false;
}
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
USHORT dsqlParameterIndex;
dsql_par* dsqlParameter;
NestConst<jrd_nod> message;
USHORT argNumber;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> argFlag;
NestConst<ValueExprNode> argIndicator;
Refactor parameters and GEN_ID.
2010-10-09 03:57:37 +02:00
NestConst<ItemInfo> argInfo;
};
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
class RecordKeyNode : public TypedNode<ValueExprNode, ExprNode::TYPE_RECORD_KEY>
{
public:
RecordKeyNode(MemoryPool& pool, UCHAR aBlrOp, const Firebird::MetaName& aDsqlQualifier = 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 bool dsqlAggregate2Finder(Aggregate2Finder& visitor);
virtual bool dsqlInvalidReferenceFinder(InvalidReferenceFinder& visitor);
virtual bool dsqlSubSelectFinder(SubSelectFinder& visitor);
virtual bool dsqlFieldFinder(FieldFinder& visitor);
virtual bool dsqlFieldRemapper(FieldRemapper& visitor);
virtual void setParameterName(dsql_par* parameter) const;
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual bool jrdPossibleUnknownFinder()
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
{
return false;
}
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual bool jrdStreamFinder(CompilerScratch* csb, UCHAR findStream);
virtual void jrdStreamsCollector(Firebird::SortedArray<int>& streamList);
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
virtual bool computable(CompilerScratch* csb, SSHORT stream, bool idxUse,
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
bool allowOnlyCurrentStream, ValueExprNode* value);
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
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 dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
virtual bool expressionEqual(thread_db* tdbb, CompilerScratch* csb, /*const*/ ExprNode* other,
USHORT stream) /*const*/;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
private:
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
static ValueExprNode* catenateNodes(thread_db* tdbb, ValueExprNodeStack& stack);
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
public:
UCHAR blrOp;
Firebird::MetaName dsqlQualifier;
dsql_nod* dsqlRelation;
USHORT recStream;
bool aggregate;
};
Refactor blr_index (nod_scalar)
2010-11-09 00:17:01 +01:00
class ScalarNode : public TypedNode<ValueExprNode, ExprNode::TYPE_SCALAR>
{
public:
explicit ScalarNode(MemoryPool& pool)
: TypedNode<ValueExprNode, ExprNode::TYPE_SCALAR>(pool),
field(NULL),
subscripts(NULL)
{
addChildNode(field);
addChildNode(subscripts);
}
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
// This is a non-DSQL node.
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const
{
fb_assert(false);
}
virtual void setParameterName(dsql_par* parameter) const
{
fb_assert(false);
}
virtual void genBlr(DsqlCompilerScratch* dsqlScratch)
{
fb_assert(false);
}
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc)
{
fb_assert(false);
}
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactor blr_index (nod_scalar)
2010-11-09 00:17:01 +01:00
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> field;
NestConst<ValueListNode> subscripts;
Refactor blr_index (nod_scalar)
2010-11-09 00:17:01 +01:00
};
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
class StmtExprNode : public TypedNode<ValueExprNode, ExprNode::TYPE_STMT_EXPR>
{
public:
explicit StmtExprNode(MemoryPool& pool)
: TypedNode<ValueExprNode, ExprNode::TYPE_STMT_EXPR>(pool),
stmt(NULL),
expr(NULL)
{
// Do not add the statement. We'll manually handle it in pass1 and pass2.
addChildNode(expr);
}
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, UCHAR blrOp);
// This is a non-DSQL node.
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const
{
fb_assert(false);
}
virtual void setParameterName(dsql_par* parameter) const
{
fb_assert(false);
}
virtual void genBlr(DsqlCompilerScratch* dsqlScratch)
{
fb_assert(false);
}
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc)
{
fb_assert(false);
}
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
NestConst<jrd_nod> stmt;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> expr;
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
};
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*/;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
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 dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
UCHAR blrOp;
dsql_nod* dsqlArg;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> arg;
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
};
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*/;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactor *_LENGTH functions
2010-10-16 20:17:00 +02:00
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
UCHAR blrSubOp;
dsql_nod* dsqlArg;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> arg;
Refactor *_LENGTH functions
2010-10-16 20:17:00 +02:00
};
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);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual bool jrdUnmappableNode(const MapNode* mapNode, UCHAR shellStream)
Refactor blr_via, blr_from, blr_maximum, blr_minimum, blr_count, blr_average and blr_total
2010-11-07 03:18:58 +01:00
{
return false;
}
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual bool jrdPossibleUnknownFinder()
Refactor blr_via, blr_from, blr_maximum, blr_minimum, blr_count, blr_average and blr_total
2010-11-07 03:18:58 +01:00
{
return true;
}
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual bool jrdStreamFinder(CompilerScratch* csb, UCHAR findStream);
virtual void jrdStreamsCollector(Firebird::SortedArray<int>& streamList);
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 computable(CompilerScratch* csb, SSHORT stream, bool idxUse,
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
bool allowOnlyCurrentStream, ValueExprNode* value);
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 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*/;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
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 dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
UCHAR blrOp;
dsql_nod* dsqlRse;
dsql_nod* dsqlValue1;
dsql_nod* dsqlValue2;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<RseNode> rse;
NestConst<ValueExprNode> value1;
NestConst<ValueExprNode> value2;
Refactor blr_via, blr_from, blr_maximum, blr_minimum, blr_count, blr_average and blr_total
2010-11-07 03:18:58 +01:00
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);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactor SUBSTRING
2010-10-16 19:42:04 +02:00
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;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> expr;
NestConst<ValueExprNode> start;
NestConst<ValueExprNode> length;
Refactor SUBSTRING
2010-10-16 19:42:04 +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 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);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Feature CORE-2006 - SUBSTRING with regular expression (SIMILAR TO) capability
2010-02-21 02:47:54 +01:00
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
dsql_nod* dsqlExpr;
dsql_nod* dsqlPattern;
dsql_nod* dsqlEscape;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> expr;
NestConst<ValueExprNode> pattern;
NestConst<ValueExprNode> 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*/;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
Firebird::MetaName name;
dsql_nod* dsqlArgs;
bool dsqlSpecialSyntax;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueListNode> 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*/;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
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 dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
UCHAR where;
dsql_nod* dsqlValue;
dsql_nod* dsqlTrimChars; // may be NULL
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> value;
NestConst<ValueExprNode> trimChars; // may be NULL
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
};
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*/;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactor user and system functions nodes
2010-04-05 20:43:11 +02:00
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
Firebird::QualifiedName name;
dsql_nod* dsqlArgs;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueListNode> 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
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual bool jrdPossibleUnknownFinder()
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
{
return true;
}
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
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 dsc* execute(thread_db* tdbb, jrd_req* request) const;
public:
dsql_nod* dsqlCondition;
dsql_nod* dsqlTrueValue;
dsql_nod* dsqlFalseValue;
NestConst<BoolExprNode> condition;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
NestConst<ValueExprNode> trueValue;
NestConst<ValueExprNode> falseValue;
};
// Container for a list of value expressions.
class ValueListNode : public TypedNode<ValueExprNode, ExprNode::TYPE_VALUE_LIST>
{
public:
ValueListNode(MemoryPool& pool, unsigned count);
// This is a non-DSQL node.
virtual void print(Firebird::string& text, Firebird::Array<dsql_nod*>& nodes) const
{
fb_assert(false);
}
virtual void setParameterName(dsql_par* parameter) const
{
fb_assert(false);
}
virtual void genBlr(DsqlCompilerScratch* dsqlScratch)
{
fb_assert(false);
}
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc)
{
fb_assert(false);
}
virtual ValueListNode* copy(thread_db* tdbb, NodeCopier& copier);
virtual ValueListNode* pass1(thread_db* tdbb, CompilerScratch* csb)
{
ValueExprNode::pass1(tdbb, csb);
return this;
}
virtual ValueListNode* pass2(thread_db* tdbb, CompilerScratch* csb)
{
ValueExprNode::pass2(tdbb, csb);
return this;
}
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc)
{
fb_assert(false); // Invalid operation.
}
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const
{
fb_assert(false); // Invalid operation.
}
public:
NestValueArray args;
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
};
Refactor variables
2010-11-02 18:05:01 +01:00
class VariableNode : public TypedNode<ValueExprNode, ExprNode::TYPE_VARIABLE>
{
public:
Refactored DSQL nodes: nod_derived_field, nod_map, nod_dbkey and nod_rec_version. Refactored JRD nodes: blr_field (JRD side only), blr_dbkey, blr_record_version and blr_stmt_expr.
2010-11-14 18:25:48 +01:00
explicit VariableNode(MemoryPool& pool);
Refactor variables
2010-11-02 18:05:01 +01: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 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;
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual bool jrdUnmappableNode(const MapNode* mapNode, UCHAR shellStream)
Refactor variables
2010-11-02 18:05:01 +01:00
{
return false;
}
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier);
Make ExprNodes and RecordSourceNodes reference others directly instead of via jrd_nod. Store ValueExprNodes instead of jrd_nod in the metadata cache. Make RecordSourceNode child of ExprNode as they share most operations. Get rid of the JRD visitors in favor of direct calls. Convert assignments statement lists created inside expressions to separate source and targets ValuesExprNodes.
2010-11-21 04:47:29 +01:00
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
Refactor variables
2010-11-02 18:05:01 +01:00
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