firebird/firebird-mirror
firebird/firebird-mirror
8
0
Fork 1
mirror of https://github.com/FirebirdSQL/firebird.git synced 2025-01-22 20:03:02 +01:00
Code Issues

Rename class jrd_req to Request.

Browse Source
This commit is contained in:
Adriano dos Santos Fernandes 2022-02-13 10:51:30 -03:00
parent d39f248c77
commit 98f678d4ee
84 changed files with 926 additions and 926 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
src/dsql/AggNodes.cpp
View File

@ -356,7 +356,7 @@ AggNode* AggNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
void AggNode::aggInit(thread_db* tdbb, jrd_req* request) const
void AggNode::aggInit(thread_db* tdbb, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
impure->vlux_count = 0;
@ -378,7 +378,7 @@ void AggNode::aggInit(thread_db* tdbb, jrd_req* request) const
}
}
bool AggNode::aggPass(thread_db* tdbb, jrd_req* request) const
bool AggNode::aggPass(thread_db* tdbb, Request* request) const
{
dsc* desc = NULL;
@ -435,7 +435,7 @@ bool AggNode::aggPass(thread_db* tdbb, jrd_req* request) const
return true;
}
void AggNode::aggFinish(thread_db* /*tdbb*/, jrd_req* request) const
void AggNode::aggFinish(thread_db* /*tdbb*/, Request* request) const
{
if (asb)
{
@ -445,7 +445,7 @@ void AggNode::aggFinish(thread_db* /*tdbb*/, jrd_req* request) const
}
}
dsc* AggNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* AggNode::execute(thread_db* tdbb, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
@ -685,7 +685,7 @@ string AvgAggNode::internalPrint(NodePrinter& printer) const
return "AvgAggNode";
}
void AvgAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
void AvgAggNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -704,7 +704,7 @@ void AvgAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
}
}
void AvgAggNode::aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const
void AvgAggNode::aggPass(thread_db* tdbb, Request* request, dsc* desc) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
if (impure->vlux_count++ == 0) // first call to aggPass()
@ -720,7 +720,7 @@ void AvgAggNode::aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const
ArithmeticNode::add2(tdbb, desc, impure, this, blr_add);
}
dsc* AvgAggNode::aggExecute(thread_db* tdbb, jrd_req* request) const
dsc* AvgAggNode::aggExecute(thread_db* tdbb, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
@ -848,7 +848,7 @@ string ListAggNode::internalPrint(NodePrinter& printer) const
return "ListAggNode";
}
void ListAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
void ListAggNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -859,7 +859,7 @@ void ListAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
impure->vlu_desc.dsc_dtype = 0;
}
void ListAggNode::aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const
void ListAggNode::aggPass(thread_db* tdbb, Request* request, dsc* desc) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
@ -897,7 +897,7 @@ void ListAggNode::aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const
impure->vlu_blob->BLB_put_data(tdbb, temp, len);
}
dsc* ListAggNode::aggExecute(thread_db* tdbb, jrd_req* request) const
dsc* ListAggNode::aggExecute(thread_db* tdbb, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
@ -1000,7 +1000,7 @@ string CountAggNode::internalPrint(NodePrinter& printer) const
}
//// TODO: Improve count(*) in local tables.
void CountAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
void CountAggNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -1008,7 +1008,7 @@ void CountAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
impure->make_int64(0);
}
void CountAggNode::aggPass(thread_db* /*tdbb*/, jrd_req* request, dsc* /*desc*/) const
void CountAggNode::aggPass(thread_db* /*tdbb*/, Request* request, dsc* /*desc*/) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
@ -1018,7 +1018,7 @@ void CountAggNode::aggPass(thread_db* /*tdbb*/, jrd_req* request, dsc* /*desc*/)
++impure->vlu_misc.vlu_int64;
}
dsc* CountAggNode::aggExecute(thread_db* /*tdbb*/, jrd_req* request) const
dsc* CountAggNode::aggExecute(thread_db* /*tdbb*/, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
@ -1253,7 +1253,7 @@ string SumAggNode::internalPrint(NodePrinter& printer) const
return "SumAggNode";
}
void SumAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
void SumAggNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -1269,7 +1269,7 @@ void SumAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
}
}
void SumAggNode::aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const
void SumAggNode::aggPass(thread_db* tdbb, Request* request, dsc* desc) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
++impure->vlux_count;
@ -1280,7 +1280,7 @@ void SumAggNode::aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const
ArithmeticNode::add2(tdbb, desc, impure, this, blr_add);
}
dsc* SumAggNode::aggExecute(thread_db* /*tdbb*/, jrd_req* request) const
dsc* SumAggNode::aggExecute(thread_db* /*tdbb*/, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
@ -1345,7 +1345,7 @@ string MaxMinAggNode::internalPrint(NodePrinter& printer) const
return "MaxMinAggNode";
}
void MaxMinAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
void MaxMinAggNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -1353,7 +1353,7 @@ void MaxMinAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
impure->vlu_desc.dsc_dtype = 0;
}
void MaxMinAggNode::aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const
void MaxMinAggNode::aggPass(thread_db* tdbb, Request* request, dsc* desc) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
++impure->vlux_count;
@ -1370,7 +1370,7 @@ void MaxMinAggNode::aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const
EVL_make_value(tdbb, desc, impure);
}
dsc* MaxMinAggNode::aggExecute(thread_db* /*tdbb*/, jrd_req* request) const
dsc* MaxMinAggNode::aggExecute(thread_db* /*tdbb*/, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
@ -1472,7 +1472,7 @@ string StdDevAggNode::internalPrint(NodePrinter& printer) const
return "StdDevAggNode";
}
void StdDevAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
void StdDevAggNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -1491,7 +1491,7 @@ void StdDevAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
}
}
void StdDevAggNode::aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const
void StdDevAggNode::aggPass(thread_db* tdbb, Request* request, dsc* desc) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
++impure->vlux_count;
@ -1514,7 +1514,7 @@ void StdDevAggNode::aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const
}
}
dsc* StdDevAggNode::aggExecute(thread_db* tdbb, jrd_req* request) const
dsc* StdDevAggNode::aggExecute(thread_db* tdbb, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
StdDevImpure* impure2 = request->getImpure<StdDevImpure>(impure2Offset);
@ -1681,7 +1681,7 @@ string CorrAggNode::internalPrint(NodePrinter& printer) const
return "CorrAggNode";
}
void CorrAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
void CorrAggNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -1700,7 +1700,7 @@ void CorrAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
}
}
bool CorrAggNode::aggPass(thread_db* tdbb, jrd_req* request) const
bool CorrAggNode::aggPass(thread_db* tdbb, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
@ -1744,12 +1744,12 @@ bool CorrAggNode::aggPass(thread_db* tdbb, jrd_req* request) const
return true;
}
void CorrAggNode::aggPass(thread_db* /*tdbb*/, jrd_req* /*request*/, dsc* /*desc*/) const
void CorrAggNode::aggPass(thread_db* /*tdbb*/, Request* /*request*/, dsc* /*desc*/) const
{
fb_assert(false);
}
dsc* CorrAggNode::aggExecute(thread_db* tdbb, jrd_req* request) const
dsc* CorrAggNode::aggExecute(thread_db* tdbb, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
CorrImpure* impure2 = request->getImpure<CorrImpure>(impure2Offset);
@ -1957,7 +1957,7 @@ string RegrAggNode::internalPrint(NodePrinter& printer) const
return "RegrAggNode";
}
void RegrAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
void RegrAggNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -1976,7 +1976,7 @@ void RegrAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
}
}
bool RegrAggNode::aggPass(thread_db* tdbb, jrd_req* request) const
bool RegrAggNode::aggPass(thread_db* tdbb, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
@ -2021,12 +2021,12 @@ bool RegrAggNode::aggPass(thread_db* tdbb, jrd_req* request) const
return true;
}
void RegrAggNode::aggPass(thread_db* /*tdbb*/, jrd_req* /*request*/, dsc* /*desc*/) const
void RegrAggNode::aggPass(thread_db* /*tdbb*/, Request* /*request*/, dsc* /*desc*/) const
{
fb_assert(false);
}
dsc* RegrAggNode::aggExecute(thread_db* tdbb, jrd_req* request) const
dsc* RegrAggNode::aggExecute(thread_db* tdbb, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
@ -2226,7 +2226,7 @@ string RegrCountAggNode::internalPrint(NodePrinter& printer) const
return "RegrCountAggNode";
}
void RegrCountAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
void RegrCountAggNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -2234,7 +2234,7 @@ void RegrCountAggNode::aggInit(thread_db* tdbb, jrd_req* request) const
impure->make_int64(0);
}
bool RegrCountAggNode::aggPass(thread_db* tdbb, jrd_req* request) const
bool RegrCountAggNode::aggPass(thread_db* tdbb, Request* request) const
{
EVL_expr(tdbb, request, arg);
if (request->req_flags & req_null)
@ -2250,12 +2250,12 @@ bool RegrCountAggNode::aggPass(thread_db* tdbb, jrd_req* request) const
return true;
}
void RegrCountAggNode::aggPass(thread_db* /*tdbb*/, jrd_req* /*request*/, dsc* /*desc*/) const
void RegrCountAggNode::aggPass(thread_db* /*tdbb*/, Request* /*request*/, dsc* /*desc*/) const
{
fb_assert(false);
}
dsc* RegrCountAggNode::aggExecute(thread_db* tdbb, jrd_req* request) const
dsc* RegrCountAggNode::aggExecute(thread_db* tdbb, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);

60
src/dsql/AggNodes.h
View File

@ -53,9 +53,9 @@ public:
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual AggNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual void aggPass(thread_db* tdbb, Request* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, Request* request) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -91,9 +91,9 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual void aggPass(thread_db* tdbb, Request* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, Request* request) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -120,9 +120,9 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual void aggPass(thread_db* tdbb, Request* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, Request* request) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -150,9 +150,9 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual void aggPass(thread_db* tdbb, Request* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, Request* request) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -181,9 +181,9 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual void aggPass(thread_db* tdbb, Request* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, Request* request) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -230,9 +230,9 @@ public:
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual AggNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual void aggPass(thread_db* tdbb, Request* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, Request* request) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -288,10 +288,10 @@ public:
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual AggNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual bool aggPass(thread_db* tdbb, jrd_req* request) const;
virtual void aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual bool aggPass(thread_db* tdbb, Request* request) const;
virtual void aggPass(thread_db* tdbb, Request* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, Request* request) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -353,10 +353,10 @@ public:
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual AggNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual bool aggPass(thread_db* tdbb, jrd_req* request) const;
virtual void aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual bool aggPass(thread_db* tdbb, Request* request) const;
virtual void aggPass(thread_db* tdbb, Request* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, Request* request) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -393,10 +393,10 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual bool aggPass(thread_db* tdbb, jrd_req* request) const;
virtual void aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual bool aggPass(thread_db* tdbb, Request* request) const;
virtual void aggPass(thread_db* tdbb, Request* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, Request* request) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;

18
src/dsql/BoolNodes.cpp
View File

@ -170,7 +170,7 @@ BoolExprNode* BinaryBoolNode::copy(thread_db* tdbb, NodeCopier& copier) const
return node;
}
bool BinaryBoolNode::execute(thread_db* tdbb, jrd_req* request) const
bool BinaryBoolNode::execute(thread_db* tdbb, Request* request) const
{
switch (blrOp)
{
@ -185,7 +185,7 @@ bool BinaryBoolNode::execute(thread_db* tdbb, jrd_req* request) const
return false;
}
bool BinaryBoolNode::executeAnd(thread_db* tdbb, jrd_req* request) const
bool BinaryBoolNode::executeAnd(thread_db* tdbb, Request* request) const
{
// If either operand is false, then the result is false;
// If both are true, the result is true;
@ -231,7 +231,7 @@ bool BinaryBoolNode::executeAnd(thread_db* tdbb, jrd_req* request) const
return false;
}
bool BinaryBoolNode::executeOr(thread_db* tdbb, jrd_req* request) const
bool BinaryBoolNode::executeOr(thread_db* tdbb, Request* request) const
{
// If either operand is true, then the result is true;
// If both are false, the result is false;
@ -643,7 +643,7 @@ void ComparativeBoolNode::pass2Boolean2(thread_db* tdbb, CompilerScratch* csb)
}
}
bool ComparativeBoolNode::execute(thread_db* tdbb, jrd_req* request) const
bool ComparativeBoolNode::execute(thread_db* tdbb, Request* request) const
{
dsc* desc[2] = {NULL, NULL};
bool computed_invariant = false;
@ -817,7 +817,7 @@ bool ComparativeBoolNode::execute(thread_db* tdbb, jrd_req* request) const
}
// Perform one of the complex string functions CONTAINING, MATCHES, or STARTS WITH.
bool ComparativeBoolNode::stringBoolean(thread_db* tdbb, jrd_req* request, dsc* desc1,
bool ComparativeBoolNode::stringBoolean(thread_db* tdbb, Request* request, dsc* desc1,
dsc* desc2, bool computedInvariant) const
{
SET_TDBB(tdbb);
@ -1023,7 +1023,7 @@ bool ComparativeBoolNode::stringBoolean(thread_db* tdbb, jrd_req* request, dsc*
}
// Execute SLEUTH operator.
bool ComparativeBoolNode::sleuth(thread_db* tdbb, jrd_req* request, const dsc* desc1,
bool ComparativeBoolNode::sleuth(thread_db* tdbb, Request* request, const dsc* desc1,
const dsc* desc2) const
{
SET_TDBB(tdbb);
@ -1223,7 +1223,7 @@ void MissingBoolNode::pass2Boolean2(thread_db* tdbb, CompilerScratch* csb)
arg->getDesc(tdbb, csb, &descriptor_a);
}
bool MissingBoolNode::execute(thread_db* tdbb, jrd_req* request) const
bool MissingBoolNode::execute(thread_db* tdbb, Request* request) const
{
EVL_expr(tdbb, request, arg);
@ -1298,7 +1298,7 @@ BoolExprNode* NotBoolNode::pass1(thread_db* tdbb, CompilerScratch* csb)
return BoolExprNode::pass1(tdbb, csb);
}
bool NotBoolNode::execute(thread_db* tdbb, jrd_req* request) const
bool NotBoolNode::execute(thread_db* tdbb, Request* request) const
{
bool value = arg->execute(tdbb, request);
@ -1612,7 +1612,7 @@ void RseBoolNode::pass2Boolean2(thread_db* tdbb, CompilerScratch* csb)
subQuery = FB_NEW_POOL(*tdbb->getDefaultPool()) SubQuery(rsb, rse->rse_invariants);
}
bool RseBoolNode::execute(thread_db* tdbb, jrd_req* request) const
bool RseBoolNode::execute(thread_db* tdbb, Request* request) const
{
USHORT* invariant_flags;
impure_value* impure;

18
src/dsql/BoolNodes.h
View File

@ -54,11 +54,11 @@ public:
virtual BoolExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual bool dsqlMatch(DsqlCompilerScratch* dsqlScratch, const ExprNode* other, bool ignoreMapCast) const;
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual bool execute(thread_db* tdbb, jrd_req* request) const;
virtual bool execute(thread_db* tdbb, Request* request) const;
private:
virtual bool executeAnd(thread_db* tdbb, jrd_req* request) const;
virtual bool executeOr(thread_db* tdbb, jrd_req* request) const;
virtual bool executeAnd(thread_db* tdbb, Request* request) const;
virtual bool executeOr(thread_db* tdbb, Request* request) const;
public:
UCHAR blrOp;
@ -106,12 +106,12 @@ public:
virtual BoolExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual void pass2Boolean1(thread_db* tdbb, CompilerScratch* csb);
virtual void pass2Boolean2(thread_db* tdbb, CompilerScratch* csb);
virtual bool execute(thread_db* tdbb, jrd_req* request) const;
virtual bool execute(thread_db* tdbb, Request* request) const;
private:
bool stringBoolean(thread_db* tdbb, jrd_req* request, dsc* desc1, dsc* desc2,
bool stringBoolean(thread_db* tdbb, Request* request, dsc* desc1, dsc* desc2,
bool computedInvariant) const;
bool sleuth(thread_db* tdbb, jrd_req* request, const dsc* desc1, const dsc* desc2) const;
bool sleuth(thread_db* tdbb, Request* request, const dsc* desc1, const dsc* desc2) const;
BoolExprNode* createRseNode(DsqlCompilerScratch* dsqlScratch, UCHAR rseBlrOp);
@ -151,7 +151,7 @@ public:
virtual BoolExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual BoolExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual void pass2Boolean2(thread_db* tdbb, CompilerScratch* csb);
virtual bool execute(thread_db* tdbb, jrd_req* request) const;
virtual bool execute(thread_db* tdbb, Request* request) const;
public:
bool dsqlUnknown;
@ -183,7 +183,7 @@ public:
virtual BoolExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual BoolExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual bool execute(thread_db* tdbb, jrd_req* request) const;
virtual bool execute(thread_db* tdbb, Request* request) const;
private:
BoolExprNode* process(DsqlCompilerScratch* dsqlScratch, bool invert);
@ -235,7 +235,7 @@ public:
virtual BoolExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual void pass2Boolean1(thread_db* tdbb, CompilerScratch* csb);
virtual void pass2Boolean2(thread_db* tdbb, CompilerScratch* csb);
virtual bool execute(thread_db* tdbb, jrd_req* request) const;
virtual bool execute(thread_db* tdbb, Request* request) const;
private:
BoolExprNode* convertNeqAllToNotAny(thread_db* tdbb, CompilerScratch* csb);

2
src/dsql/DsqlBatch.cpp
View File

@ -652,7 +652,7 @@ private:
// execute request
m_dsqlRequest->req_transaction = transaction;
jrd_req* req = m_dsqlRequest->getRequest();
Request* req = m_dsqlRequest->getRequest();
fb_assert(req);
// prepare completion interface

8
src/dsql/DsqlRequests.h
View File

@ -41,7 +41,7 @@ class DsqlCompilerScratch;
class DsqlCursor;
class DsqlDmlStatement;
class dsql_par;
class jrd_req;
class Request;
class jrd_tra;
class Statement;
class SessionManagementNode;
@ -70,7 +70,7 @@ public:
return nullptr;
}
virtual jrd_req* getRequest() const
virtual Request* getRequest() const
{
return nullptr;
}
@ -160,7 +160,7 @@ public:
Statement* getStatement() const override;
jrd_req* getRequest() const override
Request* getRequest() const override
{
return request;
}
@ -209,7 +209,7 @@ public:
private:
Firebird::RefPtr<Firebird::IMessageMetadata> delayedFormat;
jrd_req* request = nullptr;
Request* request = nullptr;
bool needDelayedFormat = false;
bool firstRowFetched = false;
};

86
src/dsql/ExprNodes.cpp
View File

@ -1838,7 +1838,7 @@ ValueExprNode* ArithmeticNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* ArithmeticNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* ArithmeticNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
@ -3214,7 +3214,7 @@ ValueExprNode* AtNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* AtNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* AtNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
request->req_flags &= ~req_null;
@ -3332,7 +3332,7 @@ ValueExprNode* BoolAsValueNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* BoolAsValueNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* BoolAsValueNode::execute(thread_db* tdbb, Request* request) const
{
UCHAR booleanVal = (UCHAR) boolean->execute(tdbb, request);
@ -3552,7 +3552,7 @@ ValueExprNode* CastNode::pass2(thread_db* tdbb, CompilerScratch* csb)
}
// Cast from one datatype to another.
dsc* CastNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* CastNode::execute(thread_db* tdbb, Request* request) const
{
dsc* value = EVL_expr(tdbb, request, source);
@ -3732,7 +3732,7 @@ ValueExprNode* CoalesceNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* CoalesceNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* CoalesceNode::execute(thread_db* tdbb, Request* request) const
{
for (auto& item : args->items)
{
@ -3931,7 +3931,7 @@ ValueExprNode* ConcatenateNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* ConcatenateNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* ConcatenateNode::execute(thread_db* tdbb, Request* request) const
{
const dsc* value1 = EVL_expr(tdbb, request, arg1);
const ULONG flags = request->req_flags;
@ -4164,7 +4164,7 @@ ValueExprNode* CurrentDateNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* CurrentDateNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* CurrentDateNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
request->req_flags &= ~req_null;
@ -4267,7 +4267,7 @@ ValueExprNode* CurrentTimeNode::dsqlPass(DsqlCompilerScratch* /*dsqlScratch*/)
return this;
}
dsc* CurrentTimeNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* CurrentTimeNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
request->req_flags &= ~req_null;
@ -4372,7 +4372,7 @@ ValueExprNode* CurrentTimeStampNode::dsqlPass(DsqlCompilerScratch* /*dsqlScratch
return this;
}
dsc* CurrentTimeStampNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* CurrentTimeStampNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
request->req_flags &= ~req_null;
@ -4450,7 +4450,7 @@ ValueExprNode* CurrentRoleNode::pass2(thread_db* tdbb, CompilerScratch* csb)
}
// CVC: Current role will get a validated role; IE one that exists.
dsc* CurrentRoleNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* CurrentRoleNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
request->req_flags &= ~req_null;
@ -4536,7 +4536,7 @@ ValueExprNode* CurrentUserNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* CurrentUserNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* CurrentUserNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
request->req_flags &= ~req_null;
@ -4785,7 +4785,7 @@ ValueExprNode* DecodeNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* DecodeNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* DecodeNode::execute(thread_db* tdbb, Request* request) const
{
dsc* testDesc = EVL_expr(tdbb, request, test);
@ -5123,7 +5123,7 @@ ValueExprNode* DerivedExprNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* DerivedExprNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* DerivedExprNode::execute(thread_db* tdbb, Request* request) const
{
if (cursorNumber.specified)
request->req_cursors[cursorNumber.value]->checkState(request);
@ -5208,7 +5208,7 @@ ValueExprNode* DomainValidationNode::pass2(thread_db* tdbb, CompilerScratch* csb
return this;
}
dsc* DomainValidationNode::execute(thread_db* /*tdbb*/, jrd_req* request) const
dsc* DomainValidationNode::execute(thread_db* /*tdbb*/, Request* request) const
{
if (request->req_domain_validation == NULL ||
(request->req_domain_validation->dsc_flags & DSC_null))
@ -5419,7 +5419,7 @@ ValueExprNode* ExtractNode::pass2(thread_db* tdbb, CompilerScratch* csb)
}
// Handles EXTRACT(part FROM date/time/timestamp)
dsc* ExtractNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* ExtractNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
request->req_flags &= ~req_null;
@ -6796,7 +6796,7 @@ ValueExprNode* FieldNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* FieldNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* FieldNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
@ -7056,7 +7056,7 @@ ValueExprNode* GenIdNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* GenIdNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* GenIdNode::execute(thread_db* tdbb, Request* request) const
{
request->req_flags &= ~req_null;
@ -7254,7 +7254,7 @@ ValueExprNode* InternalInfoNode::pass2(thread_db* tdbb, CompilerScratch* csb)
}
// Return a given element of the internal engine data.
dsc* InternalInfoNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* InternalInfoNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
request->req_flags &= ~req_null;
@ -7954,7 +7954,7 @@ ValueExprNode* LiteralNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* LiteralNode::execute(thread_db* /*tdbb*/, jrd_req* /*request*/) const
dsc* LiteralNode::execute(thread_db* /*tdbb*/, Request* /*request*/) const
{
return const_cast<dsc*>(&litDesc);
}
@ -8131,7 +8131,7 @@ ValueExprNode* LocalTimeNode::dsqlPass(DsqlCompilerScratch* /*dsqlScratch*/)
return this;
}
dsc* LocalTimeNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* LocalTimeNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
request->req_flags &= ~req_null;
@ -8223,7 +8223,7 @@ ValueExprNode* LocalTimeStampNode::dsqlPass(DsqlCompilerScratch* /*dsqlScratch*/
return this;
}
dsc* LocalTimeStampNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* LocalTimeStampNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
request->req_flags &= ~req_null;
@ -8834,7 +8834,7 @@ ValueExprNode* NegateNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* NegateNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* NegateNode::execute(thread_db* tdbb, Request* request) const
{
request->req_flags &= ~req_null;
@ -8962,7 +8962,7 @@ ValueExprNode* NullNode::copy(thread_db* tdbb, NodeCopier& /*copier*/) const
return &INSTANCE;
}
dsc* NullNode::execute(thread_db* /*tdbb*/, jrd_req* /*request*/) const
dsc* NullNode::execute(thread_db* /*tdbb*/, Request* /*request*/) const
{
return NULL;
}
@ -9363,7 +9363,7 @@ ValueExprNode* OverNode::copy(thread_db* /*tdbb*/, NodeCopier& /*copier*/) const
return NULL;
}
dsc* OverNode::execute(thread_db* /*tdbb*/, jrd_req* /*request*/) const
dsc* OverNode::execute(thread_db* /*tdbb*/, Request* /*request*/) const
{
fb_assert(false);
return NULL;
@ -9645,7 +9645,7 @@ bool ParameterNode::dsqlMatch(DsqlCompilerScratch* dsqlScratch, const ExprNode*
return o && outerDecl == o->outerDecl && dsqlParameter->par_index == o->dsqlParameter->par_index;
}
jrd_req* ParameterNode::getParamRequest(jrd_req* request) const
Request* ParameterNode::getParamRequest(Request* request) const
{
auto paramRequest = request;
@ -9715,7 +9715,7 @@ ValueExprNode* ParameterNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* ParameterNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* ParameterNode::execute(thread_db* tdbb, Request* request) const
{
dsc* retDesc;
impure_value* impureForOuter;
@ -9733,7 +9733,7 @@ dsc* ParameterNode::execute(thread_db* tdbb, jrd_req* request) const
const auto paramRequest = getParamRequest(request);
AutoSetRestore2<jrd_req*, thread_db> autoSetRequest(
AutoSetRestore2<Request*, thread_db> autoSetRequest(
tdbb, &thread_db::getRequest, &thread_db::setRequest, paramRequest);
const dsc* desc;
@ -10278,7 +10278,7 @@ ValueExprNode* RecordKeyNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* RecordKeyNode::execute(thread_db* /*tdbb*/, jrd_req* request) const
dsc* RecordKeyNode::execute(thread_db* /*tdbb*/, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
const record_param* rpb = &request->req_rpb[recStream];
@ -10466,7 +10466,7 @@ ValueExprNode* ScalarNode::pass2(thread_db* tdbb, CompilerScratch* csb)
}
// Evaluate a scalar item from an array.
dsc* ScalarNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* ScalarNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
const dsc* desc = EVL_expr(tdbb, request, field);
@ -10553,7 +10553,7 @@ ValueExprNode* StmtExprNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return NULL;
}
dsc* StmtExprNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* StmtExprNode::execute(thread_db* tdbb, Request* request) const
{
fb_assert(false);
return NULL;
@ -10680,7 +10680,7 @@ ValueExprNode* StrCaseNode::pass2(thread_db* tdbb, CompilerScratch* csb)
}
// Low/up case a string.
dsc* StrCaseNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* StrCaseNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
request->req_flags &= ~req_null;
@ -10898,7 +10898,7 @@ ValueExprNode* StrLenNode::pass2(thread_db* tdbb, CompilerScratch* csb)
}
// Handles BIT_LENGTH(s), OCTET_LENGTH(s) and CHAR[ACTER]_LENGTH(s)
dsc* StrLenNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* StrLenNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* const impure = request->getImpure<impure_value>(impureOffset);
request->req_flags &= ~req_null;
@ -11351,7 +11351,7 @@ ValueExprNode* SubQueryNode::pass2(thread_db* tdbb, CompilerScratch* csb)
}
// Evaluate a subquery expression.
dsc* SubQueryNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* SubQueryNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* impure = request->getImpure<impure_value>(impureOffset);
request->req_flags &= ~req_null;
@ -11674,7 +11674,7 @@ ValueExprNode* SubstringNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* SubstringNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* SubstringNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* impure = request->getImpure<impure_value>(impureOffset);
@ -11980,7 +11980,7 @@ ValueExprNode* SubstringSimilarNode::pass2(thread_db* tdbb, CompilerScratch* csb
return this;
}
dsc* SubstringSimilarNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* SubstringSimilarNode::execute(thread_db* tdbb, Request* request) const
{
// Run all expression arguments.
@ -12277,7 +12277,7 @@ ValueExprNode* SysFuncCallNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* SysFuncCallNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* SysFuncCallNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* impure = request->getImpure<impure_value>(impureOffset);
return function->evlFunc(tdbb, function, args->items, impure);
@ -12546,7 +12546,7 @@ ValueExprNode* TrimNode::pass2(thread_db* tdbb, CompilerScratch* csb)
}
// Perform trim function = TRIM([where what FROM] string).
dsc* TrimNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* TrimNode::execute(thread_db* tdbb, Request* request) const
{
impure_value* impure = request->getImpure<impure_value>(impureOffset);
request->req_flags &= ~req_null;
@ -12974,7 +12974,7 @@ ValueExprNode* UdfCallNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* UdfCallNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* UdfCallNode::execute(thread_db* tdbb, Request* request) const
{
UCHAR* impure = request->getImpure<UCHAR>(impureOffset);
Impure* impureArea = request->getImpure<Impure>(impureOffset);
@ -13098,7 +13098,7 @@ dsc* UdfCallNode::execute(thread_db* tdbb, jrd_req* request) const
const SavNumber savNumber = transaction->tra_save_point ?
transaction->tra_save_point->getNumber() : 0;
jrd_req* funcRequest = function->getStatement()->findRequest(tdbb);
Request* funcRequest = function->getStatement()->findRequest(tdbb);
// trace function execution start
TraceFuncExecute trace(tdbb, funcRequest, request, inMsg, inMsgLength);
@ -13490,7 +13490,7 @@ ValueExprNode* ValueIfNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* ValueIfNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* ValueIfNode::execute(thread_db* tdbb, Request* request) const
{
return EVL_expr(tdbb, request, (condition->execute(tdbb, request) ? trueValue : falseValue));
}
@ -13652,7 +13652,7 @@ bool VariableNode::dsqlMatch(DsqlCompilerScratch* dsqlScratch, const ExprNode* o
return true;
}
jrd_req* VariableNode::getVarRequest(jrd_req* request) const
Request* VariableNode::getVarRequest(Request* request) const
{
auto varRequest = request;
@ -13709,7 +13709,7 @@ ValueExprNode* VariableNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
dsc* VariableNode::execute(thread_db* tdbb, jrd_req* request) const
dsc* VariableNode::execute(thread_db* tdbb, Request* request) const
{
const auto varRequest = getVarRequest(request);
const auto varImpure = varRequest->getImpure<impure_value>(varDecl->impureOffset);
@ -13736,7 +13736,7 @@ dsc* VariableNode::execute(thread_db* tdbb, jrd_req* request) const
{
if (varInfo)
{
AutoSetRestore2<jrd_req*, thread_db> autoSetRequest(
AutoSetRestore2<Request*, thread_db> autoSetRequest(
tdbb, &thread_db::getRequest, &thread_db::setRequest, varRequest);
EVL_validate(tdbb, Item(Item::TYPE_VARIABLE, varId), varInfo,

90
src/dsql/ExprNodes.h
View File

@ -91,7 +91,7 @@ public:
virtual bool dsqlMatch(DsqlCompilerScratch* dsqlScratch, const ExprNode* other, bool ignoreMapCast) const;
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
// add and add2 are used in somewhat obscure way in aggregation.
static dsc* add(thread_db* tdbb, const dsc* desc, impure_value* value, const ValueExprNode* node,
@ -160,7 +160,7 @@ public:
return NULL;
}
virtual dsc* execute(thread_db* /*tdbb*/, jrd_req* /*request*/) const
virtual dsc* execute(thread_db* /*tdbb*/, Request* /*request*/) const
{
fb_assert(false);
return NULL;
@ -196,7 +196,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
NestConst<ValueExprNode> dateTimeArg;
@ -230,7 +230,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
NestConst<BoolExprNode> boolean;
@ -269,7 +269,7 @@ public:
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
MetaName dsqlAlias;
@ -310,7 +310,7 @@ public:
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
virtual bool possiblyUnknown() const
{
@ -369,7 +369,7 @@ public:
return NULL;
}
virtual dsc* execute(thread_db* /*tdbb*/, jrd_req* /*request*/) const
virtual dsc* execute(thread_db* /*tdbb*/, Request* /*request*/) const
{
fb_assert(false);
return NULL;
@ -409,7 +409,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
NestConst<ValueExprNode> arg1;
@ -435,7 +435,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
};
@ -459,7 +459,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
unsigned precision;
@ -486,7 +486,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
unsigned precision;
@ -512,7 +512,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
};
@ -535,7 +535,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
};
@ -575,7 +575,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
Firebird::string label;
@ -673,7 +673,7 @@ public:
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
NestConst<ValueExprNode> arg;
@ -704,7 +704,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
dsc domDesc;
@ -737,7 +737,7 @@ public:
virtual bool dsqlMatch(DsqlCompilerScratch* dsqlScratch, const ExprNode* other, bool ignoreMapCast) const;
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
UCHAR blrSubOp;
@ -802,7 +802,7 @@ public:
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
private:
static dsql_fld* resolveContext(DsqlCompilerScratch* dsqlScratch,
@ -853,7 +853,7 @@ public:
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
GeneratorItem generator;
@ -898,7 +898,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
NestConst<ValueExprNode> arg;
@ -927,7 +927,7 @@ public:
virtual bool dsqlMatch(DsqlCompilerScratch* dsqlScratch, const ExprNode* other, bool ignoreMapCast) const;
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
SLONG getSlong() const
{
@ -992,7 +992,7 @@ public:
return NULL;
}
virtual dsc* execute(thread_db* /*tdbb*/, jrd_req* /*request*/) const
virtual dsc* execute(thread_db* /*tdbb*/, Request* /*request*/) const
{
fb_assert(false);
return NULL;
@ -1041,7 +1041,7 @@ public:
return NULL;
}
virtual dsc* execute(thread_db* /*tdbb*/, jrd_req* /*request*/) const
virtual dsc* execute(thread_db* /*tdbb*/, Request* /*request*/) const
{
fb_assert(false);
return NULL;
@ -1117,7 +1117,7 @@ public:
return NULL;
}
virtual dsc* execute(thread_db* /*tdbb*/, jrd_req* /*request*/) const
virtual dsc* execute(thread_db* /*tdbb*/, Request* /*request*/) const
{
fb_assert(false);
return NULL;
@ -1151,7 +1151,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
unsigned precision;
@ -1178,7 +1178,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
unsigned precision;
@ -1209,7 +1209,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
NestConst<ValueExprNode> arg;
@ -1247,7 +1247,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
private:
static Firebird::GlobalPtr<NullNode> INSTANCE;
@ -1553,7 +1553,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
NestConst<ValueExprNode> aggExpr;
@ -1595,12 +1595,12 @@ public:
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
virtual bool dsqlMatch(DsqlCompilerScratch* dsqlScratch, const ExprNode* other, bool ignoreMapCast) const;
jrd_req* getParamRequest(jrd_req* request) const;
Request* getParamRequest(Request* request) const;
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
dsql_msg* dsqlMessage = nullptr;
@ -1665,7 +1665,7 @@ public:
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
const char* getAlias(bool rdb) const
{
@ -1742,7 +1742,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
NestConst<ValueExprNode> field;
@ -1801,7 +1801,7 @@ public:
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
NestConst<StmtNode> stmt;
@ -1835,7 +1835,7 @@ public:
virtual bool dsqlMatch(DsqlCompilerScratch* dsqlScratch, const ExprNode* other, bool ignoreMapCast) const;
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
const UCHAR blrOp;
@ -1869,7 +1869,7 @@ public:
virtual bool dsqlMatch(DsqlCompilerScratch* dsqlScratch, const ExprNode* other, bool ignoreMapCast) const;
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
UCHAR blrSubOp;
@ -1923,7 +1923,7 @@ public:
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
NestConst<RecordSourceNode> dsqlRse;
@ -1964,7 +1964,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
static dsc* perform(thread_db* tdbb, impure_value* impure, const dsc* valueDsc,
const dsc* startDsc, const dsc* lengthDsc);
@ -2005,7 +2005,7 @@ public:
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
NestConst<ValueExprNode> expr;
@ -2039,7 +2039,7 @@ public:
virtual bool dsqlMatch(DsqlCompilerScratch* dsqlScratch, const ExprNode* other, bool ignoreMapCast) const;
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
MetaName name;
@ -2078,7 +2078,7 @@ public:
virtual bool dsqlMatch(DsqlCompilerScratch* dsqlScratch, const ExprNode* other, bool ignoreMapCast) const;
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
UCHAR where;
@ -2125,7 +2125,7 @@ public:
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
QualifiedName name;
@ -2172,7 +2172,7 @@ public:
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
NestConst<BoolExprNode> condition;
@ -2200,13 +2200,13 @@ public:
dsqlDesc = desc;
}
jrd_req* getVarRequest(jrd_req* request) const;
Request* getVarRequest(Request* request) const;
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
public:
MetaName dsqlName;

32
src/dsql/Nodes.h
View File

@ -746,7 +746,7 @@ public:
}
virtual BoolExprNode* copy(thread_db* tdbb, NodeCopier& copier) const = 0;
virtual bool execute(thread_db* tdbb, jrd_req* request) const = 0;
virtual bool execute(thread_db* tdbb, Request* request) const = 0;
};
class ValueExprNode : public ExprNode
@ -828,7 +828,7 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc) = 0;
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const = 0;
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const = 0;
virtual dsc* execute(thread_db* tdbb, Request* request) const = 0;
public:
SCHAR nodScale;
@ -885,7 +885,7 @@ public:
return NULL;
}
virtual dsc* execute(thread_db* /*tdbb*/, jrd_req* /*request*/) const
virtual dsc* execute(thread_db* /*tdbb*/, Request* /*request*/) const
{
fb_assert(false);
return NULL;
@ -1043,19 +1043,19 @@ public:
return false;
}
virtual dsc* winPass(thread_db* /*tdbb*/, jrd_req* /*request*/, SlidingWindow* /*window*/) const
virtual dsc* winPass(thread_db* /*tdbb*/, Request* /*request*/, SlidingWindow* /*window*/) const
{
return NULL;
}
virtual void aggInit(thread_db* tdbb, jrd_req* request) const = 0; // pure, but defined
virtual void aggFinish(thread_db* tdbb, jrd_req* request) const;
virtual bool aggPass(thread_db* tdbb, jrd_req* request) const;
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const = 0; // pure, but defined
virtual void aggFinish(thread_db* tdbb, Request* request) const;
virtual bool aggPass(thread_db* tdbb, Request* request) const;
virtual dsc* execute(thread_db* tdbb, Request* request) const;
virtual unsigned getCapabilities() const = 0;
virtual void aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const = 0;
virtual dsc* aggExecute(thread_db* tdbb, jrd_req* request) const = 0;
virtual void aggPass(thread_db* tdbb, Request* request, dsc* desc) const = 0;
virtual dsc* aggExecute(thread_db* tdbb, Request* request) const = 0;
virtual AggNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
@ -1087,11 +1087,11 @@ public:
explicit WinFuncNode(MemoryPool& pool, const AggInfo& aAggInfo, ValueExprNode* aArg = NULL);
public:
virtual void aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const
virtual void aggPass(thread_db* tdbb, Request* request, dsc* desc) const
{
}
virtual dsc* aggExecute(thread_db* tdbb, jrd_req* request) const
virtual dsc* aggExecute(thread_db* tdbb, Request* request) const
{
return NULL;
}
@ -1441,7 +1441,7 @@ public:
struct ExeState
{
ExeState(thread_db* tdbb, jrd_req* request, jrd_tra* transaction)
ExeState(thread_db* tdbb, Request* request, jrd_tra* transaction)
: savedTdbb(tdbb),
oldPool(tdbb->getDefaultPool()),
oldRequest(tdbb->getRequest()),
@ -1467,7 +1467,7 @@ public:
thread_db* savedTdbb;
MemoryPool* oldPool; // Save the old pool to restore on exit.
jrd_req* oldRequest; // Save the old request to restore on exit.
Request* oldRequest; // Save the old request to restore on exit.
jrd_tra* oldTransaction; // Save the old transcation to restore on exit.
const StmtNode* topNode;
const StmtNode* prevNode;
@ -1529,7 +1529,7 @@ public:
return NULL;
}
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const = 0;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const = 0;
public:
NestConst<StmtNode> parentStmt;
@ -1567,7 +1567,7 @@ public:
return NULL;
}
const StmtNode* execute(thread_db* /*tdbb*/, jrd_req* /*request*/, ExeState* /*exeState*/) const
const StmtNode* execute(thread_db* /*tdbb*/, Request* /*request*/, ExeState* /*exeState*/) const
{
fb_assert(false);
return NULL;

356
src/dsql/StmtNodes.cpp
View File

File diff suppressed because it is too large Load Diff

90
src/dsql/StmtNodes.h
View File

@ -143,7 +143,7 @@ public:
virtual AssignmentNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual AssignmentNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual AssignmentNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
NestConst<ValueExprNode> asgnFrom;
@ -171,10 +171,10 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual BlockNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual BlockNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
private:
static bool testAndFixupError(thread_db* tdbb, jrd_req* request, const ExceptionArray& conditions);
static bool testAndFixupError(thread_db* tdbb, Request* request, const ExceptionArray& conditions);
public:
NestConst<StmtNode> action;
@ -201,7 +201,7 @@ public:
virtual CompoundStmtNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual CompoundStmtNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual CompoundStmtNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
Firebird::Array<NestConst<StmtNode> > statements;
@ -238,7 +238,7 @@ public:
return this;
}
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
UCHAR blrOp;
@ -271,7 +271,7 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual CursorStmtNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual CursorStmtNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
MetaName dsqlName;
@ -314,7 +314,7 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual DeclareCursorNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual DeclareCursorNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
MetaName dsqlName;
@ -356,10 +356,10 @@ public:
}
DeclareLocalTableNode* pass2(thread_db* tdbb, CompilerScratch* csb) override;
const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const override;
const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const override;
public:
Impure* getImpure(thread_db* tdbb, jrd_req* request, bool createWhenDead = true) const;
Impure* getImpure(thread_db* tdbb, Request* request, bool createWhenDead = true) const;
public:
NestConst<Format> format;
@ -396,7 +396,7 @@ public:
virtual DeclareSubFuncNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual DeclareSubFuncNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
private:
static void parseParameters(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb,
@ -449,7 +449,7 @@ public:
virtual DeclareSubProcNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual DeclareSubProcNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
private:
static void parseParameters(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb,
@ -491,7 +491,7 @@ public:
virtual DeclareVariableNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual DeclareVariableNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual DeclareVariableNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
NestConst<ParameterClause> dsqlDef;
@ -530,11 +530,11 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual EraseNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual EraseNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
private:
static void pass1Erase(thread_db* tdbb, CompilerScratch* csb, EraseNode* node);
const StmtNode* erase(thread_db* tdbb, jrd_req* request, WhichTrigger whichTrig) const;
const StmtNode* erase(thread_db* tdbb, Request* request, WhichTrigger whichTrig) const;
public:
NestConst<RelationSourceNode> dsqlRelation;
@ -572,7 +572,7 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual ErrorHandlerNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ErrorHandlerNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
NestConst<StmtNode> action;
@ -607,11 +607,11 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual ExecProcedureNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ExecProcedureNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
private:
ValueListNode* explodeOutputs(DsqlCompilerScratch* dsqlScratch, const dsql_prc* procedure);
void executeProcedure(thread_db* tdbb, jrd_req* request) const;
void executeProcedure(thread_db* tdbb, Request* request) const;
public:
QualifiedName dsqlName;
@ -656,12 +656,12 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual ExecStatementNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ExecStatementNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
private:
static void genOptionalExpr(DsqlCompilerScratch* dsqlScratch, const UCHAR code, ValueExprNode* node);
void getString(thread_db* tdbb, jrd_req* request, const ValueExprNode* node,
void getString(thread_db* tdbb, Request* request, const ValueExprNode* node,
Firebird::string& str, bool useAttCS = false) const;
public:
@ -701,7 +701,7 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual IfNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual IfNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
NestConst<BoolExprNode> condition;
@ -733,7 +733,7 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual InAutonomousTransactionNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual InAutonomousTransactionNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
NestConst<StmtNode> action;
@ -760,7 +760,7 @@ public:
virtual InitVariableNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual InitVariableNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual InitVariableNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
USHORT varId;
@ -826,7 +826,7 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual ExceptionNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ExceptionNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
private:
void setError(thread_db* tdbb) const;
@ -881,14 +881,14 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual StmtNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual StmtNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
bool isWriteLockMode(jrd_req* request) const;
void setWriteLockMode(jrd_req* request) const;
bool isWriteLockMode(Request* request) const;
void setWriteLockMode(Request* request) const;
// Used by UPDATE and DELETE sub-statements of MERGE
void checkRecordUpdated(thread_db* tdbb, jrd_req* request, record_param* rpb) const;
void setRecordUpdated(thread_db* tdbb, jrd_req* request, record_param* rpb) const;
void checkRecordUpdated(thread_db* tdbb, Request* request, record_param* rpb) const;
void setRecordUpdated(thread_db* tdbb, Request* request, record_param* rpb) const;
public:
struct Impure
@ -935,7 +935,7 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual HandlerNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual HandlerNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
NestConst<StmtNode> statement;
@ -960,7 +960,7 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual LabelNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual LabelNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
NestConst<StmtNode> statement;
@ -1009,7 +1009,7 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual LoopNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual LoopNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
MetaName* dsqlLabelName;
@ -1110,7 +1110,7 @@ public:
virtual MessageNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual MessageNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual MessageNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
Firebird::SortedArray<USHORT> itemsUsedInSubroutines;
@ -1139,11 +1139,11 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual ModifyNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ModifyNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
private:
static void pass1Modify(thread_db* tdbb, CompilerScratch* csb, ModifyNode* node);
const StmtNode* modify(thread_db* tdbb, jrd_req* request, WhichTrigger whichTrig) const;
const StmtNode* modify(thread_db* tdbb, Request* request, WhichTrigger whichTrig) const;
public:
NestConst<RecordSourceNode> dsqlRelation;
@ -1199,7 +1199,7 @@ public:
return this;
}
const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const override;
const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const override;
};
@ -1221,7 +1221,7 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual PostEventNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual PostEventNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
NestConst<ValueExprNode> event;
@ -1248,7 +1248,7 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual ReceiveNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ReceiveNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
NestConst<StmtNode> statement;
@ -1277,12 +1277,12 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual StoreNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual StoreNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
private:
static bool pass1Store(thread_db* tdbb, CompilerScratch* csb, StoreNode* node);
void makeDefaults(thread_db* tdbb, CompilerScratch* csb);
const StmtNode* store(thread_db* tdbb, jrd_req* request, WhichTrigger whichTrig) const;
const StmtNode* store(thread_db* tdbb, Request* request, WhichTrigger whichTrig) const;
public:
NestConst<RecordSourceNode> target;
@ -1321,7 +1321,7 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual SelectNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual SelectNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
NestConst<SelectExprNode> dsqlExpr;
@ -1355,7 +1355,7 @@ public:
virtual SetGeneratorNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual SetGeneratorNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
GeneratorItem generator;
@ -1379,7 +1379,7 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual StallNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual StallNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
};
@ -1401,7 +1401,7 @@ public:
virtual void genBlr(DsqlCompilerScratch* dsqlScratch);
virtual SuspendNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual SuspendNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
NestConst<MessageNode> message;
@ -1448,7 +1448,7 @@ public:
virtual SavepointEncloseNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual SavepointEncloseNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const;
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const;
public:
NestConst<StmtNode> statement;
@ -1893,7 +1893,7 @@ public:
return this;
}
const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const override;
const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const override;
public:
USHORT tableNumber = 0;

48
src/dsql/WinNodes.cpp
View File

@ -76,7 +76,7 @@ ValueExprNode* DenseRankWinNode::copy(thread_db* tdbb, NodeCopier& /*copier*/) c
return FB_NEW_POOL(*tdbb->getDefaultPool()) DenseRankWinNode(*tdbb->getDefaultPool());
}
void DenseRankWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
void DenseRankWinNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -84,11 +84,11 @@ void DenseRankWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
impure->make_int64(0, 0);
}
void DenseRankWinNode::aggPass(thread_db* /*tdbb*/, jrd_req* /*request*/, dsc* /*desc*/) const
void DenseRankWinNode::aggPass(thread_db* /*tdbb*/, Request* /*request*/, dsc* /*desc*/) const
{
}
dsc* DenseRankWinNode::aggExecute(thread_db* /*tdbb*/, jrd_req* request) const
dsc* DenseRankWinNode::aggExecute(thread_db* /*tdbb*/, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
++impure->vlu_misc.vlu_int64;
@ -146,7 +146,7 @@ AggNode* RankWinNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
void RankWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
void RankWinNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -155,13 +155,13 @@ void RankWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
impure->vlux_count = 0;
}
void RankWinNode::aggPass(thread_db* /*tdbb*/, jrd_req* request, dsc* /*desc*/) const
void RankWinNode::aggPass(thread_db* /*tdbb*/, Request* request, dsc* /*desc*/) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
++impure->vlux_count;
}
dsc* RankWinNode::aggExecute(thread_db* tdbb, jrd_req* request) const
dsc* RankWinNode::aggExecute(thread_db* tdbb, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
@ -222,7 +222,7 @@ AggNode* PercentRankWinNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
void PercentRankWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
void PercentRankWinNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -235,13 +235,13 @@ void PercentRankWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
impureTemp->vlux_count = 0;
}
void PercentRankWinNode::aggPass(thread_db* /*tdbb*/, jrd_req* request, dsc* /*desc*/) const
void PercentRankWinNode::aggPass(thread_db* /*tdbb*/, Request* request, dsc* /*desc*/) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
++impure->vlux_count;
}
dsc* PercentRankWinNode::aggExecute(thread_db* /*tdbb*/, jrd_req* request) const
dsc* PercentRankWinNode::aggExecute(thread_db* /*tdbb*/, Request* request) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
impure_value_ex* impureTemp = request->getImpure<impure_value_ex>(tempImpure);
@ -254,7 +254,7 @@ dsc* PercentRankWinNode::aggExecute(thread_db* /*tdbb*/, jrd_req* request) const
return NULL;
}
dsc* PercentRankWinNode::winPass(thread_db* /*tdbb*/, jrd_req* request, SlidingWindow* window) const
dsc* PercentRankWinNode::winPass(thread_db* /*tdbb*/, Request* request, SlidingWindow* window) const
{
impure_value_ex* impureTemp = request->getImpure<impure_value_ex>(tempImpure);
@ -307,7 +307,7 @@ AggNode* CumeDistWinNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
void CumeDistWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
void CumeDistWinNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -315,7 +315,7 @@ void CumeDistWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
impure->make_double(0);
}
dsc* CumeDistWinNode::winPass(thread_db* /*tdbb*/, jrd_req* request, SlidingWindow* window) const
dsc* CumeDistWinNode::winPass(thread_db* /*tdbb*/, Request* request, SlidingWindow* window) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
@ -366,7 +366,7 @@ ValueExprNode* RowNumberWinNode::copy(thread_db* tdbb, NodeCopier& /*copier*/) c
return FB_NEW_POOL(*tdbb->getDefaultPool()) RowNumberWinNode(*tdbb->getDefaultPool());
}
void RowNumberWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
void RowNumberWinNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -374,7 +374,7 @@ void RowNumberWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
impure->make_int64(0, 0);
}
dsc* RowNumberWinNode::winPass(thread_db* /*tdbb*/, jrd_req* request, SlidingWindow* window) const
dsc* RowNumberWinNode::winPass(thread_db* /*tdbb*/, Request* request, SlidingWindow* window) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
impure->vlu_misc.vlu_int64 = window->getRecordPosition() - window->getPartitionStart() + 1;
@ -425,12 +425,12 @@ ValueExprNode* FirstValueWinNode::copy(thread_db* tdbb, NodeCopier& copier) cons
return node;
}
void FirstValueWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
void FirstValueWinNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
}
dsc* FirstValueWinNode::winPass(thread_db* tdbb, jrd_req* request, SlidingWindow* window) const
dsc* FirstValueWinNode::winPass(thread_db* tdbb, Request* request, SlidingWindow* window) const
{
if (!window->moveWithinFrame(-(window->getRecordPosition() - window->getFrameStart())))
return NULL;
@ -486,12 +486,12 @@ ValueExprNode* LastValueWinNode::copy(thread_db* tdbb, NodeCopier& copier) const
return node;
}
void LastValueWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
void LastValueWinNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
}
dsc* LastValueWinNode::winPass(thread_db* tdbb, jrd_req* request, SlidingWindow* window) const
dsc* LastValueWinNode::winPass(thread_db* tdbb, Request* request, SlidingWindow* window) const
{
if (!window->moveWithinFrame(window->getFrameEnd() - window->getRecordPosition()))
return NULL;
@ -558,7 +558,7 @@ ValueExprNode* NthValueWinNode::copy(thread_db* tdbb, NodeCopier& copier) const
return node;
}
void NthValueWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
void NthValueWinNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -566,7 +566,7 @@ void NthValueWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
impure->make_int64(0, 0);
}
dsc* NthValueWinNode::winPass(thread_db* tdbb, jrd_req* request, SlidingWindow* window) const
dsc* NthValueWinNode::winPass(thread_db* tdbb, Request* request, SlidingWindow* window) const
{
dsc* desc = EVL_expr(tdbb, request, row);
if (!desc || (request->req_flags & req_null))
@ -652,12 +652,12 @@ void LagLeadWinNode::getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc)
arg->getDesc(tdbb, csb, desc);
}
void LagLeadWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
void LagLeadWinNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
}
dsc* LagLeadWinNode::winPass(thread_db* tdbb, jrd_req* request, SlidingWindow* window) const
dsc* LagLeadWinNode::winPass(thread_db* tdbb, Request* request, SlidingWindow* window) const
{
dsc* desc = EVL_expr(tdbb, request, rows);
if (!desc || (request->req_flags & req_null))
@ -818,7 +818,7 @@ AggNode* NTileWinNode::pass2(thread_db* tdbb, CompilerScratch* csb)
return this;
}
void NTileWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
void NTileWinNode::aggInit(thread_db* tdbb, Request* request) const
{
AggNode::aggInit(tdbb, request);
@ -847,7 +847,7 @@ void NTileWinNode::aggInit(thread_db* tdbb, jrd_req* request) const
}
}
dsc* NTileWinNode::winPass(thread_db* /*tdbb*/, jrd_req* request, SlidingWindow* window) const
dsc* NTileWinNode::winPass(thread_db* /*tdbb*/, Request* request, SlidingWindow* window) const
{
impure_value_ex* impure = request->getImpure<impure_value_ex>(impureOffset);
ThisImpure* thisImpure = request->getImpure<ThisImpure>(thisImpureOffset);

48
src/dsql/WinNodes.h
View File

@ -51,9 +51,9 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual void aggPass(thread_db* tdbb, Request* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, Request* request) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -81,9 +81,9 @@ public:
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual AggNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual void aggPass(thread_db* tdbb, Request* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, Request* request) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -114,11 +114,11 @@ public:
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual AggNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggPass(thread_db* tdbb, jrd_req* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual void aggPass(thread_db* tdbb, Request* request, dsc* desc) const;
virtual dsc* aggExecute(thread_db* tdbb, Request* request) const;
virtual dsc* winPass(thread_db* tdbb, jrd_req* request, SlidingWindow* window) const;
virtual dsc* winPass(thread_db* tdbb, Request* request, SlidingWindow* window) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -149,9 +149,9 @@ public:
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual AggNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual dsc* winPass(thread_db* tdbb, jrd_req* request, SlidingWindow* window) const;
virtual dsc* winPass(thread_db* tdbb, Request* request, SlidingWindow* window) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -178,9 +178,9 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual dsc* winPass(thread_db* tdbb, jrd_req* request, SlidingWindow* window) const;
virtual dsc* winPass(thread_db* tdbb, Request* request, SlidingWindow* window) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -202,9 +202,9 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual dsc* winPass(thread_db* tdbb, jrd_req* request, SlidingWindow* window) const;
virtual dsc* winPass(thread_db* tdbb, Request* request, SlidingWindow* window) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -228,9 +228,9 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual dsc* winPass(thread_db* tdbb, jrd_req* request, SlidingWindow* window) const;
virtual dsc* winPass(thread_db* tdbb, Request* request, SlidingWindow* window) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -269,9 +269,9 @@ public:
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual dsc* winPass(thread_db* tdbb, jrd_req* request, SlidingWindow* window) const;
virtual dsc* winPass(thread_db* tdbb, Request* request, SlidingWindow* window) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;
@ -306,8 +306,8 @@ public:
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual dsc* winPass(thread_db* tdbb, jrd_req* request, SlidingWindow* window) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual dsc* winPass(thread_db* tdbb, Request* request, SlidingWindow* window) const;
protected:
virtual void parseArgs(thread_db* tdbb, CompilerScratch* csb, unsigned count);
@ -373,9 +373,9 @@ public:
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual AggNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual void aggInit(thread_db* tdbb, jrd_req* request) const;
virtual void aggInit(thread_db* tdbb, Request* request) const;
virtual dsc* winPass(thread_db* tdbb, jrd_req* request, SlidingWindow* window) const;
virtual dsc* winPass(thread_db* tdbb, Request* request, SlidingWindow* window) const;
protected:
virtual AggNode* dsqlCopy(DsqlCompilerScratch* dsqlScratch) /*const*/;

2
src/dsql/dsql.h
View File

@ -87,7 +87,7 @@ namespace Jrd
class ValueListNode;
class WindowClause;
class jrd_tra;
class jrd_req;
class Request;
class blb;
struct bid;

6
src/jrd/Attachment.cpp
View File

@ -646,7 +646,7 @@ bool Attachment::hasActiveRequests() const
for (const jrd_tra* transaction = att_transactions;
transaction; transaction = transaction->tra_next)
{
for (const jrd_req* request = transaction->tra_requests;
for (const Request* request = transaction->tra_requests;
request; request = request->req_tra_next)
{
if (request->req_transaction && (request->req_flags & req_active))
@ -659,7 +659,7 @@ bool Attachment::hasActiveRequests() const
// Find an inactive incarnation of a system request. If necessary, clone it.
jrd_req* Jrd::Attachment::findSystemRequest(thread_db* tdbb, USHORT id, USHORT which)
Request* Jrd::Attachment::findSystemRequest(thread_db* tdbb, USHORT id, USHORT which)
{
static const int MAX_RECURSION = 100;
@ -685,7 +685,7 @@ jrd_req* Jrd::Attachment::findSystemRequest(thread_db* tdbb, USHORT id, USHORT w
// Msg363 "request depth exceeded. (Recursive definition?)"
}
jrd_req* clone = statement->getRequest(tdbb, n);
Request* clone = statement->getRequest(tdbb, n);
if (!(clone->req_flags & (req_active | req_reserved)))
{

6
src/jrd/Attachment.h
View File

@ -68,7 +68,7 @@ namespace Jrd
class thread_db;
class Database;
class jrd_tra;
class jrd_req;
class Request;
class Lock;
class jrd_file;
class Format;
@ -546,7 +546,7 @@ private:
public:
Firebird::SortedArray<Statement*> att_statements; // Statements belonging to attachment
Firebird::SortedArray<jrd_req*> att_requests; // Requests belonging to attachment
Firebird::SortedArray<Request*> att_requests; // Requests belonging to attachment
Lock* att_id_lock; // Attachment lock (if any)
AttNumber att_attachment_id; // Attachment ID
Lock* att_cancel_lock; // Lock to cancel the active request
@ -625,7 +625,7 @@ public:
Firebird::ICryptKeyCallback* att_crypt_callback; // callback for DB crypt
Firebird::DecimalStatus att_dec_status; // error handling and rounding
jrd_req* findSystemRequest(thread_db* tdbb, USHORT id, USHORT which);
Request* findSystemRequest(thread_db* tdbb, USHORT id, USHORT which);
Firebird::Array<CharSetContainer*> att_charsets; // intl character set descriptions
Firebird::GenericMap<Firebird::Pair<Firebird::Left<

4
src/jrd/ConfigTable.cpp
View File

@ -88,7 +88,7 @@ RecordBuffer* ConfigTable::getRecords(thread_db* tdbb, jrd_rel* relation)
void ConfigTableScan::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
delete impure->table;
@ -112,7 +112,7 @@ bool ConfigTableScan::retrieveRecord(thread_db* tdbb, jrd_rel* relation,
RecordBuffer* ConfigTableScan::getRecords(thread_db* tdbb, jrd_rel* relation) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!impure->table)

38
src/jrd/ExtEngineManager.cpp
View File

@ -134,9 +134,9 @@ namespace
return type_alignments[desc->dsc_dtype];
}
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const
{
if (request->req_operation == jrd_req::req_evaluate)
if (request->req_operation == Request::req_evaluate)
{
// Clear the message. This is important for external routines.
UCHAR* msg = request->getImpure<UCHAR>(impureOffset);
@ -204,9 +204,9 @@ namespace
return this;
}
const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* /*exeState*/) const
const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* /*exeState*/) const
{
if (request->req_operation == jrd_req::req_evaluate)
if (request->req_operation == Request::req_evaluate)
{
dsc* defaultDesc = NULL;
@ -242,7 +242,7 @@ namespace
MOV_move(tdbb, &temp, &desc);
}
request->req_operation = jrd_req::req_return;
request->req_operation = Request::req_return;
}
return parentStmt;
@ -322,9 +322,9 @@ namespace
{
}
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const
{
if (request->req_operation == jrd_req::req_evaluate)
if (request->req_operation == Request::req_evaluate)
{
UCHAR* inMsg = extInMessageNode ? request->getImpure<UCHAR>(extInMessageNode->impureOffset) : NULL;
UCHAR* outMsg = request->getImpure<UCHAR>(extOutMessageNode->impureOffset);
@ -361,7 +361,7 @@ namespace
statements.add(FB_NEW_POOL(pool) StallNode(pool));
}
virtual const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* exeState) const
virtual const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* exeState) const
{
impure_state* const impure = request->getImpure<impure_state>(impureOffset);
ExtEngineManager::ResultSet*& resultSet = request->req_ext_resultset;
@ -373,7 +373,7 @@ namespace
switch (request->req_operation)
{
case jrd_req::req_evaluate:
case Request::req_evaluate:
fb_assert(!resultSet);
resultSet = procedure->open(tdbb, extInMsg, extOutMsg);
@ -386,8 +386,8 @@ namespace
*eof = -1;
// fall into
case jrd_req::req_proceed:
case jrd_req::req_sync:
case Request::req_proceed:
case Request::req_sync:
if (resultSet)
{
if (resultSet->fetch(tdbb) && (request->req_flags & req_proc_fetch))
@ -401,10 +401,10 @@ namespace
}
impure->sta_state = 0; // suspend node
request->req_operation = jrd_req::req_sync;
request->req_operation = Request::req_sync;
break;
case jrd_req::req_unwind:
case Request::req_unwind:
delete resultSet;
resultSet = NULL;
break;
@ -450,21 +450,21 @@ namespace
return this;
}
const StmtNode* execute(thread_db* tdbb, jrd_req* request, ExeState* /*exeState*/) const
const StmtNode* execute(thread_db* tdbb, Request* request, ExeState* /*exeState*/) const
{
if (request->req_operation == jrd_req::req_evaluate)
if (request->req_operation == Request::req_evaluate)
{
trigger->execute(tdbb, request, request->req_trigger_action,
getRpb(request, 0), getRpb(request, 1));
request->req_operation = jrd_req::req_return;
request->req_operation = Request::req_return;
}
return parentStmt;
}
private:
static record_param* getRpb(jrd_req* request, USHORT n)
static record_param* getRpb(Request* request, USHORT n)
{
return request->req_rpb.getCount() > n && request->req_rpb[n].rpb_number.isValid() ?
&request->req_rpb[n] : NULL;
@ -893,7 +893,7 @@ ExtEngineManager::Trigger::~Trigger()
}
void ExtEngineManager::Trigger::execute(thread_db* tdbb, jrd_req* request, unsigned action,
void ExtEngineManager::Trigger::execute(thread_db* tdbb, Request* request, unsigned action,
record_param* oldRpb, record_param* newRpb) const
{
EngineAttachmentInfo* attInfo = extManager->getEngineAttachment(tdbb, engine);
@ -1039,7 +1039,7 @@ void ExtEngineManager::Trigger::setupComputedFields(thread_db* tdbb, MemoryPool&
}
void ExtEngineManager::Trigger::setValues(thread_db* tdbb, jrd_req* request, Array<UCHAR>& msgBuffer,
void ExtEngineManager::Trigger::setValues(thread_db* tdbb, Request* request, Array<UCHAR>& msgBuffer,
record_param* rpb) const
{
if (!rpb || !rpb->rpb_record)

6
src/jrd/ExtEngineManager.h
View File

@ -40,7 +40,7 @@ namespace Jrd {
class thread_db;
class jrd_prc;
class jrd_req;
class Request;
class jrd_tra;
class Attachment;
class CompilerScratch;
@ -280,12 +280,12 @@ public:
Firebird::IExternalTrigger* aTrigger, const Jrd::Trigger* aTrg);
~Trigger();
void execute(thread_db* tdbb, jrd_req* request, unsigned action,
void execute(thread_db* tdbb, Request* request, unsigned action,
record_param* oldRpb, record_param* newRpb) const;
private:
void setupComputedFields(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb);
void setValues(thread_db* tdbb, jrd_req* request, Firebird::Array<UCHAR>& msgBuffer, record_param* rpb) const;
void setValues(thread_db* tdbb, Request* request, Firebird::Array<UCHAR>& msgBuffer, record_param* rpb) const;
public:
Firebird::Array<NestConst<StmtNode>> computedStatements;

10
src/jrd/Monitoring.cpp
View File

@ -1078,7 +1078,7 @@ void Monitoring::putTransaction(SnapshotData::DumpRecord& record, const jrd_tra*
record.reset(rel_mon_transactions);
int temp = mon_state_idle;
for (const jrd_req* request = transaction->tra_requests;
for (const Request* request = transaction->tra_requests;
request; request = request->req_tra_next)
{
if (request->req_transaction && (request->req_flags & req_active))
@ -1176,7 +1176,7 @@ void Monitoring::putStatement(SnapshotData::DumpRecord& record, const Statement*
}
void Monitoring::putRequest(SnapshotData::DumpRecord& record, const jrd_req* request,
void Monitoring::putRequest(SnapshotData::DumpRecord& record, const Request* request,
const string& plan)
{
fb_assert(request);
@ -1236,12 +1236,12 @@ void Monitoring::putRequest(SnapshotData::DumpRecord& record, const jrd_req* req
}
void Monitoring::putCall(SnapshotData::DumpRecord& record, const jrd_req* request)
void Monitoring::putCall(SnapshotData::DumpRecord& record, const Request* request)
{
fb_assert(request);
const auto dbb = request->req_attachment->att_database;
const jrd_req* initialRequest = request->req_caller;
const Request* initialRequest = request->req_caller;
while (initialRequest->req_caller)
{
@ -1470,7 +1470,7 @@ void Monitoring::dumpAttachment(thread_db* tdbb, Attachment* attachment)
for (transaction = attachment->att_transactions; transaction;
transaction = transaction->tra_next)
{
for (jrd_req* request = transaction->tra_requests;
for (Request* request = transaction->tra_requests;
request && (request->req_flags & req_active) && (request->req_transaction == transaction);
request = request->req_caller)
{

4
src/jrd/Monitoring.h
View File

@ -390,8 +390,8 @@ private:
static void putAttachment(SnapshotData::DumpRecord&, const Attachment*);
static void putTransaction(SnapshotData::DumpRecord&, const jrd_tra*);
static void putStatement(SnapshotData::DumpRecord&, const Statement*, const Firebird::string&);
static void putRequest(SnapshotData::DumpRecord&, const jrd_req*, const Firebird::string&);
static void putCall(SnapshotData::DumpRecord&, const jrd_req*);
static void putRequest(SnapshotData::DumpRecord&, const Request*, const Firebird::string&);
static void putCall(SnapshotData::DumpRecord&, const Request*);
static void putStatistics(SnapshotData::DumpRecord&, const RuntimeStatistics&, int, int);
static void putContextVars(SnapshotData::DumpRecord&, const Firebird::StringMap&, SINT64, bool);
static void putMemoryUsage(SnapshotData::DumpRecord&, const Firebird::MemoryStats&, int, int);

4
src/jrd/PreparedStatement.cpp
View File

@ -346,10 +346,10 @@ void PreparedStatement::setDesc(thread_db* tdbb, unsigned param, const dsc& valu
{
fb_assert(param > 0);
jrd_req* request = getDsqlRequest()->getRequest();
Request* request = getDsqlRequest()->getRequest();
// Setup tdbb info necessary for blobs.
AutoSetRestore2<jrd_req*, thread_db> autoRequest(
AutoSetRestore2<Request*, thread_db> autoRequest(
tdbb, &thread_db::getRequest, &thread_db::setRequest, request);
AutoSetRestore<jrd_tra*> autoRequestTrans(&request->req_transaction,
tdbb->getTransaction());

8
src/jrd/ResultSet.cpp
View File

@ -103,10 +103,10 @@ Firebird::string ResultSet::getString(thread_db* tdbb, unsigned param)
{
fb_assert(param > 0);
jrd_req* request = stmt->getDsqlRequest()->getRequest();
Request* request = stmt->getDsqlRequest()->getRequest();
// Setup tdbb info necessary for blobs.
AutoSetRestore2<jrd_req*, thread_db> autoRequest(
AutoSetRestore2<Request*, thread_db> autoRequest(
tdbb, &thread_db::getRequest, &thread_db::setRequest, request);
AutoSetRestore<jrd_tra*> autoRequestTrans(&request->req_transaction,
tdbb->getTransaction());
@ -131,10 +131,10 @@ void ResultSet::moveDesc(thread_db* tdbb, unsigned param, dsc& desc)
{
fb_assert(param > 0);
jrd_req* request = stmt->getDsqlRequest()->getRequest();
Request* request = stmt->getDsqlRequest()->getRequest();
// Setup tdbb info necessary for blobs.
AutoSetRestore2<jrd_req*, thread_db> autoRequest(
AutoSetRestore2<Request*, thread_db> autoRequest(
tdbb, &thread_db::getRequest, &thread_db::setRequest, request);
AutoSetRestore<jrd_tra*> autoRequestTrans(&request->req_transaction,
tdbb->getTransaction());

2
src/jrd/RuntimeStatistics.h
View File

@ -360,7 +360,7 @@ private:
// These two numbers are used in adjust() and assign() methods as "generation"
// values in order to avoid costly operations when two instances of RuntimeStatistics
// contain equal counters values. This is intended to use *only* with the
// same pair of class instances, as in jrd_req.
// same pair of class instances, as in Request.
ULONG allChgNumber; // incremented when any counter changes
ULONG relChgNumber; // incremented when relation counter changes

18
src/jrd/Statement.cpp
View File

@ -209,7 +209,7 @@ Statement* Statement::makeStatement(thread_db* tdbb, CompilerScratch* csb, bool
Database* const dbb = tdbb->getDatabase();
fb_assert(dbb);
jrd_req* const old_request = tdbb->getRequest();
Request* const old_request = tdbb->getRequest();
tdbb->setRequest(NULL);
Statement* statement = NULL;
@ -310,7 +310,7 @@ Statement* Statement::makeStatement(thread_db* tdbb, CompilerScratch* csb, bool
}
// Turn a parsed scratch into an executable request.
jrd_req* Statement::makeRequest(thread_db* tdbb, CompilerScratch* csb, bool internalFlag)
Request* Statement::makeRequest(thread_db* tdbb, CompilerScratch* csb, bool internalFlag)
{
Statement* statement = makeStatement(tdbb, csb, internalFlag);
return statement->getRequest(tdbb, 0);
@ -330,7 +330,7 @@ const Routine* Statement::getRoutine() const
// Determine if any request of this statement are active.
bool Statement::isActive() const
{
for (const jrd_req* const* request = requests.begin(); request != requests.end(); ++request)
for (const Request* const* request = requests.begin(); request != requests.end(); ++request)
{
if (*request && ((*request)->req_flags & req_in_use))
return true;
@ -339,7 +339,7 @@ bool Statement::isActive() const
return false;
}
jrd_req* Statement::findRequest(thread_db* tdbb, bool unique)
Request* Statement::findRequest(thread_db* tdbb, bool unique)
{
SET_TDBB(tdbb);
Attachment* const attachment = tdbb->getAttachment();
@ -351,14 +351,14 @@ jrd_req* Statement::findRequest(thread_db* tdbb, bool unique)
// Search clones for one request in use by this attachment.
// If not found, return first inactive request.
jrd_req* clone = NULL;
Request* clone = NULL;
USHORT count = 0;
const USHORT clones = requests.getCount();
USHORT n;
for (n = 0; n < clones; ++n)
{
jrd_req* next = getRequest(tdbb, n);
Request* next = getRequest(tdbb, n);
if (next->req_attachment == attachment)
{
@ -391,7 +391,7 @@ jrd_req* Statement::findRequest(thread_db* tdbb, bool unique)
return clone;
}
jrd_req* Statement::getRequest(thread_db* tdbb, USHORT level)
Request* Statement::getRequest(thread_db* tdbb, USHORT level)
{
SET_TDBB(tdbb);
@ -408,7 +408,7 @@ jrd_req* Statement::getRequest(thread_db* tdbb, USHORT level)
&dbb->dbb_memory_stats : &attachment->att_memory_stats;
// Create the request.
jrd_req* const request = FB_NEW_POOL(*pool) jrd_req(attachment, this, parentStats);
Request* const request = FB_NEW_POOL(*pool) Request(attachment, this, parentStats);
if (level == 0)
pool->setStatsGroup(request->req_memory_stats);
@ -646,7 +646,7 @@ void Statement::release(thread_db* tdbb)
}
}
for (jrd_req** instance = requests.begin(); instance != requests.end(); ++instance)
for (Request** instance = requests.begin(); instance != requests.end(); ++instance)
EXE_release(tdbb, *instance);
const auto attachment = tdbb->getAttachment();

8
src/jrd/Statement.h
View File

@ -46,7 +46,7 @@ private:
public:
static Statement* makeStatement(thread_db* tdbb, CompilerScratch* csb, bool internalFlag);
static jrd_req* makeRequest(thread_db* tdbb, CompilerScratch* csb, bool internalFlag);
static Request* makeRequest(thread_db* tdbb, CompilerScratch* csb, bool internalFlag);
StmtNumber getStatementId() const
{
@ -58,8 +58,8 @@ public:
const Routine* getRoutine() const;
bool isActive() const;
jrd_req* findRequest(thread_db* tdbb, bool unique = false);
jrd_req* getRequest(thread_db* tdbb, USHORT level);
Request* findRequest(thread_db* tdbb, bool unique = false);
Request* getRequest(thread_db* tdbb, USHORT level);
void verifyAccess(thread_db* tdbb);
void release(thread_db* tdbb);
@ -79,7 +79,7 @@ public:
ULONG impureSize; // Size of impure area
mutable StmtNumber id; // statement identifier
Firebird::Array<record_param> rpbsSetup;
Firebird::Array<jrd_req*> requests; // vector of requests
Firebird::Array<Request*> requests; // vector of requests
ExternalAccessList externalList; // Access to procedures/triggers to be checked
AccessItemList accessList; // Access items to be checked
ResourceList resources; // Resources (relations and indices)

100
src/jrd/SysFunction.cpp
View File

@ -1862,7 +1862,7 @@ dsc* evlStdMath(thread_db* tdbb, const SysFunction* function, const NestValueArr
fb_assert(args.getCount() == 1);
fb_assert(function->misc != NULL);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -1962,7 +1962,7 @@ dsc* evlAbs(thread_db* tdbb, const SysFunction*, const NestValueArray& args, imp
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -2020,7 +2020,7 @@ dsc* evlAsciiChar(thread_db* tdbb, const SysFunction*, const NestValueArray& arg
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -2042,7 +2042,7 @@ dsc* evlAsciiVal(thread_db* tdbb, const SysFunction*, const NestValueArray& args
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -2077,7 +2077,7 @@ dsc* evlAtan2(thread_db* tdbb, const SysFunction* function, const NestValueArray
{
fb_assert(args.getCount() == 2);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* desc1 = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if desc1 is NULL
@ -2146,7 +2146,7 @@ dsc* evlBin(thread_db* tdbb, const SysFunction* function, const NestValueArray&
fb_assert(function->misc != NULL);
Function func = (Function)(IPTR) function->misc;
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
bool f128 = false;
for (unsigned i = 0; i < args.getCount(); ++i)
@ -2212,7 +2212,7 @@ dsc* evlBinShift(thread_db* tdbb, const SysFunction* function, const NestValueAr
fb_assert(args.getCount() == 2);
fb_assert(function->misc != NULL);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value1 = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value1 is NULL
@ -2263,7 +2263,7 @@ dsc* evlCeil(thread_db* tdbb, const SysFunction*, const NestValueArray& args,
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -2348,7 +2348,7 @@ dsc* evlCharToUuid(thread_db* tdbb, const SysFunction* function, const NestValue
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -2466,7 +2466,7 @@ dsc* evlDateAdd(thread_db* tdbb, const SysFunction* function, const NestValueArr
{
fb_assert(args.getCount() == 3);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* quantityDsc = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if quantityDsc is NULL
@ -2994,7 +2994,7 @@ dsc* evlEncryptDecrypt(thread_db* tdbb, const SysFunction* function, const NestV
fb_assert(args.getCount() == CRYPT_ARG_MAX);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
// parse args and check correctness
const dsc* dscs[CRYPT_ARG_MAX];
@ -3512,7 +3512,7 @@ dsc* evlRsaEncryptDecrypt(thread_db* tdbb, const SysFunction* function, const Ne
fb_assert(args.getCount() == RSA_CRYPT_ARG_MAX || args.getCount() == RSA_CRYPT_ARG_MAX - 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
// parse args and check correctness
const dsc* dscs[RSA_CRYPT_ARG_MAX];
@ -3582,7 +3582,7 @@ dsc* evlRsaPrivate(thread_db* tdbb, const SysFunction* function, const NestValue
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -3613,7 +3613,7 @@ dsc* evlRsaPublic(thread_db* tdbb, const SysFunction* function, const NestValueA
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -3652,7 +3652,7 @@ dsc* evlRsaSign(thread_db* tdbb, const SysFunction* function, const NestValueArr
fb_assert(args.getCount() == RSA_SIGN_ARG_MAX || args.getCount() == RSA_SIGN_ARG_MAX - 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
// parse args and check correctness
const dsc* dscs[RSA_SIGN_ARG_MAX];
@ -3721,7 +3721,7 @@ dsc* evlRsaVerify(thread_db* tdbb, const SysFunction* function, const NestValueA
fb_assert(args.getCount() == RSA_VERIFY_ARG_MAX || args.getCount() == RSA_VERIFY_ARG_MAX - 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
// parse args and check correctness
const dsc* dscs[RSA_VERIFY_ARG_MAX];
@ -3780,7 +3780,7 @@ dsc* evlDateDiff(thread_db* tdbb, const SysFunction* function, const NestValueAr
{
fb_assert(args.getCount() == 3);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* partDsc = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if partDsc is NULL
@ -4010,7 +4010,7 @@ dsc* evlExp(thread_db* tdbb, const SysFunction*, const NestValueArray& args,
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -4047,7 +4047,7 @@ dsc* evlFirstLastDay(thread_db* tdbb, const SysFunction* function, const NestVal
{
fb_assert(args.getCount() >= 2);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* partDsc = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if partDsc is NULL
@ -4174,7 +4174,7 @@ dsc* evlFloor(thread_db* tdbb, const SysFunction*, const NestValueArray& args,
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -4292,7 +4292,7 @@ dsc* evlGetContext(thread_db* tdbb, const SysFunction*, const NestValueArray& ar
Jrd::Attachment* attachment = tdbb->getAttachment();
Database* dbb = tdbb->getDatabase();
jrd_tra* transaction = tdbb->getTransaction();
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
request->req_flags &= ~req_null;
const dsc* nameSpace = EVL_expr(tdbb, request, args[0]);
@ -4442,7 +4442,7 @@ dsc* evlGetContext(thread_db* tdbb, const SysFunction*, const NestValueArray& ar
else if ((transaction->tra_flags & TRA_read_committed) &&
(transaction->tra_flags & TRA_read_consistency))
{
jrd_req* snapshot_req = request->req_snapshot.m_owner;
Request* snapshot_req = request->req_snapshot.m_owner;
if (snapshot_req)
resultStr.printf("%" SQUADFORMAT, snapshot_req->req_snapshot.m_number);
else
@ -4579,7 +4579,7 @@ dsc* evlSetContext(thread_db* tdbb, const SysFunction*, const NestValueArray& ar
Jrd::Attachment* attachment = tdbb->getAttachment();
jrd_tra* transaction = tdbb->getTransaction();
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
request->req_flags &= ~req_null;
const dsc* nameSpace = EVL_expr(tdbb, request, args[0]);
@ -4679,7 +4679,7 @@ dsc* evlGetTranCN(thread_db* tdbb, const SysFunction* function, const NestValueA
fb_assert(args.getCount() == 1);
Database* dbb = tdbb->getDatabase();
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
request->req_flags &= ~req_null;
const dsc* value = EVL_expr(tdbb, request, args[0]);
@ -4720,7 +4720,7 @@ dsc* evlHash(thread_db* tdbb, const SysFunction* function, const NestValueArray&
{
fb_assert(args.getCount() >= 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -4779,7 +4779,7 @@ dsc* evlLeft(thread_db* tdbb, const SysFunction*, const NestValueArray& args,
{
fb_assert(args.getCount() == 2);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* str = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if str is NULL
@ -4803,7 +4803,7 @@ dsc* evlLnLog10(thread_db* tdbb, const SysFunction* function, const NestValueArr
fb_assert(args.getCount() == 1);
fb_assert(function->misc != NULL);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -4876,7 +4876,7 @@ dsc* evlLog(thread_db* tdbb, const SysFunction* function, const NestValueArray&
{
fb_assert(args.getCount() == 2);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value[2];
value[0] = EVL_expr(tdbb, request, args[0]);
@ -4942,7 +4942,7 @@ dsc* evlQuantize(thread_db* tdbb, const SysFunction* function, const NestValueAr
{
fb_assert(args.getCount() == 2);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value[2];
value[0] = EVL_expr(tdbb, request, args[0]);
@ -4981,7 +4981,7 @@ dsc* evlCompare(thread_db* tdbb, const SysFunction* function, const NestValueArr
{
fb_assert(args.getCount() == 2);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value[2];
value[0] = EVL_expr(tdbb, request, args[0]);
@ -5037,7 +5037,7 @@ dsc* evlNormDec(thread_db* tdbb, const SysFunction* function, const NestValueArr
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value;
value = EVL_expr(tdbb, request, args[0]);
@ -5070,7 +5070,7 @@ dsc* evlMakeDbkey(Jrd::thread_db* tdbb, const SysFunction* function, const NestV
// MAKE_DBKEY ( REL_NAME | REL_ID, RECNUM [, DPNUM [, PPNUM] ] )
Database* const dbb = tdbb->getDatabase();
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
fb_assert(args.getCount() >= 2 && args.getCount() <= 4);
@ -5171,7 +5171,7 @@ dsc* evlMaxMinValue(thread_db* tdbb, const SysFunction* function, const NestValu
fb_assert(args.getCount() >= 1);
fb_assert(function->misc != NULL);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
dsc* result = NULL;
for (FB_SIZE_T i = 0; i < args.getCount(); ++i)
@ -5211,7 +5211,7 @@ dsc* evlMod(thread_db* tdbb, const SysFunction*, const NestValueArray& args,
{
fb_assert(args.getCount() == 2);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value1 = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value1 is NULL
@ -5274,7 +5274,7 @@ dsc* evlOverlay(thread_db* tdbb, const SysFunction* function, const NestValueArr
{
fb_assert(args.getCount() >= 3);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -5458,7 +5458,7 @@ dsc* evlPad(thread_db* tdbb, const SysFunction* function, const NestValueArray&
{
fb_assert(args.getCount() >= 2);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value1 = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value1 is NULL
@ -5633,7 +5633,7 @@ dsc* evlPosition(thread_db* tdbb, const SysFunction* function, const NestValueAr
{
fb_assert(args.getCount() >= 2);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value1 = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value1 is NULL
@ -5759,7 +5759,7 @@ dsc* evlPower(thread_db* tdbb, const SysFunction* function, const NestValueArray
{
fb_assert(args.getCount() == 2);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value[2];
value[0] = EVL_expr(tdbb, request, args[0]);
@ -5835,7 +5835,7 @@ dsc* evlReplace(thread_db* tdbb, const SysFunction*, const NestValueArray& args,
{
fb_assert(args.getCount() == 3);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
dsc* values[3]; // 0 = searched, 1 = find, 2 = replacement
const dsc* firstBlob = NULL;
@ -5993,7 +5993,7 @@ dsc* evlReverse(thread_db* tdbb, const SysFunction*, const NestValueArray& args,
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -6096,7 +6096,7 @@ dsc* evlRight(thread_db* tdbb, const SysFunction*, const NestValueArray& args,
{
fb_assert(args.getCount() == 2);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -6149,7 +6149,7 @@ dsc* evlRound(thread_db* tdbb, const SysFunction* function, const NestValueArray
{
fb_assert(args.getCount() >= 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -6197,7 +6197,7 @@ dsc* evlSign(thread_db* tdbb, const SysFunction*, const NestValueArray& args,
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -6228,7 +6228,7 @@ dsc* evlSqrt(thread_db* tdbb, const SysFunction* function, const NestValueArray&
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -6271,7 +6271,7 @@ dsc* evlTrunc(thread_db* tdbb, const SysFunction* function, const NestValueArray
{
fb_assert(args.getCount() >= 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -6404,7 +6404,7 @@ dsc* evlUuidToChar(thread_db* tdbb, const SysFunction* function, const NestValue
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -6448,7 +6448,7 @@ dsc* evlRoleInUse(thread_db* tdbb, const SysFunction*, const NestValueArray& arg
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
Jrd::Attachment* attachment = tdbb->getAttachment();
const dsc* value = EVL_expr(tdbb, request, args[0]);
@ -6475,7 +6475,7 @@ dsc* evlSystemPrivilege(thread_db* tdbb, const SysFunction*, const NestValueArra
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
return NULL;
@ -6497,7 +6497,7 @@ dsc* evlUnicodeChar(thread_db* tdbb, const SysFunction* function, const NestValu
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL
@ -6532,7 +6532,7 @@ dsc* evlUnicodeVal(thread_db* tdbb, const SysFunction*, const NestValueArray& ar
{
fb_assert(args.getCount() == 1);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const dsc* value = EVL_expr(tdbb, request, args[0]);
if (request->req_flags & req_null) // return NULL if value is NULL

22
src/jrd/blb.cpp
View File

@ -345,13 +345,13 @@ blb* blb::create2(thread_db* tdbb,
// Bind non-user blob to the request
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
if (!userBlob && request)
{
transaction->tra_blobs->locate(blob->blb_temp_id);
BlobIndex* current = &transaction->tra_blobs->current();
jrd_req* blob_request = request;
Request* blob_request = request;
while (blob_request->req_caller)
blob_request = blob_request->req_caller;
@ -1052,7 +1052,7 @@ void blb::move(thread_db* tdbb, dsc* from_desc, dsc* to_desc,
return;
}
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
if (relation->isVirtual()) {
ERR_post(Arg::Gds(isc_read_only));
@ -1138,7 +1138,7 @@ void blb::move(thread_db* tdbb, dsc* from_desc, dsc* to_desc,
{
// Walk through call stack looking if our BLOB is
// owned by somebody from our call chain
jrd_req* temp_req = request;
Request* temp_req = request;
do {
if (blobIndex->bli_request == temp_req)
break;
@ -1224,7 +1224,7 @@ void blb::move(thread_db* tdbb, dsc* from_desc, dsc* to_desc,
blobIndex->bli_materialized = true;
blobIndex->bli_blob_id = *destination;
// Assign temporary BLOB ownership to top-level request if it is not assigned yet
jrd_req* own_request;
Request* own_request;
if (blobIndex->bli_request) {
own_request = blobIndex->bli_request;
}
@ -2081,7 +2081,7 @@ blb* blb::copy_blob(thread_db* tdbb, const bid* source, bid* destination,
**************************************/
SET_TDBB(tdbb);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
jrd_tra* transaction = request ? request->req_transaction : tdbb->getTransaction();
blb* input = open2(tdbb, transaction, source, bpb_length, bpb);
blb* output = create(tdbb, transaction, destination);
@ -2532,7 +2532,7 @@ static void move_from_string(thread_db* tdbb, const dsc* from_desc, dsc* to_desc
status_exception::raise(Arg::Gds(isc_malformed_string));
}
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
jrd_tra* transaction = request ? request->req_transaction : tdbb->getTransaction();
transaction = transaction->getOuter();
@ -2580,7 +2580,7 @@ static void move_from_string(thread_db* tdbb, const dsc* from_desc, dsc* to_desc
if (current->bli_materialized)
{
// Delete BLOB from request owned blob list
jrd_req* blob_request = current->bli_request;
Request* blob_request = current->bli_request;
if (blob_request)
{
if (blob_request->req_blobs.locate(blob_temp_id)) {
@ -2603,7 +2603,7 @@ static void move_from_string(thread_db* tdbb, const dsc* from_desc, dsc* to_desc
// we may still bind lifetime of blob to current top level request.
if (!current->bli_request)
{
jrd_req* blob_request = request;
Request* blob_request = request;
while (blob_request->req_caller)
blob_request = blob_request->req_caller;
@ -2641,7 +2641,7 @@ static void move_to_string(thread_db* tdbb, dsc* fromDesc, dsc* toDesc)
else
blobAsText.dsc_ttype() = ttype_ascii;
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
jrd_tra* transaction = request ? request->req_transaction : tdbb->getTransaction();
transaction = transaction->getOuter();
@ -2678,7 +2678,7 @@ void blb::destroy(const bool purge_flag)
{
if (blb_transaction->tra_blobs->locate(blb_temp_id))
{
jrd_req* blob_request = blb_transaction->tra_blobs->current().bli_request;
Request* blob_request = blb_transaction->tra_blobs->current().bli_request;
if (blob_request)
{

2
src/jrd/blb.h
View File

@ -51,7 +51,7 @@ namespace Jrd
class Attachment;
class BlobControl;
class jrd_rel;
class jrd_req;
class Request;
class jrd_tra;
class vcl;
class thread_db;

6
src/jrd/btr.cpp
View File

@ -541,8 +541,8 @@ DSC* BTR_eval_expression(thread_db* tdbb, index_desc* idx, Record* record, bool&
fb_assert(idx->idx_expression != NULL);
// check for resursive expression evaluation
jrd_req* const org_request = tdbb->getRequest();
jrd_req* const expr_request = idx->idx_expression_statement->findRequest(tdbb, true);
Request* const org_request = tdbb->getRequest();
Request* const expr_request = idx->idx_expression_statement->findRequest(tdbb, true);
if (expr_request == NULL)
ERR_post(Arg::Gds(isc_random) << "Attempt to evaluate index expression recursively");
@ -3281,7 +3281,7 @@ static DSC* eval(thread_db* tdbb, const ValueExprNode* node, DSC* temp, bool* is
**************************************/
SET_TDBB(tdbb);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
dsc* desc = EVL_expr(tdbb, request, node);
*isNull = false;

4
src/jrd/cmp.cpp
View File

@ -199,7 +199,7 @@ Statement* CMP_compile(thread_db* tdbb, const UCHAR* blr, ULONG blrLength, bool
return statement;
}
jrd_req* CMP_compile_request(thread_db* tdbb, const UCHAR* blr, ULONG blrLength, bool internalFlag)
Request* CMP_compile_request(thread_db* tdbb, const UCHAR* blr, ULONG blrLength, bool internalFlag)
{
/**************************************
*
@ -401,7 +401,7 @@ void CMP_post_resource( ResourceList* rsc_ptr, void* obj, Resource::rsc_s type,
}
void CMP_release(thread_db* tdbb, jrd_req* request)
void CMP_release(thread_db* tdbb, Request* request)
{
/**************************************
*

6
src/jrd/cmp_proto.h
View File

@ -39,11 +39,11 @@ Jrd::BoolExprNode* CMP_clone_node_opt(Jrd::thread_db*, Jrd::CompilerScratch*, Jr
Jrd::ValueExprNode* CMP_clone_node(Jrd::thread_db*, Jrd::CompilerScratch*, Jrd::ValueExprNode*);
Jrd::Statement* CMP_compile(Jrd::thread_db* tdbb, const UCHAR* blr, ULONG blrLength, bool internalFlag,
ULONG dbginfoLength, const UCHAR* dbginfo);
Jrd::jrd_req* CMP_compile_request(Jrd::thread_db*, const UCHAR* blr, ULONG blrLength, bool internalFlag);
Jrd::Request* CMP_compile_request(Jrd::thread_db*, const UCHAR* blr, ULONG blrLength, bool internalFlag);
Jrd::CompilerScratch::csb_repeat* CMP_csb_element(Jrd::CompilerScratch*, StreamType element);
const Jrd::Format* CMP_format(Jrd::thread_db*, Jrd::CompilerScratch*, StreamType);
Jrd::IndexLock* CMP_get_index_lock(Jrd::thread_db*, Jrd::jrd_rel*, USHORT);
Jrd::jrd_req* CMP_make_request(Jrd::thread_db*, Jrd::CompilerScratch*, bool);
Jrd::Request* CMP_make_request(Jrd::thread_db*, Jrd::CompilerScratch*, bool);
Jrd::ItemInfo* CMP_pass2_validation(Jrd::thread_db*, Jrd::CompilerScratch*, const Jrd::Item&);
void CMP_post_access(Jrd::thread_db*, Jrd::CompilerScratch*, const Jrd::MetaName&, SLONG ssRelationId,
@ -53,6 +53,6 @@ void CMP_post_access(Jrd::thread_db*, Jrd::CompilerScratch*, const Jrd::MetaName
void CMP_post_procedure_access(Jrd::thread_db*, Jrd::CompilerScratch*, Jrd::jrd_prc*);
void CMP_post_resource(Jrd::ResourceList*, void*, Jrd::Resource::rsc_s, USHORT);
Jrd::RecordSource* CMP_post_rse(Jrd::thread_db*, Jrd::CompilerScratch*, Jrd::RseNode*);
void CMP_release(Jrd::thread_db*, Jrd::jrd_req*);
void CMP_release(Jrd::thread_db*, Jrd::Request*);
#endif // JRD_CMP_PROTO_H

6
src/jrd/dfw.epp
View File

@ -2795,7 +2795,7 @@ static bool create_expression_index(thread_db* tdbb, SSHORT phase, DeferredWork*
SelectivityList selectivity(*tdbb->getDefaultPool());
jrd_tra* const current_transaction = tdbb->getTransaction();
jrd_req* const current_request = tdbb->getRequest();
Request* const current_request = tdbb->getRequest();
try
{
@ -5911,10 +5911,10 @@ static bool make_version(thread_db* tdbb, SSHORT phase, DeferredWork* work, jrd_
ValueExprNode* defaultNode = static_cast<ValueExprNode*>(MET_parse_blob(
tdbb, relation, defaultValue, NULL, &defaultStatement, false, false));
jrd_req* const defaultRequest = defaultStatement->findRequest(tdbb);
Request* const defaultRequest = defaultStatement->findRequest(tdbb);
// Attention: this is scoped to the end of this "try".
AutoSetRestore2<jrd_req*, thread_db> autoRequest(tdbb,
AutoSetRestore2<Request*, thread_db> autoRequest(tdbb,
&thread_db::getRequest, &thread_db::setRequest, defaultRequest);
defaultRequest->validateTimeStamp();

8
src/jrd/evl.cpp
View File

@ -134,7 +134,7 @@ dsc* EVL_assign_to(thread_db* tdbb, const ValueExprNode* node)
DEV_BLKCHK(node, type_nod);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
// The only nodes that can be assigned to are: argument, field and variable.
@ -243,7 +243,7 @@ RecordBitmap** EVL_bitmap(thread_db* tdbb, const InversionNode* node, RecordBitm
case InversionNode::TYPE_DBKEY:
{
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
impure_inversion* impure = request->getImpure<impure_inversion>(node->impure);
RecordBitmap::reset(impure->inv_bitmap);
const dsc* const desc = EVL_expr(tdbb, request, node->value);
@ -303,7 +303,7 @@ void EVL_dbkey_bounds(thread_db* tdbb, const Array<DbKeyRangeNode*>& ranges,
**************************************/
SET_TDBB(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
for (const auto node : ranges)
{
@ -624,7 +624,7 @@ void EVL_validate(thread_db* tdbb, const Item& item, const ItemInfo* itemInfo, d
if (itemInfo == NULL)
return;
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
bool err = false;
if (null && !itemInfo->nullable)

2
src/jrd/evl_proto.h
View File

@ -46,7 +46,7 @@ void EVL_validate(Jrd::thread_db*, const Jrd::Item&, const Jrd::ItemInfo*, dsc*
namespace Jrd
{
// Evaluate a value expression.
inline dsc* EVL_expr(thread_db* tdbb, jrd_req* request, const ValueExprNode* node)
inline dsc* EVL_expr(thread_db* tdbb, Request* request, const ValueExprNode* node)
{
if (!node)
BUGCHECK(303); // msg 303 Invalid expression for evaluation

72
src/jrd/exe.cpp
View File

@ -214,11 +214,11 @@ string StatusXcp::as_text() const
}
static void execute_looper(thread_db*, jrd_req*, jrd_tra*, const StmtNode*, jrd_req::req_s);
static void looper_seh(thread_db*, jrd_req*, const StmtNode*);
static void release_blobs(thread_db*, jrd_req*);
static void trigger_failure(thread_db*, jrd_req*);
static void stuff_stack_trace(const jrd_req*);
static void execute_looper(thread_db*, Request*, jrd_tra*, const StmtNode*, Request::req_s);
static void looper_seh(thread_db*, Request*, const StmtNode*);
static void release_blobs(thread_db*, Request*);
static void trigger_failure(thread_db*, Request*);
static void stuff_stack_trace(const Request*);
const size_t MAX_STACK_TRACE = 2048;
@ -229,7 +229,7 @@ void EXE_assignment(thread_db* tdbb, const AssignmentNode* node)
DEV_BLKCHK(node, type_nod);
SET_TDBB(tdbb);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
// Get descriptors of src field/parameter/variable, etc.
request->req_flags &= ~req_null;
@ -243,7 +243,7 @@ void EXE_assignment(thread_db* tdbb, const AssignmentNode* node)
void EXE_assignment(thread_db* tdbb, const ValueExprNode* source, const ValueExprNode* target)
{
SET_TDBB(tdbb);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
// Get descriptors of src field/parameter/variable, etc.
request->req_flags &= ~req_null;
@ -257,14 +257,14 @@ void EXE_assignment(thread_db* tdbb, const ValueExprNode* to, dsc* from_desc, bo
const ValueExprNode* missing_node, const ValueExprNode* missing2_node)
{
SET_TDBB(tdbb);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const auto toVar = nodeAs<VariableNode>(to);
if (toVar && toVar->outerDecl)
request = toVar->getVarRequest(request);
AutoSetRestore2<jrd_req*, thread_db> autoSetRequest(
AutoSetRestore2<Request*, thread_db> autoSetRequest(
tdbb, &thread_db::getRequest, &thread_db::setRequest, request);
// Get descriptors of receiving and sending fields/parameters, variables, etc.
@ -299,7 +299,7 @@ void EXE_assignment(thread_db* tdbb, const ValueExprNode* to, dsc* from_desc, bo
if (toParam->argInfo)
{
AutoSetRestore2<jrd_req*, thread_db> autoSetRequest(
AutoSetRestore2<Request*, thread_db> autoSetRequest(
tdbb, &thread_db::getRequest, &thread_db::setRequest, paramRequest);
EVL_validate(tdbb, Item(Item::TYPE_PARAMETER, message->messageNumber, toParam->argNumber),
@ -315,7 +315,7 @@ void EXE_assignment(thread_db* tdbb, const ValueExprNode* to, dsc* from_desc, bo
if (toVar->varInfo)
{
AutoSetRestore2<jrd_req*, thread_db> autoSetRequest(
AutoSetRestore2<Request*, thread_db> autoSetRequest(
tdbb, &thread_db::getRequest, &thread_db::setRequest, varRequest);
EVL_validate(tdbb, Item(Item::TYPE_VARIABLE, toVar->varId),
@ -589,7 +589,7 @@ void EXE_execute_ddl_triggers(thread_db* tdbb, jrd_tra* transaction, bool preTri
void EXE_receive(thread_db* tdbb,
jrd_req* request,
Request* request,
USHORT msg,
ULONG length,
void* buffer,
@ -647,9 +647,9 @@ void EXE_receive(thread_db* tdbb,
try
{
if (nodeIs<StallNode>(request->req_message))
execute_looper(tdbb, request, transaction, request->req_next, jrd_req::req_sync);
execute_looper(tdbb, request, transaction, request->req_next, Request::req_sync);
if (!(request->req_flags & req_active) || request->req_operation != jrd_req::req_send)
if (!(request->req_flags & req_active) || request->req_operation != Request::req_send)
ERR_post(Arg::Gds(isc_req_sync));
const MessageNode* message = nodeAs<MessageNode>(request->req_message);
@ -694,7 +694,7 @@ void EXE_receive(thread_db* tdbb,
}
}
execute_looper(tdbb, request, transaction, request->req_next, jrd_req::req_proceed);
execute_looper(tdbb, request, transaction, request->req_next, Request::req_proceed);
}
catch (const Exception&)
{
@ -744,7 +744,7 @@ void EXE_receive(thread_db* tdbb,
// Release a request instance.
void EXE_release(thread_db* tdbb, jrd_req* request)
void EXE_release(thread_db* tdbb, Request* request)
{
DEV_BLKCHK(request, type_req);
@ -768,7 +768,7 @@ void EXE_release(thread_db* tdbb, jrd_req* request)
}
void EXE_send(thread_db* tdbb, jrd_req* request, USHORT msg, ULONG length, const void* buffer)
void EXE_send(thread_db* tdbb, Request* request, USHORT msg, ULONG length, const void* buffer)
{
/**************************************
*
@ -792,7 +792,7 @@ void EXE_send(thread_db* tdbb, jrd_req* request, USHORT msg, ULONG length, const
const StmtNode* message = NULL;
const StmtNode* node;
if (request->req_operation != jrd_req::req_receive)
if (request->req_operation != Request::req_receive)
ERR_post(Arg::Gds(isc_req_sync));
node = request->req_message;
@ -831,11 +831,11 @@ void EXE_send(thread_db* tdbb, jrd_req* request, USHORT msg, ULONG length, const
memcpy(request->getImpure<UCHAR>(message->impureOffset), buffer, length);
execute_looper(tdbb, request, transaction, request->req_next, jrd_req::req_proceed);
execute_looper(tdbb, request, transaction, request->req_next, Request::req_proceed);
}
void EXE_start(thread_db* tdbb, jrd_req* request, jrd_tra* transaction)
void EXE_start(thread_db* tdbb, Request* request, jrd_tra* transaction)
{
/**************************************
*
@ -908,11 +908,11 @@ void EXE_start(thread_db* tdbb, jrd_req* request, jrd_tra* transaction)
execute_looper(tdbb, request, transaction,
request->getStatement()->topNode,
jrd_req::req_evaluate);
Request::req_evaluate);
}
void EXE_unwind(thread_db* tdbb, jrd_req* request)
void EXE_unwind(thread_db* tdbb, Request* request)
{
/**************************************
*
@ -935,7 +935,7 @@ void EXE_unwind(thread_db* tdbb, jrd_req* request)
if (statement->fors.getCount() || request->req_ext_resultset || request->req_ext_stmt)
{
Jrd::ContextPoolHolder context(tdbb, request->req_pool);
jrd_req* old_request = tdbb->getRequest();
Request* old_request = tdbb->getRequest();
jrd_tra* old_transaction = tdbb->getTransaction();
try {
tdbb->setRequest(request);
@ -1002,10 +1002,10 @@ void EXE_unwind(thread_db* tdbb, jrd_req* request)
static void execute_looper(thread_db* tdbb,
jrd_req* request,
Request* request,
jrd_tra* transaction,
const StmtNode* node,
jrd_req::req_s next_state)
Request::req_s next_state)
{
/**************************************
*
@ -1120,7 +1120,7 @@ void EXE_execute_triggers(thread_db* tdbb,
SET_TDBB(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
jrd_tra* const transaction = request ? request->req_transaction : tdbb->getTransaction();
TrigVector* vector = *triggers;
@ -1149,7 +1149,7 @@ void EXE_execute_triggers(thread_db* tdbb,
else
TimeZoneUtil::validateGmtTimeStamp(timestamp);
jrd_req* trigger = NULL;
Request* trigger = NULL;
try
{
@ -1210,7 +1210,7 @@ void EXE_execute_triggers(thread_db* tdbb,
EXE_start(tdbb, trigger, transaction);
}
const bool ok = (trigger->req_operation != jrd_req::req_unwind);
const bool ok = (trigger->req_operation != Request::req_unwind);
trace.finish(ok ? ITracePlugin::RESULT_SUCCESS : ITracePlugin::RESULT_FAILED);
EXE_unwind(tdbb, trigger);
@ -1246,11 +1246,11 @@ void EXE_execute_triggers(thread_db* tdbb,
}
static void stuff_stack_trace(const jrd_req* request)
static void stuff_stack_trace(const Request* request)
{
string sTrace;
for (const jrd_req* req = request; req; req = req->req_caller)
for (const Request* req = request; req; req = req->req_caller)
{
const Statement* const statement = req->getStatement();
@ -1310,7 +1310,7 @@ static void stuff_stack_trace(const jrd_req* request)
}
const StmtNode* EXE_looper(thread_db* tdbb, jrd_req* request, const StmtNode* node)
const StmtNode* EXE_looper(thread_db* tdbb, Request* request, const StmtNode* node)
{
/**************************************
*
@ -1348,7 +1348,7 @@ const StmtNode* EXE_looper(thread_db* tdbb, jrd_req* request, const StmtNode* no
{
try
{
if (request->req_operation == jrd_req::req_evaluate)
if (request->req_operation == Request::req_evaluate)
{
JRD_reschedule(tdbb);
@ -1390,7 +1390,7 @@ const StmtNode* EXE_looper(thread_db* tdbb, jrd_req* request, const StmtNode* no
exeState.errorPending = true;
exeState.catchDisabled = true;
request->req_operation = jrd_req::req_unwind;
request->req_operation = Request::req_unwind;
request->req_label = 0;
if (!(tdbb->tdbb_flags & TDBB_stack_trace_done) && !(tdbb->tdbb_flags & TDBB_sys_error))
@ -1453,7 +1453,7 @@ const StmtNode* EXE_looper(thread_db* tdbb, jrd_req* request, const StmtNode* no
// Start looper under Windows SEH (Structured Exception Handling) control
static void looper_seh(thread_db* tdbb, jrd_req* request, const StmtNode* node)
static void looper_seh(thread_db* tdbb, Request* request, const StmtNode* node)
{
#ifdef WIN_NT
START_CHECK_FOR_EXCEPTIONS(NULL);
@ -1475,7 +1475,7 @@ static void looper_seh(thread_db* tdbb, jrd_req* request, const StmtNode* node)
}
static void release_blobs(thread_db* tdbb, jrd_req* request)
static void release_blobs(thread_db* tdbb, Request* request)
{
/**************************************
*
@ -1550,7 +1550,7 @@ static void release_blobs(thread_db* tdbb, jrd_req* request)
}
static void trigger_failure(thread_db* tdbb, jrd_req* trigger)
static void trigger_failure(thread_db* tdbb, Request* trigger)
{
/**************************************
*

26
src/jrd/exe_proto.h
View File

@ -27,7 +27,7 @@
#include "../jrd/cmp_proto.h"
namespace Jrd {
class jrd_req;
class Request;
class jrd_tra;
class AssignmentNode;
}
@ -40,17 +40,17 @@ void EXE_assignment(Jrd::thread_db* tdbb, const Jrd::ValueExprNode* to, dsc* fro
void EXE_execute_db_triggers(Jrd::thread_db*, Jrd::jrd_tra*, enum TriggerAction);
void EXE_execute_ddl_triggers(Jrd::thread_db* tdbb, Jrd::jrd_tra* transaction,
bool preTriggers, int action);
const Jrd::StmtNode* EXE_looper(Jrd::thread_db* tdbb, Jrd::jrd_req* request,
const Jrd::StmtNode* EXE_looper(Jrd::thread_db* tdbb, Jrd::Request* request,
const Jrd::StmtNode* in_node);
void EXE_execute_triggers(Jrd::thread_db*, Jrd::TrigVector**, Jrd::record_param*, Jrd::record_param*,
enum TriggerAction, Jrd::StmtNode::WhichTrigger);
void EXE_receive(Jrd::thread_db*, Jrd::jrd_req*, USHORT, ULONG, void*, bool = false);
void EXE_release(Jrd::thread_db*, Jrd::jrd_req*);
void EXE_send(Jrd::thread_db*, Jrd::jrd_req*, USHORT, ULONG, const void*);
void EXE_start(Jrd::thread_db*, Jrd::jrd_req*, Jrd::jrd_tra*);
void EXE_unwind(Jrd::thread_db*, Jrd::jrd_req*);
void EXE_receive(Jrd::thread_db*, Jrd::Request*, USHORT, ULONG, void*, bool = false);
void EXE_release(Jrd::thread_db*, Jrd::Request*);
void EXE_send(Jrd::thread_db*, Jrd::Request*, USHORT, ULONG, const void*);
void EXE_start(Jrd::thread_db*, Jrd::Request*, Jrd::jrd_tra*);
void EXE_unwind(Jrd::thread_db*, Jrd::Request*);
namespace Jrd
{
@ -97,12 +97,12 @@ namespace Jrd
cacheRequest();
}
jrd_req* operator ->()
Request* operator ->()
{
return request;
}
operator jrd_req*()
operator Request*()
{
return request;
}
@ -139,7 +139,7 @@ namespace Jrd
private:
USHORT id;
USHORT which;
jrd_req* request;
Request* request;
};
class AutoRequest
@ -169,12 +169,12 @@ namespace Jrd
request = CMP_compile_request(tdbb, blr, blrLength, true);
}
jrd_req* operator ->()
Request* operator ->()
{
return request;
}
operator jrd_req*()
operator Request*()
{
return request;
}
@ -195,7 +195,7 @@ namespace Jrd
}
private:
jrd_req* request;
Request* request;
};
}

8
src/jrd/extds/ExtDS.cpp
View File

@ -2249,7 +2249,7 @@ void Statement::doSetInParams(thread_db* tdbb, unsigned int count, const MetaStr
const NestConst<ValueExprNode>* jrdVar = params;
GenericMap<Pair<NonPooled<const ValueExprNode*, dsc*> > > paramDescs(getPool());
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
for (FB_SIZE_T i = 0; i < count; ++i, ++jrdVar)
{
@ -2364,7 +2364,7 @@ void Statement::getExtBlob(thread_db* tdbb, const dsc& src, dsc& dst)
{
extBlob->open(tdbb, *m_transaction, src, NULL);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
const UCHAR bpb[] = {isc_bpb_version1, isc_bpb_storage, 1, isc_bpb_storage_temp};
bid* localBlobID = (bid*) dst.dsc_address;
destBlob = blb::create2(tdbb, request->req_transaction, localBlobID, sizeof(bpb), bpb);
@ -2408,7 +2408,7 @@ void Statement::putExtBlob(thread_db* tdbb, dsc& src, dsc& dst)
{
extBlob->create(tdbb, *m_transaction, dst, NULL);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
bid* srcBid = (bid*) src.dsc_address;
UCharBuffer bpb;
@ -2478,7 +2478,7 @@ void Statement::raise(FbStatusVector* status, thread_db* tdbb, const char* sWher
Arg::Str(m_connection.getDataSourceName()));
}
void Statement::bindToRequest(jrd_req* request, Statement** impure)
void Statement::bindToRequest(Request* request, Statement** impure)
{
fb_assert(!m_boundReq);
fb_assert(!m_prevInReq);

6
src/jrd/extds/ExtDS.h
View File

@ -631,7 +631,7 @@ public:
const Firebird::string* sQuery = NULL);
// Active statement must be bound to parent jrd request
void bindToRequest(Jrd::jrd_req* request, Statement** impure);
void bindToRequest(Jrd::Request* request, Statement** impure);
void unBindFromRequest();
protected:
@ -666,7 +666,7 @@ protected:
Statement* m_nextFree; // next free statement
Jrd::jrd_req* m_boundReq;
Jrd::Request* m_boundReq;
Statement** m_ReqImpure;
Statement* m_nextInReq;
Statement* m_prevInReq;
@ -693,7 +693,7 @@ protected:
unsigned int m_outputs;
bool m_callerPrivileges;
Jrd::jrd_req* m_preparedByReq;
Jrd::Request* m_preparedByReq;
// set in preprocess
Firebird::SortedObjectsArray<const Firebird::MetaString> m_sqlParamNames;

2
src/jrd/extds/InternalDS.cpp
View File

@ -459,7 +459,7 @@ void InternalStatement::doPrepare(thread_db* tdbb, const string& sql)
if (m_callerPrivileges)
{
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
auto statement = request ? request->getStatement() : NULL;
CallerName callerName;
const Routine* routine;

2
src/jrd/fun.epp
View File

@ -359,7 +359,7 @@ void FUN_evaluate(thread_db* tdbb, const Function* function, const NestValueArra
const Parameter* return_ptr = function->getOutputFields()[0];
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
// CVC: restoring the null flag seems like a Borland hack to try to
// patch a bug with null handling. There's no evident reason to restore it
// because EVL_expr() resets it every time it's called. Kept it for now.

12
src/jrd/inf.cpp
View File

@ -1008,7 +1008,7 @@ UCHAR* INF_put_item(UCHAR item,
}
ULONG INF_request_info(const jrd_req* request,
ULONG INF_request_info(const Request* request,
const ULONG item_length,
const UCHAR* items,
const ULONG output_length,
@ -1090,9 +1090,9 @@ ULONG INF_request_info(const jrd_req* request,
else
{
auto state = isc_info_req_active;
if (request->req_operation == jrd_req::req_send)
if (request->req_operation == Request::req_send)
state = isc_info_req_send;
else if (request->req_operation == jrd_req::req_receive)
else if (request->req_operation == Request::req_receive)
{
const StmtNode* node = request->req_next;
@ -1101,7 +1101,7 @@ ULONG INF_request_info(const jrd_req* request,
else
state = isc_info_req_receive;
}
else if ((request->req_operation == jrd_req::req_return) &&
else if ((request->req_operation == Request::req_return) &&
(request->req_flags & req_stall))
{
state = isc_info_req_sql_stall;
@ -1113,8 +1113,8 @@ ULONG INF_request_info(const jrd_req* request,
case isc_info_message_number:
case isc_info_message_size:
if (!(request->req_flags & req_active) ||
(request->req_operation != jrd_req::req_receive &&
request->req_operation != jrd_req::req_send))
(request->req_operation != Request::req_receive &&
request->req_operation != Request::req_send))
{
buffer_ptr[0] = item;
item = isc_info_error;

4
src/jrd/inf_proto.h
View File

@ -25,7 +25,7 @@
#define JRD_INF_PROTO_H
namespace Jrd {
class jrd_req;
class Request;
class jrd_tra;
class blb;
}
@ -34,7 +34,7 @@ void INF_blob_info(const Jrd::blb*, const ULONG, const UCHAR*, const ULONG, UCHA
USHORT INF_convert(SINT64, UCHAR*);
void INF_database_info(Jrd::thread_db*, const ULONG, const UCHAR*, const ULONG, UCHAR*);
UCHAR* INF_put_item(UCHAR, ULONG, const void*, UCHAR*, const UCHAR*, const bool inserting = false);
ULONG INF_request_info(const Jrd::jrd_req*, const ULONG, const UCHAR*, const ULONG, UCHAR*);
ULONG INF_request_info(const Jrd::Request*, const ULONG, const UCHAR*, const ULONG, UCHAR*);
void INF_transaction_info(const Jrd::jrd_tra*, const ULONG, const UCHAR*, const ULONG, UCHAR*);
#endif // JRD_INF_PROTO_H

32
src/jrd/jrd.cpp
View File

@ -1311,7 +1311,7 @@ static bool drop_files(const jrd_file*);
static void find_intl_charset(thread_db*, Jrd::Attachment*, const DatabaseOptions*);
static void init_database_lock(thread_db*);
static void run_commit_triggers(thread_db* tdbb, jrd_tra* transaction);
static jrd_req* verify_request_synchronization(Statement* statement, USHORT level);
static Request* verify_request_synchronization(Statement* statement, USHORT level);
static void purge_transactions(thread_db*, Jrd::Attachment*, const bool);
static void check_single_maintenance(thread_db* tdbb);
@ -1357,7 +1357,7 @@ TraceFailedConnection::TraceFailedConnection(const char* filename, const Databas
// do it here to prevent committing every record update
// in a statement
//
static void check_autocommit(thread_db* tdbb, jrd_req* request)
static void check_autocommit(thread_db* tdbb, Request* request)
{
jrd_tra* const transaction = request->req_transaction;
@ -3880,7 +3880,7 @@ void JRequest::receive(CheckStatusWrapper* user_status, int level, unsigned int
EngineContextHolder tdbb(user_status, this, FB_FUNCTION);
check_database(tdbb);
jrd_req* request = verify_request_synchronization(getHandle(), level);
Request* request = verify_request_synchronization(getHandle(), level);
try
{
@ -4017,7 +4017,7 @@ void JRequest::getInfo(CheckStatusWrapper* user_status, int level, unsigned int
EngineContextHolder tdbb(user_status, this, FB_FUNCTION);
check_database(tdbb);
jrd_req* request = verify_request_synchronization(getHandle(), level);
Request* request = verify_request_synchronization(getHandle(), level);
try
{
@ -4220,7 +4220,7 @@ void JRequest::send(CheckStatusWrapper* user_status, int level, unsigned int msg
EngineContextHolder tdbb(user_status, this, FB_FUNCTION);
check_database(tdbb);
jrd_req* request = verify_request_synchronization(getHandle(), level);
Request* request = verify_request_synchronization(getHandle(), level);
try
{
@ -4447,7 +4447,7 @@ void JRequest::startAndSend(CheckStatusWrapper* user_status, ITransaction* tra,
validateHandle(tdbb, transaction);
check_database(tdbb);
jrd_req* request = getHandle()->getRequest(tdbb, level);
Request* request = getHandle()->getRequest(tdbb, level);
try
{
@ -4505,7 +4505,7 @@ void JRequest::start(CheckStatusWrapper* user_status, ITransaction* tra, int lev
validateHandle(tdbb, transaction);
check_database(tdbb);
jrd_req* request = getHandle()->getRequest(tdbb, level);
Request* request = getHandle()->getRequest(tdbb, level);
try
{
@ -4703,7 +4703,7 @@ void JAttachment::transactRequest(CheckStatusWrapper* user_status, ITransaction*
const MessageNode* inMessage = NULL;
const MessageNode* outMessage = NULL;
jrd_req* request = NULL;
Request* request = NULL;
MemoryPool* new_pool = att->createPool();
try
@ -4922,7 +4922,7 @@ void JRequest::unwind(CheckStatusWrapper* user_status, int level)
EngineContextHolder tdbb(user_status, this, FB_FUNCTION);
check_database(tdbb);
jrd_req* request = verify_request_synchronization(getHandle(), level);
Request* request = verify_request_synchronization(getHandle(), level);
try
{
@ -8335,7 +8335,7 @@ static void run_commit_triggers(thread_db* tdbb, jrd_tra* transaction)
//
// @param request The incoming, parent request to be replaced.
// @param level The level of the sub-request we need to find.
static jrd_req* verify_request_synchronization(Statement* statement, USHORT level)
static Request* verify_request_synchronization(Statement* statement, USHORT level)
{
if (level)
{
@ -8895,7 +8895,7 @@ void thread_db::setTransaction(jrd_tra* val)
traStat = val ? &val->tra_stats : RuntimeStatistics::getDummy();
}
void thread_db::setRequest(jrd_req* val)
void thread_db::setRequest(Request* val)
{
request = val;
reqStat = val ? &val->req_stats : RuntimeStatistics::getDummy();
@ -9084,7 +9084,7 @@ void JRD_autocommit_ddl(thread_db* tdbb, jrd_tra* transaction)
}
void JRD_receive(thread_db* tdbb, jrd_req* request, USHORT msg_type, ULONG msg_length, void* msg)
void JRD_receive(thread_db* tdbb, Request* request, USHORT msg_type, ULONG msg_length, void* msg)
{
/**************************************
*
@ -9108,7 +9108,7 @@ void JRD_receive(thread_db* tdbb, jrd_req* request, USHORT msg_type, ULONG msg_l
}
void JRD_send(thread_db* tdbb, jrd_req* request, USHORT msg_type, ULONG msg_length, const void* msg)
void JRD_send(thread_db* tdbb, Request* request, USHORT msg_type, ULONG msg_length, const void* msg)
{
/**************************************
*
@ -9132,7 +9132,7 @@ void JRD_send(thread_db* tdbb, jrd_req* request, USHORT msg_type, ULONG msg_leng
}
void JRD_start(Jrd::thread_db* tdbb, jrd_req* request, jrd_tra* transaction)
void JRD_start(Jrd::thread_db* tdbb, Request* request, jrd_tra* transaction)
{
/**************************************
*
@ -9221,7 +9221,7 @@ void JRD_rollback_retaining(thread_db* tdbb, jrd_tra* transaction)
}
void JRD_start_and_send(thread_db* tdbb, jrd_req* request, jrd_tra* transaction,
void JRD_start_and_send(thread_db* tdbb, Request* request, jrd_tra* transaction,
USHORT msg_type, ULONG msg_length, const void* msg)
{
/**************************************
@ -9349,7 +9349,7 @@ void JRD_start_transaction(thread_db* tdbb, jrd_tra** transaction,
}
void JRD_unwind_request(thread_db* tdbb, jrd_req* request)
void JRD_unwind_request(thread_db* tdbb, Request* request)
{
/**************************************
*

10
src/jrd/jrd.h
View File

@ -106,7 +106,7 @@ const unsigned MAX_CALLBACKS = 50;
class thread_db;
class Attachment;
class jrd_tra;
class jrd_req;
class Request;
class Statement;
class jrd_file;
class Format;
@ -506,7 +506,7 @@ private:
Database* database;
Attachment* attachment;
jrd_tra* transaction;
jrd_req* request;
Request* request;
RuntimeStatistics *reqStat, *traStat, *attStat, *dbbStat;
public:
@ -591,17 +591,17 @@ public:
void setTransaction(jrd_tra* val);
jrd_req* getRequest()
Request* getRequest()
{
return request;
}
const jrd_req* getRequest() const
const Request* getRequest() const
{
return request;
}
void setRequest(jrd_req* val);
void setRequest(Request* val);
SSHORT getCharSet() const;

12
src/jrd/jrd_proto.h
View File

@ -35,7 +35,7 @@ namespace Jrd {
class jrd_tra;
class blb;
struct bid;
class jrd_req;
class Request;
class Statement;
class Service;
class thread_db;
@ -55,22 +55,22 @@ void JRD_print_procedure_info(Jrd::thread_db*, const char*);
void JRD_autocommit_ddl(Jrd::thread_db* tdbb, Jrd::jrd_tra* transaction);
void JRD_receive(Jrd::thread_db* tdbb, Jrd::jrd_req* request, USHORT msg_type, ULONG msg_length,
void JRD_receive(Jrd::thread_db* tdbb, Jrd::Request* request, USHORT msg_type, ULONG msg_length,
void* msg);
void JRD_start(Jrd::thread_db* tdbb, Jrd::jrd_req* request, Jrd::jrd_tra* transaction);
void JRD_start(Jrd::thread_db* tdbb, Jrd::Request* request, Jrd::jrd_tra* transaction);
void JRD_commit_transaction(Jrd::thread_db* tdbb, Jrd::jrd_tra* transaction);
void JRD_commit_retaining(Jrd::thread_db* tdbb, Jrd::jrd_tra* transaction);
void JRD_rollback_transaction(Jrd::thread_db* tdbb, Jrd::jrd_tra* transaction);
void JRD_rollback_retaining(Jrd::thread_db* tdbb, Jrd::jrd_tra* transaction);
void JRD_run_trans_start_triggers(Jrd::thread_db* tdbb, Jrd::jrd_tra* transaction);
void JRD_send(Jrd::thread_db* tdbb, Jrd::jrd_req* request, USHORT msg_type, ULONG msg_length,
void JRD_send(Jrd::thread_db* tdbb, Jrd::Request* request, USHORT msg_type, ULONG msg_length,
const void* msg);
void JRD_start_and_send(Jrd::thread_db* tdbb, Jrd::jrd_req* request, Jrd::jrd_tra* transaction,
void JRD_start_and_send(Jrd::thread_db* tdbb, Jrd::Request* request, Jrd::jrd_tra* transaction,
USHORT msg_type, ULONG msg_length, const void* msg);
void JRD_start_transaction(Jrd::thread_db* tdbb, Jrd::jrd_tra** transaction,
Jrd::Attachment* attachment, unsigned int tpb_length, const UCHAR* tpb);
void JRD_unwind_request(Jrd::thread_db* tdbb, Jrd::jrd_req* request);
void JRD_unwind_request(Jrd::thread_db* tdbb, Jrd::Request* request);
bool JRD_verify_database_access(const Firebird::PathName&);
void JRD_shutdown_attachment(Jrd::Attachment* attachment);
void JRD_shutdown_attachments(Jrd::Database* dbb);

2
src/jrd/met_proto.h
View File

@ -31,7 +31,7 @@ struct dsc;
namespace Jrd
{
class jrd_tra;
class jrd_req;
class Request;
class Statement;
class jrd_prc;
class Format;

2
src/jrd/par_proto.h
View File

@ -27,7 +27,7 @@
namespace Jrd {
class CompilerScratch;
class jrd_rel;
class jrd_req;
class Request;
class Statement;
class thread_db;
class ItemInfo;

22
src/jrd/recsrc/AggregatedStream.cpp
View File

@ -54,7 +54,7 @@ BaseAggWinStream<ThisType, NextType>::BaseAggWinStream(thread_db* tdbb, Compiler
template <typename ThisType, typename NextType>
void BaseAggWinStream<ThisType, NextType>::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = getImpure(request);
impure->irsb_flags = irsb_open;
@ -77,7 +77,7 @@ void BaseAggWinStream<ThisType, NextType>::open(thread_db* tdbb) const
template <typename ThisType, typename NextType>
void BaseAggWinStream<ThisType, NextType>::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -111,7 +111,7 @@ void BaseAggWinStream<ThisType, NextType>::markRecursive()
}
template <typename ThisType, typename NextType>
void BaseAggWinStream<ThisType, NextType>::invalidateRecords(jrd_req* request) const
void BaseAggWinStream<ThisType, NextType>::invalidateRecords(Request* request) const
{
m_next->invalidateRecords(request);
}
@ -130,7 +130,7 @@ void BaseAggWinStream<ThisType, NextType>::findUsedStreams(StreamList& streams,
template <typename ThisType, typename NextType>
bool BaseAggWinStream<ThisType, NextType>::evaluateGroup(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
JRD_reschedule(tdbb);
@ -194,7 +194,7 @@ bool BaseAggWinStream<ThisType, NextType>::evaluateGroup(thread_db* tdbb) const
// Initialize the aggregate record
template <typename ThisType, typename NextType>
void BaseAggWinStream<ThisType, NextType>::aggInit(thread_db* tdbb, jrd_req* request,
void BaseAggWinStream<ThisType, NextType>::aggInit(thread_db* tdbb, Request* request,
const MapNode* map) const
{
const NestConst<ValueExprNode>* const sourceEnd = map->sourceList.end();
@ -215,7 +215,7 @@ void BaseAggWinStream<ThisType, NextType>::aggInit(thread_db* tdbb, jrd_req* req
// Go through and compute all the aggregates on this record
template <typename ThisType, typename NextType>
bool BaseAggWinStream<ThisType, NextType>::aggPass(thread_db* tdbb, jrd_req* request,
bool BaseAggWinStream<ThisType, NextType>::aggPass(thread_db* tdbb, Request* request,
const NestValueArray& sourceList, const NestValueArray& targetList) const
{
bool ret = true;
@ -245,7 +245,7 @@ bool BaseAggWinStream<ThisType, NextType>::aggPass(thread_db* tdbb, jrd_req* req
}
template <typename ThisType, typename NextType>
void BaseAggWinStream<ThisType, NextType>::aggExecute(thread_db* tdbb, jrd_req* request,
void BaseAggWinStream<ThisType, NextType>::aggExecute(thread_db* tdbb, Request* request,
const NestValueArray& sourceList, const NestValueArray& targetList) const
{
const NestConst<ValueExprNode>* const sourceEnd = sourceList.end();
@ -277,7 +277,7 @@ void BaseAggWinStream<ThisType, NextType>::aggExecute(thread_db* tdbb, jrd_req*
// Finalize a sort for distinct aggregate
template <typename ThisType, typename NextType>
void BaseAggWinStream<ThisType, NextType>::aggFinish(thread_db* tdbb, jrd_req* request,
void BaseAggWinStream<ThisType, NextType>::aggFinish(thread_db* tdbb, Request* request,
const MapNode* map) const
{
const NestConst<ValueExprNode>* const sourceEnd = map->sourceList.end();
@ -295,7 +295,7 @@ void BaseAggWinStream<ThisType, NextType>::aggFinish(thread_db* tdbb, jrd_req* r
// Look for change in the values of a group/order.
template <typename ThisType, typename NextType>
int BaseAggWinStream<ThisType, NextType>::lookForChange(thread_db* tdbb, jrd_req* request,
int BaseAggWinStream<ThisType, NextType>::lookForChange(thread_db* tdbb, Request* request,
const NestValueArray* group, const SortNode* sort, impure_value* values) const
{
if (!group)
@ -340,7 +340,7 @@ int BaseAggWinStream<ThisType, NextType>::lookForChange(thread_db* tdbb, jrd_req
}
template <typename ThisType, typename NextType>
bool BaseAggWinStream<ThisType, NextType>::getNextRecord(thread_db* tdbb, jrd_req* request) const
bool BaseAggWinStream<ThisType, NextType>::getNextRecord(thread_db* tdbb, Request* request) const
{
Impure* const impure = getImpure(request);
@ -377,7 +377,7 @@ bool AggregatedStream::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
record_param* const rpb = &request->req_rpb[m_stream];
Impure* const impure = getImpure(request);

6
src/jrd/recsrc/BitmapTableScan.cpp
View File

@ -48,7 +48,7 @@ BitmapTableScan::BitmapTableScan(CompilerScratch* csb, const string& alias,
void BitmapTableScan::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -62,7 +62,7 @@ void BitmapTableScan::open(thread_db* tdbb) const
void BitmapTableScan::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -84,7 +84,7 @@ bool BitmapTableScan::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
record_param* const rpb = &request->req_rpb[m_stream];
Impure* const impure = request->getImpure<Impure>(m_impure);

12
src/jrd/recsrc/BufferedStream.cpp
View File

@ -114,7 +114,7 @@ BufferedStream::BufferedStream(CompilerScratch* csb, RecordSource* next)
void BufferedStream::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open | irsb_mustread;
@ -130,7 +130,7 @@ void BufferedStream::open(thread_db* tdbb) const
void BufferedStream::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -151,7 +151,7 @@ bool BufferedStream::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -334,7 +334,7 @@ void BufferedStream::findUsedStreams(StreamList& streams, bool expandAll) const
m_next->findUsedStreams(streams, expandAll);
}
void BufferedStream::invalidateRecords(jrd_req* request) const
void BufferedStream::invalidateRecords(Request* request) const
{
m_next->invalidateRecords(request);
}
@ -346,7 +346,7 @@ void BufferedStream::nullRecords(thread_db* tdbb) const
void BufferedStream::locate(thread_db* tdbb, FB_UINT64 position) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
// If we haven't fetched and cached the underlying stream completely, do it now
@ -362,7 +362,7 @@ void BufferedStream::locate(thread_db* tdbb, FB_UINT64 position) const
FB_UINT64 BufferedStream::getCount(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
// If we haven't fetched and cached the underlying stream completely, do it now

12
src/jrd/recsrc/ConditionalStream.cpp
View File

@ -50,7 +50,7 @@ ConditionalStream::ConditionalStream(CompilerScratch* csb,
void ConditionalStream::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -61,7 +61,7 @@ void ConditionalStream::open(thread_db* tdbb) const
void ConditionalStream::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -79,7 +79,7 @@ bool ConditionalStream::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -90,7 +90,7 @@ bool ConditionalStream::getRecord(thread_db* tdbb) const
bool ConditionalStream::refetchRecord(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -101,7 +101,7 @@ bool ConditionalStream::refetchRecord(thread_db* tdbb) const
bool ConditionalStream::lockRecord(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -146,7 +146,7 @@ void ConditionalStream::findUsedStreams(StreamList& streams, bool expandAll) con
m_second->findUsedStreams(streams, expandAll);
}
void ConditionalStream::invalidateRecords(jrd_req* request) const
void ConditionalStream::invalidateRecords(Request* request) const
{
m_first->invalidateRecords(request);
m_second->invalidateRecords(request);

16
src/jrd/recsrc/Cursor.cpp
View File

@ -35,7 +35,7 @@ namespace
{
bool validate(thread_db* tdbb)
{
const jrd_req* const request = tdbb->getRequest();
const Request* const request = tdbb->getRequest();
if (request->req_flags & req_abort)
return false;
@ -47,7 +47,7 @@ namespace
}
// Initialize dependent invariants
void initializeInvariants(jrd_req* request, const VarInvariantArray* invariants)
void initializeInvariants(Request* request, const VarInvariantArray* invariants)
{
if (invariants)
{
@ -105,7 +105,7 @@ Cursor::Cursor(CompilerScratch* csb, const RecordSource* rsb,
void Cursor::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* impure = request->getImpure<Impure>(m_impure);
impure->irsb_active = true;
@ -117,7 +117,7 @@ void Cursor::open(thread_db* tdbb) const
void Cursor::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (impure->irsb_active)
@ -135,7 +135,7 @@ bool Cursor::fetchNext(thread_db* tdbb) const
if (!validate(tdbb))
return false;
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!impure->irsb_active)
@ -207,7 +207,7 @@ bool Cursor::fetchAbsolute(thread_db* tdbb, SINT64 offset) const
if (!validate(tdbb))
return false;
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!impure->irsb_active)
@ -268,7 +268,7 @@ bool Cursor::fetchRelative(thread_db* tdbb, SINT64 offset) const
if (!validate(tdbb))
return false;
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!impure->irsb_active)
@ -335,7 +335,7 @@ bool Cursor::fetchRelative(thread_db* tdbb, SINT64 offset) const
}
// Check if the cursor is in a good state for access a field.
void Cursor::checkState(jrd_req* request) const
void Cursor::checkState(Request* request) const
{
const Impure* const impure = request->getImpure<Impure>(m_impure);

2
src/jrd/recsrc/Cursor.h
View File

@ -75,7 +75,7 @@ namespace Jrd
bool fetchAbsolute(thread_db* tdbb, SINT64 offset) const;
bool fetchRelative(thread_db* tdbb, SINT64 offset) const;
void checkState(jrd_req* request) const;
void checkState(Request* request) const;
const RecordSource* getAccessPath() const
{

6
src/jrd/recsrc/ExternalTableScan.cpp
View File

@ -47,7 +47,7 @@ ExternalTableScan::ExternalTableScan(CompilerScratch* csb, const string& alias,
void ExternalTableScan::open(thread_db* tdbb) const
{
Database* const dbb = tdbb->getDatabase();
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -65,7 +65,7 @@ void ExternalTableScan::open(thread_db* tdbb) const
void ExternalTableScan::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -79,7 +79,7 @@ bool ExternalTableScan::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
record_param* const rpb = &request->req_rpb[m_stream];
Impure* const impure = request->getImpure<Impure>(m_impure);

12
src/jrd/recsrc/FilteredStream.cpp
View File

@ -46,7 +46,7 @@ FilteredStream::FilteredStream(CompilerScratch* csb, RecordSource* next, BoolExp
void FilteredStream::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -56,7 +56,7 @@ void FilteredStream::open(thread_db* tdbb) const
void FilteredStream::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -74,7 +74,7 @@ bool FilteredStream::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -91,7 +91,7 @@ bool FilteredStream::getRecord(thread_db* tdbb) const
bool FilteredStream::refetchRecord(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
return m_next->refetchRecord(tdbb) &&
m_boolean->execute(tdbb, request);
@ -120,7 +120,7 @@ void FilteredStream::findUsedStreams(StreamList& streams, bool expandAll) const
m_next->findUsedStreams(streams, expandAll);
}
void FilteredStream::invalidateRecords(jrd_req* request) const
void FilteredStream::invalidateRecords(Request* request) const
{
m_next->invalidateRecords(request);
}
@ -132,7 +132,7 @@ void FilteredStream::nullRecords(thread_db* tdbb) const
bool FilteredStream::evaluateBoolean(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
// For ANY and ALL clauses (ALL is handled as a negated ANY),
// we must first detect them, and then make sure that the returned

8
src/jrd/recsrc/FirstRowsStream.cpp
View File

@ -46,7 +46,7 @@ FirstRowsStream::FirstRowsStream(CompilerScratch* csb, RecordSource* next, Value
void FirstRowsStream::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = 0;
@ -67,7 +67,7 @@ void FirstRowsStream::open(thread_db* tdbb) const
void FirstRowsStream::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -85,7 +85,7 @@ bool FirstRowsStream::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -130,7 +130,7 @@ void FirstRowsStream::findUsedStreams(StreamList& streams, bool expandAll) const
m_next->findUsedStreams(streams, expandAll);
}
void FirstRowsStream::invalidateRecords(jrd_req* request) const
void FirstRowsStream::invalidateRecords(Request* request) const
{
m_next->invalidateRecords(request);
}

8
src/jrd/recsrc/FullOuterJoin.cpp
View File

@ -47,7 +47,7 @@ FullOuterJoin::FullOuterJoin(CompilerScratch* csb, RecordSource* arg1, RecordSou
void FullOuterJoin::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open | irsb_first;
@ -57,7 +57,7 @@ void FullOuterJoin::open(thread_db* tdbb) const
void FullOuterJoin::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -78,7 +78,7 @@ bool FullOuterJoin::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -141,7 +141,7 @@ void FullOuterJoin::findUsedStreams(StreamList& streams, bool expandAll) const
m_arg2->findUsedStreams(streams, expandAll);
}
void FullOuterJoin::invalidateRecords(jrd_req* request) const
void FullOuterJoin::invalidateRecords(Request* request) const
{
m_arg1->invalidateRecords(request);
m_arg2->invalidateRecords(request);

6
src/jrd/recsrc/FullTableScan.cpp
View File

@ -51,7 +51,7 @@ void FullTableScan::open(thread_db* tdbb) const
{
Database* const dbb = tdbb->getDatabase();
Attachment* const attachment = tdbb->getAttachment();
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -112,7 +112,7 @@ void FullTableScan::open(thread_db* tdbb) const
void FullTableScan::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -135,7 +135,7 @@ bool FullTableScan::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
record_param* const rpb = &request->req_rpb[m_stream];
Impure* const impure = request->getImpure<Impure>(m_impure);

10
src/jrd/recsrc/HashJoin.cpp
View File

@ -283,7 +283,7 @@ HashJoin::HashJoin(thread_db* tdbb, CompilerScratch* csb, FB_SIZE_T count,
void HashJoin::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open | irsb_mustread;
@ -324,7 +324,7 @@ void HashJoin::open(thread_db* tdbb) const
void HashJoin::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
invalidateRecords(request);
@ -350,7 +350,7 @@ bool HashJoin::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -470,7 +470,7 @@ void HashJoin::findUsedStreams(StreamList& streams, bool expandAll) const
m_args[i].source->findUsedStreams(streams, expandAll);
}
void HashJoin::invalidateRecords(jrd_req* request) const
void HashJoin::invalidateRecords(Request* request) const
{
m_leader.source->invalidateRecords(request);
@ -487,7 +487,7 @@ void HashJoin::nullRecords(thread_db* tdbb) const
}
ULONG HashJoin::computeHash(thread_db* tdbb,
jrd_req* request,
Request* request,
const SubStream& sub,
UCHAR* keyBuffer) const
{

6
src/jrd/recsrc/IndexTableScan.cpp
View File

@ -61,7 +61,7 @@ IndexTableScan::IndexTableScan(CompilerScratch* csb, const string& alias,
void IndexTableScan::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_first | irsb_open;
@ -74,7 +74,7 @@ void IndexTableScan::open(thread_db* tdbb) const
void IndexTableScan::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -126,7 +126,7 @@ bool IndexTableScan::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
record_param* const rpb = &request->req_rpb[m_stream];
Impure* const impure = request->getImpure<Impure>(m_impure);

8
src/jrd/recsrc/LockedStream.cpp
View File

@ -44,7 +44,7 @@ LockedStream::LockedStream(CompilerScratch* csb, RecordSource* next)
void LockedStream::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -54,7 +54,7 @@ void LockedStream::open(thread_db* tdbb) const
void LockedStream::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -72,7 +72,7 @@ bool LockedStream::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -120,7 +120,7 @@ void LockedStream::findUsedStreams(StreamList& streams, bool expandAll) const
m_next->findUsedStreams(streams, expandAll);
}
void LockedStream::invalidateRecords(jrd_req* request) const
void LockedStream::invalidateRecords(Request* request) const
{
m_next->invalidateRecords(request);
}

14
src/jrd/recsrc/MergeJoin.cpp
View File

@ -57,7 +57,7 @@ MergeJoin::MergeJoin(CompilerScratch* csb, FB_SIZE_T count,
void MergeJoin::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -93,7 +93,7 @@ void MergeJoin::open(thread_db* tdbb) const
void MergeJoin::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -128,7 +128,7 @@ bool MergeJoin::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -371,7 +371,7 @@ void MergeJoin::findUsedStreams(StreamList& streams, bool expandAll) const
m_args[i]->findUsedStreams(streams, expandAll);
}
void MergeJoin::invalidateRecords(jrd_req* request) const
void MergeJoin::invalidateRecords(Request* request) const
{
for (FB_SIZE_T i = 0; i < m_args.getCount(); i++)
m_args[i]->invalidateRecords(request);
@ -386,7 +386,7 @@ void MergeJoin::nullRecords(thread_db* tdbb) const
int MergeJoin::compare(thread_db* tdbb, const NestValueArray* node1,
const NestValueArray* node2) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
const NestConst<ValueExprNode>* ptr1 = node1->begin();
const NestConst<ValueExprNode>* ptr2 = node2->begin();
@ -435,7 +435,7 @@ UCHAR* MergeJoin::getData(thread_db* /*tdbb*/, MergeFile* mfb, SLONG record) con
SLONG MergeJoin::getRecord(thread_db* tdbb, FB_SIZE_T index) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
const SortedStream* const sort_rsb = m_args[index];
@ -473,7 +473,7 @@ SLONG MergeJoin::getRecord(thread_db* tdbb, FB_SIZE_T index) const
bool MergeJoin::fetchRecord(thread_db* tdbb, FB_SIZE_T index) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
Impure::irsb_mrg_repeat* tail = &impure->irsb_mrg_rpt[index];

8
src/jrd/recsrc/NestedLoopJoin.cpp
View File

@ -59,7 +59,7 @@ NestedLoopJoin::NestedLoopJoin(CompilerScratch* csb, RecordSource* outer, Record
void NestedLoopJoin::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open | irsb_first | irsb_mustread;
@ -67,7 +67,7 @@ void NestedLoopJoin::open(thread_db* tdbb) const
void NestedLoopJoin::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -86,7 +86,7 @@ bool NestedLoopJoin::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -257,7 +257,7 @@ void NestedLoopJoin::findUsedStreams(StreamList& streams, bool expandAll) const
m_args[i]->findUsedStreams(streams, expandAll);
}
void NestedLoopJoin::invalidateRecords(jrd_req* request) const
void NestedLoopJoin::invalidateRecords(Request* request) const
{
for (FB_SIZE_T i = 0; i < m_args.getCount(); i++)
m_args[i]->invalidateRecords(request);

12
src/jrd/recsrc/ProcedureScan.cpp
View File

@ -64,7 +64,7 @@ void ProcedureScan::open(thread_db* tdbb) const
const_cast<jrd_prc*>(m_procedure)->checkReload(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -98,7 +98,7 @@ void ProcedureScan::open(thread_db* tdbb) const
im = NULL;
}
jrd_req* const proc_request = m_procedure->getStatement()->findRequest(tdbb);
Request* const proc_request = m_procedure->getStatement()->findRequest(tdbb);
impure->irsb_req_handle = proc_request;
// req_proc_fetch flag used only when fetching rows, so
@ -134,7 +134,7 @@ void ProcedureScan::open(thread_db* tdbb) const
void ProcedureScan::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -144,7 +144,7 @@ void ProcedureScan::close(thread_db* tdbb) const
{
impure->irsb_flags &= ~irsb_open;
jrd_req* const proc_request = impure->irsb_req_handle;
Request* const proc_request = impure->irsb_req_handle;
if (proc_request)
{
@ -166,7 +166,7 @@ bool ProcedureScan::getRecord(thread_db* tdbb) const
UserId* invoker = m_procedure->invoker ? m_procedure->invoker : tdbb->getAttachment()->att_ss_user;
AutoSetRestore<UserId*> userIdHolder(&tdbb->getAttachment()->att_ss_user, invoker);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
record_param* const rpb = &request->req_rpb[m_stream];
Impure* const impure = request->getImpure<Impure>(m_impure);
@ -185,7 +185,7 @@ bool ProcedureScan::getRecord(thread_db* tdbb) const
Record* const record = VIO_record(tdbb, rpb, m_format, tdbb->getDefaultPool());
jrd_req* const proc_request = impure->irsb_req_handle;
Request* const proc_request = impure->irsb_req_handle;
TraceProcFetch trace(tdbb, proc_request);

8
src/jrd/recsrc/RecordSource.cpp
View File

@ -188,7 +188,7 @@ RecordStream::RecordStream(CompilerScratch* csb, StreamType stream, const Format
bool RecordStream::refetchRecord(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
jrd_tra* const transaction = request->req_transaction;
record_param* const rpb = &request->req_rpb[m_stream];
@ -207,7 +207,7 @@ bool RecordStream::refetchRecord(thread_db* tdbb) const
bool RecordStream::lockRecord(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
jrd_tra* const transaction = request->req_transaction;
record_param* const rpb = &request->req_rpb[m_stream];
@ -231,7 +231,7 @@ void RecordStream::findUsedStreams(StreamList& streams, bool /*expandAll*/) cons
streams.add(m_stream);
}
void RecordStream::invalidateRecords(jrd_req* request) const
void RecordStream::invalidateRecords(Request* request) const
{
record_param* const rpb = &request->req_rpb[m_stream];
rpb->rpb_number.setValid(false);
@ -239,7 +239,7 @@ void RecordStream::invalidateRecords(jrd_req* request) const
void RecordStream::nullRecords(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
record_param* const rpb = &request->req_rpb[m_stream];
rpb->rpb_number.setValid(false);

74
src/jrd/recsrc/RecordSource.h
View File

@ -35,7 +35,7 @@
namespace Jrd
{
class thread_db;
class jrd_req;
class Request;
class jrd_prc;
class AggNode;
class BoolExprNode;
@ -68,7 +68,7 @@ namespace Jrd
bool detailed, unsigned level) const = 0;
virtual void markRecursive() = 0;
virtual void invalidateRecords(jrd_req* request) const = 0;
virtual void invalidateRecords(Request* request) const = 0;
virtual void findUsedStreams(StreamList& streams, bool expandAll = false) const = 0;
virtual void nullRecords(thread_db* tdbb) const = 0;
@ -130,7 +130,7 @@ namespace Jrd
bool lockRecord(thread_db* tdbb) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
void nullRecords(thread_db* tdbb) const override;
@ -306,7 +306,7 @@ namespace Jrd
{
struct Impure : public RecordSource::Impure
{
jrd_req* irsb_req_handle;
Request* irsb_req_handle;
UCHAR* irsb_message;
};
@ -355,7 +355,7 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
void nullRecords(thread_db* tdbb) const override;
@ -383,7 +383,7 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
void nullRecords(thread_db* tdbb) const override;
@ -413,7 +413,7 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
void nullRecords(thread_db* tdbb) const override;
@ -449,7 +449,7 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
void nullRecords(thread_db* tdbb) const override;
@ -480,7 +480,7 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
void nullRecords(thread_db* tdbb) const override;
@ -575,7 +575,7 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
void nullRecords(thread_db* tdbb) const override;
@ -598,7 +598,7 @@ namespace Jrd
bool compareKeys(const UCHAR* p, const UCHAR* q) const;
UCHAR* getData(thread_db* tdbb) const;
void mapData(thread_db* tdbb, jrd_req* request, UCHAR* data) const;
void mapData(thread_db* tdbb, Request* request, UCHAR* data) const;
bool isKey(const dsc* desc) const
{
@ -624,7 +624,7 @@ namespace Jrd
class SlidingWindow
{
public:
SlidingWindow(thread_db* aTdbb, const BaseBufferedStream* aStream, jrd_req* request,
SlidingWindow(thread_db* aTdbb, const BaseBufferedStream* aStream, Request* request,
FB_UINT64 aPartitionStart, FB_UINT64 aPartitionEnd,
FB_UINT64 aFrameStart, FB_UINT64 aFrameEnd);
~SlidingWindow();
@ -714,28 +714,28 @@ namespace Jrd
bool lockRecord(thread_db* tdbb) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
protected:
Impure* getImpure(jrd_req* request) const
Impure* getImpure(Request* request) const
{
return request->getImpure<typename ThisType::Impure>(m_impure);
}
bool evaluateGroup(thread_db* tdbb) const;
void aggInit(thread_db* tdbb, jrd_req* request, const MapNode* map) const;
bool aggPass(thread_db* tdbb, jrd_req* request,
void aggInit(thread_db* tdbb, Request* request, const MapNode* map) const;
bool aggPass(thread_db* tdbb, Request* request,
const NestValueArray& sourceList, const NestValueArray& targetList) const;
void aggExecute(thread_db* tdbb, jrd_req* request,
void aggExecute(thread_db* tdbb, Request* request,
const NestValueArray& sourceList, const NestValueArray& targetList) const;
void aggFinish(thread_db* tdbb, jrd_req* request, const MapNode* map) const;
void aggFinish(thread_db* tdbb, Request* request, const MapNode* map) const;
// Cache the values of a group/order in the impure.
template <typename AdjustFunctor>
void cacheValues(thread_db* tdbb, jrd_req* request,
void cacheValues(thread_db* tdbb, Request* request,
const NestValueArray* group, impure_value* values,
AdjustFunctor adjustFunctor) const
{
@ -761,11 +761,11 @@ namespace Jrd
}
}
int lookForChange(thread_db* tdbb, jrd_req* request,
int lookForChange(thread_db* tdbb, Request* request,
const NestValueArray* group, const SortNode* sort, impure_value* values) const;
private:
bool getNextRecord(thread_db* tdbb, jrd_req* request) const;
bool getNextRecord(thread_db* tdbb, Request* request) const;
protected:
NestConst<NextType> m_next;
@ -855,16 +855,16 @@ namespace Jrd
void nullRecords(thread_db* tdbb) const;
protected:
Impure* getImpure(jrd_req* request) const
Impure* getImpure(Request* request) const
{
return request->getImpure<Impure>(m_impure);
}
private:
const void getFrameValue(thread_db* tdbb, jrd_req* request,
const void getFrameValue(thread_db* tdbb, Request* request,
const Frame* frame, impure_value_ex* impureValue) const;
SINT64 locateFrameRange(thread_db* tdbb, jrd_req* request, Impure* impure,
SINT64 locateFrameRange(thread_db* tdbb, Request* request, Impure* impure,
const Frame* frame, const dsc* offsetDesc, SINT64 position) const;
private:
@ -893,7 +893,7 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
void nullRecords(thread_db* tdbb) const override;
@ -909,7 +909,7 @@ namespace Jrd
public:
virtual void locate(thread_db* tdbb, FB_UINT64 position) const = 0;
virtual FB_UINT64 getCount(thread_db* tdbb) const = 0;
virtual FB_UINT64 getPosition(jrd_req* request) const = 0;
virtual FB_UINT64 getPosition(Request* request) const = 0;
};
class BufferedStream : public BaseBufferedStream
@ -953,7 +953,7 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
void nullRecords(thread_db* tdbb) const override;
@ -961,7 +961,7 @@ namespace Jrd
void locate(thread_db* tdbb, FB_UINT64 position) const override;
FB_UINT64 getCount(thread_db* tdbb) const override;
FB_UINT64 getPosition(jrd_req* request) const override
FB_UINT64 getPosition(Request* request) const override
{
Impure* const impure = request->getImpure<Impure>(m_impure);
return impure->irsb_position;
@ -993,7 +993,7 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
void nullRecords(thread_db* tdbb) const override;
@ -1022,7 +1022,7 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
void nullRecords(thread_db* tdbb) const override;
@ -1071,13 +1071,13 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
void nullRecords(thread_db* tdbb) const override;
private:
ULONG computeHash(thread_db* tdbb, jrd_req* request,
ULONG computeHash(thread_db* tdbb, Request* request,
const SubStream& sub, UCHAR* buffer) const;
bool fetchRecord(thread_db* tdbb, Impure* impure, FB_SIZE_T stream) const;
@ -1131,7 +1131,7 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
void nullRecords(thread_db* tdbb) const override;
@ -1188,7 +1188,7 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
private:
@ -1229,11 +1229,11 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
private:
void cleanupLevel(jrd_req* request, Impure* impure) const;
void cleanupLevel(Request* request, Impure* impure) const;
const StreamType m_mapStream;
NestConst<RecordSource> m_root;
@ -1267,7 +1267,7 @@ namespace Jrd
bool detailed, unsigned level) const override;
void markRecursive() override;
void invalidateRecords(jrd_req* request) const override;
void invalidateRecords(Request* request) const override;
void findUsedStreams(StreamList& streams, bool expandAll = false) const override;
void nullRecords(thread_db* tdbb) const override;

10
src/jrd/recsrc/RecursiveStream.cpp
View File

@ -68,7 +68,7 @@ RecursiveStream::RecursiveStream(CompilerScratch* csb, StreamType stream, Stream
void RecursiveStream::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -96,7 +96,7 @@ void RecursiveStream::open(thread_db* tdbb) const
void RecursiveStream::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
invalidateRecords(request);
@ -119,7 +119,7 @@ bool RecursiveStream::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
record_param* const rpb = &request->req_rpb[m_stream];
Impure* const impure = request->getImpure<Impure>(m_impure);
Impure* const saveImpure = request->getImpure<Impure>(m_saveOffset);
@ -273,7 +273,7 @@ void RecursiveStream::markRecursive()
m_inner->markRecursive();
}
void RecursiveStream::invalidateRecords(jrd_req* request) const
void RecursiveStream::invalidateRecords(Request* request) const
{
m_root->invalidateRecords(request);
m_inner->invalidateRecords(request);
@ -293,7 +293,7 @@ void RecursiveStream::findUsedStreams(StreamList& streams, bool expandAll) const
}
}
void RecursiveStream::cleanupLevel(jrd_req* request, Impure* impure) const
void RecursiveStream::cleanupLevel(Request* request, Impure* impure) const
{
Impure* const saveImpure = request->getImpure<Impure>(m_saveOffset);

10
src/jrd/recsrc/SingularStream.cpp
View File

@ -44,7 +44,7 @@ SingularStream::SingularStream(CompilerScratch* csb, RecordSource* next)
void SingularStream::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -54,7 +54,7 @@ void SingularStream::open(thread_db* tdbb) const
void SingularStream::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -72,7 +72,7 @@ bool SingularStream::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -92,7 +92,7 @@ bool SingularStream::getRecord(thread_db* tdbb) const
void SingularStream::doGetRecord(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
const FB_SIZE_T streamCount = m_streams.getCount();
@ -160,7 +160,7 @@ void SingularStream::findUsedStreams(StreamList& streams, bool expandAll) const
m_next->findUsedStreams(streams, expandAll);
}
void SingularStream::invalidateRecords(jrd_req* request) const
void SingularStream::invalidateRecords(Request* request) const
{
m_next->invalidateRecords(request);
}

8
src/jrd/recsrc/SkipRowsStream.cpp
View File

@ -46,7 +46,7 @@ SkipRowsStream::SkipRowsStream(CompilerScratch* csb, RecordSource* next, ValueEx
void SkipRowsStream::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -66,7 +66,7 @@ void SkipRowsStream::open(thread_db* tdbb) const
void SkipRowsStream::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -84,7 +84,7 @@ bool SkipRowsStream::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -131,7 +131,7 @@ void SkipRowsStream::findUsedStreams(StreamList& streams, bool expandAll) const
m_next->findUsedStreams(streams, expandAll);
}
void SkipRowsStream::invalidateRecords(jrd_req* request) const
void SkipRowsStream::invalidateRecords(Request* request) const
{
m_next->invalidateRecords(request);
}

14
src/jrd/recsrc/SortedStream.cpp
View File

@ -52,7 +52,7 @@ SortedStream::SortedStream(CompilerScratch* csb, RecordSource* next, SortMap* ma
void SortedStream::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -67,7 +67,7 @@ void SortedStream::open(thread_db* tdbb) const
void SortedStream::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -88,7 +88,7 @@ bool SortedStream::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -150,7 +150,7 @@ void SortedStream::findUsedStreams(StreamList& streams, bool expandAll) const
m_next->findUsedStreams(streams, expandAll);
}
void SortedStream::invalidateRecords(jrd_req* request) const
void SortedStream::invalidateRecords(Request* request) const
{
m_next->invalidateRecords(request);
}
@ -162,7 +162,7 @@ void SortedStream::nullRecords(thread_db* tdbb) const
Sort* SortedStream::init(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
m_next->open(tdbb);
ULONG records = 0;
@ -310,7 +310,7 @@ bool SortedStream::compareKeys(const UCHAR* p, const UCHAR* q) const
UCHAR* SortedStream::getData(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
ULONG* data = nullptr;
@ -319,7 +319,7 @@ UCHAR* SortedStream::getData(thread_db* tdbb) const
return reinterpret_cast<UCHAR*>(data);
}
void SortedStream::mapData(thread_db* tdbb, jrd_req* request, UCHAR* data) const
void SortedStream::mapData(thread_db* tdbb, Request* request, UCHAR* data) const
{
StreamType stream = INVALID_STREAM;
dsc from, to;

12
src/jrd/recsrc/Union.cpp
View File

@ -61,7 +61,7 @@ Union::Union(CompilerScratch* csb, StreamType stream,
void Union::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -82,7 +82,7 @@ void Union::open(thread_db* tdbb) const
void Union::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -101,7 +101,7 @@ bool Union::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
record_param* const rpb = &request->req_rpb[m_stream];
Impure* const impure = request->getImpure<Impure>(m_impure);
@ -144,7 +144,7 @@ bool Union::getRecord(thread_db* tdbb) const
bool Union::refetchRecord(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (impure->irsb_count >= m_args.getCount())
@ -155,7 +155,7 @@ bool Union::refetchRecord(thread_db* tdbb) const
bool Union::lockRecord(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (impure->irsb_count >= m_args.getCount())
@ -197,7 +197,7 @@ void Union::markRecursive()
m_args[i]->markRecursive();
}
void Union::invalidateRecords(jrd_req* request) const
void Union::invalidateRecords(Request* request) const
{
for (FB_SIZE_T i = 0; i < m_args.getCount(); i++)
m_args[i]->invalidateRecords(request);

6
src/jrd/recsrc/VirtualTableScan.cpp
View File

@ -45,7 +45,7 @@ VirtualTableScan::VirtualTableScan(CompilerScratch* csb, const string& alias,
void VirtualTableScan::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -60,7 +60,7 @@ void VirtualTableScan::open(thread_db* tdbb) const
void VirtualTableScan::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -74,7 +74,7 @@ bool VirtualTableScan::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
record_param* const rpb = &request->req_rpb[m_stream];
Impure* const impure = request->getImpure<Impure>(m_impure);

34
src/jrd/recsrc/WindowedStream.cpp
View File

@ -61,14 +61,14 @@ namespace
void print(thread_db* tdbb, Firebird::string& plan, bool detailed, unsigned level) const;
void markRecursive();
void invalidateRecords(jrd_req* request) const;
void invalidateRecords(Request* request) const;
void findUsedStreams(StreamList& streams, bool expandAll) const;
void nullRecords(thread_db* tdbb) const;
void locate(thread_db* tdbb, FB_UINT64 position) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_position = position;
}
@ -78,7 +78,7 @@ namespace
return m_next->getCount(tdbb);
}
FB_UINT64 getPosition(jrd_req* request) const
FB_UINT64 getPosition(Request* request) const
{
Impure* const impure = request->getImpure<Impure>(m_impure);
return impure->irsb_position;
@ -98,7 +98,7 @@ namespace
void BufferedStreamWindow::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -107,7 +107,7 @@ namespace
void BufferedStreamWindow::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -119,7 +119,7 @@ namespace
bool BufferedStreamWindow::getRecord(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -158,7 +158,7 @@ namespace
m_next->findUsedStreams(streams, expandAll);
}
void BufferedStreamWindow::invalidateRecords(jrd_req* request) const
void BufferedStreamWindow::invalidateRecords(Request* request) const
{
m_next->invalidateRecords(request);
}
@ -335,7 +335,7 @@ WindowedStream::WindowedStream(thread_db* tdbb, Optimizer* opt,
void WindowedStream::open(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
impure->irsb_flags = irsb_open;
@ -346,7 +346,7 @@ void WindowedStream::open(thread_db* tdbb) const
void WindowedStream::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
invalidateRecords(request);
@ -364,7 +364,7 @@ bool WindowedStream::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (!(impure->irsb_flags & irsb_open))
@ -397,7 +397,7 @@ void WindowedStream::markRecursive()
m_joinedStream->markRecursive();
}
void WindowedStream::invalidateRecords(jrd_req* request) const
void WindowedStream::invalidateRecords(Request* request) const
{
m_joinedStream->invalidateRecords(request);
}
@ -509,7 +509,7 @@ void WindowedStream::WindowStream::open(thread_db* tdbb) const
{
BaseAggWinStream::open(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = getImpure(request);
impure->partitionBlock.startPosition = impure->partitionBlock.endPosition =
@ -533,7 +533,7 @@ void WindowedStream::WindowStream::open(thread_db* tdbb) const
void WindowedStream::WindowStream::close(thread_db* tdbb) const
{
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
Impure* const impure = request->getImpure<Impure>(m_impure);
if (impure->irsb_flags & irsb_open)
@ -546,7 +546,7 @@ bool WindowedStream::WindowStream::getRecord(thread_db* tdbb) const
{
JRD_reschedule(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
record_param* const rpb = &request->req_rpb[m_stream];
Impure* const impure = getImpure(request);
@ -893,7 +893,7 @@ void WindowedStream::WindowStream::nullRecords(thread_db* tdbb) const
m_next->nullRecords(tdbb);
}
const void WindowedStream::WindowStream::getFrameValue(thread_db* tdbb, jrd_req* request,
const void WindowedStream::WindowStream::getFrameValue(thread_db* tdbb, Request* request,
const Frame* frame, impure_value_ex* impureValue) const
{
dsc* desc = EVL_expr(tdbb, request, frame->value);
@ -928,7 +928,7 @@ const void WindowedStream::WindowStream::getFrameValue(thread_db* tdbb, jrd_req*
}
}
SINT64 WindowedStream::WindowStream::locateFrameRange(thread_db* tdbb, jrd_req* request, Impure* impure,
SINT64 WindowedStream::WindowStream::locateFrameRange(thread_db* tdbb, Request* request, Impure* impure,
const Frame* frame, const dsc* offsetDesc, SINT64 position) const
{
if (m_order->expressions.getCount() != 1)
@ -1044,7 +1044,7 @@ SINT64 WindowedStream::WindowStream::locateFrameRange(thread_db* tdbb, jrd_req*
// ------------------------------
SlidingWindow::SlidingWindow(thread_db* aTdbb, const BaseBufferedStream* aStream,
jrd_req* request,
Request* request,
FB_UINT64 aPartitionStart, FB_UINT64 aPartitionEnd,
FB_UINT64 aFrameStart, FB_UINT64 aFrameEnd)
: tdbb(aTdbb), // Note: instantiate the class only as local variable

2
src/jrd/replication/Applier.cpp
View File

@ -204,7 +204,7 @@ namespace
class LocalThreadContext
{
public:
LocalThreadContext(thread_db* tdbb, jrd_tra* tra, jrd_req* req = NULL)
LocalThreadContext(thread_db* tdbb, jrd_tra* tra, Request* req = NULL)
: m_tdbb(tdbb)
{
tdbb->setTransaction(tra);

4
src/jrd/replication/Applier.h
View File

@ -125,7 +125,7 @@ namespace Jrd
public:
Applier(Firebird::MemoryPool& pool,
const Firebird::PathName& database,
Jrd::jrd_req* request)
Jrd::Request* request)
: PermanentStorage(pool),
m_txnMap(pool), m_database(pool, database),
m_request(request), m_bitmap(FB_NEW_POOL(pool) RecordBitmap(pool)), m_record(NULL)
@ -150,7 +150,7 @@ namespace Jrd
private:
TransactionMap m_txnMap;
const Firebird::PathName m_database;
jrd_req* m_request;
Request* m_request;
Firebird::AutoPtr<RecordBitmap> m_bitmap;
Record* m_record;
JReplicator* m_interface;

14
src/jrd/req.h
View File

@ -165,7 +165,7 @@ private:
// request block
class jrd_req : public pool_alloc<type_req>
class Request : public pool_alloc<type_req>
{
private:
class TimeStampCache
@ -266,7 +266,7 @@ private:
};
public:
jrd_req(Attachment* attachment, /*const*/ Statement* aStatement,
Request(Attachment* attachment, /*const*/ Statement* aStatement,
Firebird::MemoryStats* parent_stats)
: statement(aStatement),
req_pool(statement->pool),
@ -358,10 +358,10 @@ public:
// Transaction pointer and doubly linked list pointers for requests in this
// transaction. Maintained by TRA_attach_request/TRA_detach_request.
jrd_tra* req_transaction;
jrd_req* req_tra_next;
jrd_req* req_tra_prev;
Request* req_tra_next;
Request* req_tra_prev;
jrd_req* req_caller; // Caller of this request
Request* req_caller; // Caller of this request
// This field may be used to reconstruct the whole call stack
TempBlobIdTree req_blobs; // Temporary BLOBs owned by this request
const StmtNode* req_message; // Current message for send/receive
@ -388,7 +388,7 @@ public:
Firebird::AutoPtr<Jrd::RuntimeStatistics> req_fetch_baseline; // State of request performance counters when we reported it last time
SINT64 req_fetch_elapsed; // Number of clock ticks spent while fetching rows for this request since we reported it last time
SINT64 req_fetch_rowcount; // Total number of rows returned by this request
jrd_req* req_proc_caller; // Procedure's caller request
Request* req_proc_caller; // Procedure's caller request
const ValueListNode* req_proc_inputs; // and its node with input parameters
TraNumber req_conflict_txn; // Transaction number for update conflict in read consistency mode
@ -405,7 +405,7 @@ public:
// Fields to support read consistency in READ COMMITTED transactions
struct snapshot_data
{
jrd_req* m_owner;
Request* m_owner;
SnapshotHandle m_handle;
CommitNumber m_number;

26
src/jrd/tra.cpp
View File

@ -115,10 +115,10 @@ static const UCHAR sweep_tpb[] =
};
jrd_req* TRA_get_prior_request(thread_db* tdbb)
Request* TRA_get_prior_request(thread_db* tdbb)
{
// See if there is any request right above us in the call stack
jrd_req* org_request;
Request* org_request;
thread_db* jrd_ctx = tdbb;
do
{
@ -143,7 +143,7 @@ jrd_req* TRA_get_prior_request(thread_db* tdbb)
return org_request;
}
void TRA_setup_request_snapshot(Jrd::thread_db* tdbb, Jrd::jrd_req* request)
void TRA_setup_request_snapshot(Jrd::thread_db* tdbb, Jrd::Request* request)
{
// This function is called whenever request is started in a transaction.
// Setup context to preserve read consistency in READ COMMITTED transactions.
@ -158,7 +158,7 @@ void TRA_setup_request_snapshot(Jrd::thread_db* tdbb, Jrd::jrd_req* request)
return;
// See if there is any request right above us in the call stack
jrd_req* org_request = TRA_get_prior_request(tdbb);
Request* org_request = TRA_get_prior_request(tdbb);
if (org_request && org_request->req_transaction == transaction)
{
@ -179,7 +179,7 @@ void TRA_setup_request_snapshot(Jrd::thread_db* tdbb, Jrd::jrd_req* request)
}
void TRA_release_request_snapshot(Jrd::thread_db* tdbb, Jrd::jrd_req* request)
void TRA_release_request_snapshot(Jrd::thread_db* tdbb, Jrd::Request* request)
{
// This function is called whenever request has completed processing
// in a transaction (normally or abnormally)
@ -199,7 +199,7 @@ void TRA_release_request_snapshot(Jrd::thread_db* tdbb, Jrd::jrd_req* request)
}
void TRA_attach_request(Jrd::jrd_tra* transaction, Jrd::jrd_req* request)
void TRA_attach_request(Jrd::jrd_tra* transaction, Jrd::Request* request)
{
// When request finishes normally transaction reference is not cleared.
// Then if afterwards request is restarted TRA_attach_request is called again.
@ -227,7 +227,7 @@ void TRA_attach_request(Jrd::jrd_tra* transaction, Jrd::jrd_req* request)
transaction->tra_requests = request;
}
void TRA_detach_request(Jrd::jrd_req* request)
void TRA_detach_request(Jrd::Request* request)
{
if (!request->req_transaction)
{
@ -1640,12 +1640,12 @@ int TRA_snapshot_state(thread_db* tdbb, const jrd_tra* trans, TraNumber number,
if ((trans->tra_flags & TRA_read_consistency) && state == tra_committed)
{
// GC thread accesses data directly without any request
if (jrd_req* current_request = tdbb->getRequest())
if (Request* current_request = tdbb->getRequest())
{
// Notes:
// 1) There is no request snapshot when we build expression index
// 2) Disable read committed snapshot after we encountered update conflict
jrd_req* snapshot_request = current_request->req_snapshot.m_owner;
Request* snapshot_request = current_request->req_snapshot.m_owner;
if (snapshot_request && !(snapshot_request->req_flags & req_update_conflict))
{
if (stateCn > snapshot_request->req_snapshot.m_number)
@ -2527,15 +2527,15 @@ static void restart_requests(thread_db* tdbb, jrd_tra* trans)
**************************************/
SET_TDBB(tdbb);
for (jrd_req** i = trans->tra_attachment->att_requests.begin();
for (Request** i = trans->tra_attachment->att_requests.begin();
i != trans->tra_attachment->att_requests.end();
++i)
{
Array<jrd_req*>& requests = (*i)->getStatement()->requests;
Array<Request*>& requests = (*i)->getStatement()->requests;
for (jrd_req** j = requests.begin(); j != requests.end(); ++j)
for (Request** j = requests.begin(); j != requests.end(); ++j)
{
jrd_req* request = *j;
Request* request = *j;
if (request && request->req_transaction)
{

4
src/jrd/tra.h
View File

@ -85,7 +85,7 @@ struct BlobIndex
{
ULONG bli_temp_id;
bool bli_materialized;
jrd_req* bli_request;
Request* bli_request;
union
{
bid bli_blob_id; // ID of materialized blob
@ -286,7 +286,7 @@ public:
SSHORT tra_lock_timeout; // in seconds, -1 means infinite, 0 means NOWAIT
ULONG tra_next_blob_id; // ID of the previous blob or array created in this transaction
const ISC_TIMESTAMP_TZ tra_timestamp; // transaction start time
jrd_req* tra_requests; // Doubly linked list of requests active in this transaction
Request* tra_requests; // Doubly linked list of requests active in this transaction
MonitoringSnapshot* tra_mon_snapshot; // Database state snapshot (for monitoring purposes)
RuntimeStatistics tra_stats;
Firebird::Array<DsqlCursor*> tra_open_cursors;

10
src/jrd/tra_proto.h
View File

@ -61,11 +61,11 @@ int TRA_state(const UCHAR*, TraNumber oldest, TraNumber number);
void TRA_sweep(Jrd::thread_db* tdbb);
void TRA_update_counters(Jrd::thread_db*, Jrd::Database*);
int TRA_wait(Jrd::thread_db* tdbb, Jrd::jrd_tra* trans, TraNumber number, Jrd::jrd_tra::wait_t wait);
void TRA_attach_request(Jrd::jrd_tra* transaction, Jrd::jrd_req* request);
void TRA_detach_request(Jrd::jrd_req* request);
void TRA_setup_request_snapshot(Jrd::thread_db*, Jrd::jrd_req* request);
void TRA_release_request_snapshot(Jrd::thread_db*, Jrd::jrd_req* request);
Jrd::jrd_req* TRA_get_prior_request(Jrd::thread_db*);
void TRA_attach_request(Jrd::jrd_tra* transaction, Jrd::Request* request);
void TRA_detach_request(Jrd::Request* request);
void TRA_setup_request_snapshot(Jrd::thread_db*, Jrd::Request* request);
void TRA_release_request_snapshot(Jrd::thread_db*, Jrd::Request* request);
Jrd::Request* TRA_get_prior_request(Jrd::thread_db*);
void TRA_shutdown_sweep();
#endif // JRD_TRA_PROTO_H

20
src/jrd/trace/TraceJrdHelpers.h
View File

@ -94,7 +94,7 @@ private:
class TraceProcExecute
{
public:
TraceProcExecute(thread_db* tdbb, jrd_req* request, jrd_req* caller, const ValueListNode* inputs) :
TraceProcExecute(thread_db* tdbb, Request* request, Request* caller, const ValueListNode* inputs) :
m_tdbb(tdbb),
m_request(request)
{
@ -161,14 +161,14 @@ public:
private:
bool m_need_trace;
thread_db* const m_tdbb;
jrd_req* const m_request;
Request* const m_request;
SINT64 m_start_clock;
};
class TraceProcFetch
{
public:
TraceProcFetch(thread_db* tdbb, jrd_req* request) :
TraceProcFetch(thread_db* tdbb, Request* request) :
m_tdbb(tdbb),
m_request(request)
{
@ -219,7 +219,7 @@ public:
private:
bool m_need_trace;
thread_db* const m_tdbb;
jrd_req* const m_request;
Request* const m_request;
SINT64 m_start_clock;
};
@ -227,7 +227,7 @@ private:
class TraceFuncExecute
{
public:
TraceFuncExecute(thread_db* tdbb, jrd_req* request, jrd_req* caller,
TraceFuncExecute(thread_db* tdbb, Request* request, Request* caller,
const UCHAR* inMsg, ULONG inMsgLength) :
m_tdbb(tdbb),
m_request(request),
@ -301,7 +301,7 @@ public:
private:
bool m_need_trace;
thread_db* const m_tdbb;
jrd_req* const m_request;
Request* const m_request;
const UCHAR* m_inMsg;
ULONG m_inMsgLength;
SINT64 m_start_clock;
@ -311,7 +311,7 @@ private:
class TraceTrigExecute
{
public:
TraceTrigExecute(thread_db* tdbb, jrd_req* trigger, int which_trig) :
TraceTrigExecute(thread_db* tdbb, Request* trigger, int which_trig) :
m_tdbb(tdbb),
m_request(trigger),
m_which_trig(which_trig)
@ -367,7 +367,7 @@ public:
private:
bool m_need_trace;
thread_db* const m_tdbb;
jrd_req* const m_request;
Request* const m_request;
SINT64 m_start_clock;
const int m_which_trig;
};
@ -437,7 +437,7 @@ private:
class TraceBlrExecute
{
public:
TraceBlrExecute(thread_db* tdbb, jrd_req* request) :
TraceBlrExecute(thread_db* tdbb, Request* request) :
m_tdbb(tdbb),
m_request(request)
{
@ -490,7 +490,7 @@ public:
private:
bool m_need_trace;
thread_db* const m_tdbb;
jrd_req* const m_request;
Request* const m_request;
SINT64 m_start_clock;
};

16
src/jrd/trace/TraceObjects.h
View File

@ -342,7 +342,7 @@ private:
class TraceDscFromValues : public TraceDescriptors
{
public:
TraceDscFromValues(Firebird::MemoryPool& pool, jrd_req* request, const ValueListNode* params) :
TraceDscFromValues(Firebird::MemoryPool& pool, Request* request, const ValueListNode* params) :
TraceDescriptors(pool),
m_request(request),
m_params(params)
@ -352,7 +352,7 @@ protected:
void fillParams();
private:
jrd_req* m_request;
Request* m_request;
const ValueListNode* m_params;
};
@ -402,7 +402,7 @@ class TraceProcedureImpl :
public Firebird::AutoIface<Firebird::ITraceProcedureImpl<TraceProcedureImpl, Firebird::CheckStatusWrapper> >
{
public:
TraceProcedureImpl(jrd_req* request, Firebird::PerformanceInfo* perf) :
TraceProcedureImpl(Request* request, Firebird::PerformanceInfo* perf) :
m_request(request),
m_perf(perf),
m_inputs(*getDefaultMemoryPool(), request->req_proc_caller, request->req_proc_inputs),
@ -420,7 +420,7 @@ public:
Firebird::PerformanceInfo* getPerf() { return m_perf; };
private:
jrd_req* const m_request;
Request* const m_request;
Firebird::PerformanceInfo* const m_perf;
TraceDscFromValues m_inputs;
Firebird::string m_name;
@ -431,7 +431,7 @@ class TraceFunctionImpl :
public Firebird::AutoIface<Firebird::ITraceFunctionImpl<TraceFunctionImpl, Firebird::CheckStatusWrapper> >
{
public:
TraceFunctionImpl(jrd_req* request, Firebird::ITraceParams* inputs, Firebird::PerformanceInfo* perf, const dsc* value) :
TraceFunctionImpl(Request* request, Firebird::ITraceParams* inputs, Firebird::PerformanceInfo* perf, const dsc* value) :
m_request(request),
m_perf(perf),
m_inputs(inputs),
@ -450,7 +450,7 @@ public:
Firebird::PerformanceInfo* getPerf() { return m_perf; };
private:
jrd_req* const m_request;
Request* const m_request;
Firebird::PerformanceInfo* const m_perf;
Firebird::ITraceParams* m_inputs;
TraceDscFromDsc m_value;
@ -462,7 +462,7 @@ class TraceTriggerImpl :
public Firebird::AutoIface<Firebird::ITraceTriggerImpl<TraceTriggerImpl, Firebird::CheckStatusWrapper> >
{
public:
TraceTriggerImpl(const jrd_req* trig, SSHORT which, Firebird::PerformanceInfo* perf) :
TraceTriggerImpl(const Request* trig, SSHORT which, Firebird::PerformanceInfo* perf) :
m_trig(trig),
m_which(which),
m_perf(perf)
@ -476,7 +476,7 @@ public:
Firebird::PerformanceInfo* getPerf() { return m_perf; }
private:
const jrd_req* const m_trig;
const Request* const m_trig;
const SSHORT m_which;
Firebird::PerformanceInfo* const m_perf;
};

4
src/jrd/val.h
View File

@ -55,7 +55,7 @@ namespace Jrd {
class ArrayField;
class blb;
class jrd_req;
class Request;
class jrd_tra;
// Various structures in the impure area
@ -254,7 +254,7 @@ public:
blb* arr_blob; // Blob for data access
jrd_tra* arr_transaction; // Parent transaction block
ArrayField* arr_next; // Next array in transaction
jrd_req* arr_request; // request
Request* arr_request; // request
SLONG arr_effective_length; // Length of array instance
USHORT arr_desc_length; // Length of array descriptor
ULONG arr_temp_id; // Temporary ID for open array inside the transaction

20
src/jrd/vio.cpp
View File

@ -161,7 +161,7 @@ const int PREPARE_LOCKERR = 3;
static int prepare_update(thread_db*, jrd_tra*, TraNumber commit_tid_read, record_param*,
record_param*, record_param*, PageStack&, bool);
static void protect_system_table_insert(thread_db* tdbb, const jrd_req* req, const jrd_rel* relation,
static void protect_system_table_insert(thread_db* tdbb, const Request* req, const jrd_rel* relation,
bool force_flag = false);
static void protect_system_table_delupd(thread_db* tdbb, const jrd_rel* relation, const char* operation,
bool force_flag = false);
@ -223,7 +223,7 @@ static bool assert_gc_enabled(const jrd_tra* transaction, const jrd_rel* relatio
inline void check_gbak_cheating_insupd(thread_db* tdbb, const jrd_rel* relation, const char* op)
{
const Attachment* const attachment = tdbb->getAttachment();
const jrd_req* const request = tdbb->getRequest();
const Request* const request = tdbb->getRequest();
if (relation->isSystem() && attachment->isGbak() && !(attachment->att_flags & ATT_creator) &&
!request->hasInternalStatement())
@ -1451,7 +1451,7 @@ void VIO_data(thread_db* tdbb, record_param* rpb, MemoryPool* pool)
}
static bool check_prepare_result(int prepare_result, jrd_tra* transaction, jrd_req* request, record_param* rpb)
static bool check_prepare_result(int prepare_result, jrd_tra* transaction, Request* request, record_param* rpb)
{
/**************************************
*
@ -1469,7 +1469,7 @@ static bool check_prepare_result(int prepare_result, jrd_tra* transaction, jrd_r
if (prepare_result == PREPARE_OK)
return true;
jrd_req* top_request = request->req_snapshot.m_owner;
Request* top_request = request->req_snapshot.m_owner;
const bool restart_ready = top_request &&
(top_request->req_flags & req_restart_ready);
@ -1520,7 +1520,7 @@ bool VIO_erase(thread_db* tdbb, record_param* rpb, jrd_tra* transaction)
MetaName object_name, package_name;
SET_TDBB(tdbb);
jrd_req* request = tdbb->getRequest();
Request* request = tdbb->getRequest();
jrd_rel* relation = rpb->rpb_relation;
#ifdef VIO_DEBUG
@ -3476,7 +3476,7 @@ void VIO_store(thread_db* tdbb, record_param* rpb, jrd_tra* transaction)
*
**************************************/
SET_TDBB(tdbb);
jrd_req* const request = tdbb->getRequest();
Request* const request = tdbb->getRequest();
jrd_rel* relation = rpb->rpb_relation;
DeferredWork* work = NULL;
@ -4081,7 +4081,7 @@ bool VIO_writelock(thread_db* tdbb, record_param* org_rpb, jrd_tra* transaction)
case PREPARE_DELETE:
if ((transaction->tra_flags & TRA_read_consistency))
{
jrd_req* top_request = tdbb->getRequest()->req_snapshot.m_owner;
Request* top_request = tdbb->getRequest()->req_snapshot.m_owner;
if (top_request && !(top_request->req_flags & req_update_conflict))
{
if (!(top_request->req_flags & req_restart_ready))
@ -5116,7 +5116,7 @@ static void invalidate_cursor_records(jrd_tra* transaction, record_param* mod_rp
**************************************/
fb_assert(mod_rpb && mod_rpb->rpb_relation);
for (jrd_req* request = transaction->tra_requests; request; request = request->req_tra_next)
for (Request* request = transaction->tra_requests; request; request = request->req_tra_next)
{
if (request->req_flags & req_active)
{
@ -5870,7 +5870,7 @@ static int prepare_update( thread_db* tdbb,
static void protect_system_table_insert(thread_db* tdbb,
const jrd_req* request,
const Request* request,
const jrd_rel* relation,
bool force_flag)
{
@ -5918,7 +5918,7 @@ static void protect_system_table_delupd(thread_db* tdbb,
*
**************************************/
const Attachment* const attachment = tdbb->getAttachment();
const jrd_req* const request = tdbb->getRequest();
const Request* const request = tdbb->getRequest();
if (!force_flag)
{