database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-11-10 17:42:29 +03:00
Code Activity

Phase 2 of read-only-plans project: restructure expression-tree nodes

Browse Source 
so that all executable expression nodes inherit from a common supertype
Expr.  This is somewhat of an exercise in code purity rather than any
real functional advance, but getting rid of the extra Oper or Func node
formerly used in each operator or function call should provide at least
a little space and speed improvement.
initdb forced by changes in stored-rules representation.
This commit is contained in:
Tom Lane
2002-12-12 15:49:42 +00:00
parent debb072886
commit a0bf885f9e
69 changed files with 3390 additions and 3433 deletions
Download Patch File Download Diff File Expand all files Collapse all files

522
src/backend/nodes/copyfuncs.c
View File

@@ -15,7 +15,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.229 2002/12/06 05:00:18 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.230 2002/12/12 15:49:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -563,21 +563,6 @@ _copyLimit(Limit *from)
return newnode;
}
static SubPlan *
_copySubPlan(SubPlan *from)
{
SubPlan *newnode = makeNode(SubPlan);
COPY_NODE_FIELD(plan);
COPY_SCALAR_FIELD(plan_id);
COPY_NODE_FIELD(rtable);
COPY_INTLIST_FIELD(setParam);
COPY_INTLIST_FIELD(parParam);
COPY_NODE_FIELD(sublink);
return newnode;
}
/* ****************************************************************
* primnodes.h copy functions
* ****************************************************************
@@ -603,20 +588,9 @@ _copyResdom(Resdom *from)
return newnode;
}
static Fjoin *
_copyFjoin(Fjoin *from)
{
Fjoin *newnode = makeNode(Fjoin);
COPY_SCALAR_FIELD(fj_initialized);
COPY_SCALAR_FIELD(fj_nNodes);
COPY_NODE_FIELD(fj_innerNode);
COPY_POINTER_FIELD(fj_results, from->fj_nNodes * sizeof(Datum));
COPY_POINTER_FIELD(fj_alwaysDone, from->fj_nNodes * sizeof(bool));
return newnode;
}
/*
* _copyAlias
*/
static Alias *
_copyAlias(Alias *from)
{
@@ -628,6 +602,9 @@ _copyAlias(Alias *from)
return newnode;
}
/*
* _copyRangeVar
*/
static RangeVar *
_copyRangeVar(RangeVar *from)
{
@@ -644,20 +621,11 @@ _copyRangeVar(RangeVar *from)
}
/*
* _copyExpr
* We don't need a _copyExpr because Expr is an abstract supertype which
* should never actually get instantiated. Also, since it has no common
* fields except NodeTag, there's no need for a helper routine to factor
* out copying the common fields...
*/
static Expr *
_copyExpr(Expr *from)
{
Expr *newnode = makeNode(Expr);
COPY_SCALAR_FIELD(typeOid);
COPY_SCALAR_FIELD(opType);
COPY_NODE_FIELD(oper);
COPY_NODE_FIELD(args);
return newnode;
}
/*
* _copyVar
@@ -678,25 +646,6 @@ _copyVar(Var *from)
return newnode;
}
/*
* _copyOper
*/
static Oper *
_copyOper(Oper *from)
{
Oper *newnode = makeNode(Oper);
COPY_SCALAR_FIELD(opno);
COPY_SCALAR_FIELD(opid);
COPY_SCALAR_FIELD(opresulttype);
COPY_SCALAR_FIELD(opretset);
/* Do not copy the run-time state, if any */
newnode->op_fcache = NULL;
return newnode;
}
/*
* _copyConst
*/
@@ -748,25 +697,6 @@ _copyParam(Param *from)
return newnode;
}
/*
* _copyFunc
*/
static Func *
_copyFunc(Func *from)
{
Func *newnode = makeNode(Func);
COPY_SCALAR_FIELD(funcid);
COPY_SCALAR_FIELD(funcresulttype);
COPY_SCALAR_FIELD(funcretset);
COPY_SCALAR_FIELD(funcformat);
/* Do not copy the run-time state, if any */
newnode->func_fcache = NULL;
return newnode;
}
/*
* _copyAggref
*/
@@ -780,7 +710,102 @@ _copyAggref(Aggref *from)
COPY_NODE_FIELD(target);
COPY_SCALAR_FIELD(aggstar);
COPY_SCALAR_FIELD(aggdistinct);
COPY_SCALAR_FIELD(aggno); /* probably not necessary */
COPY_SCALAR_FIELD(aggno); /* will go away soon */
return newnode;
}
/*
* _copyArrayRef
*/
static ArrayRef *
_copyArrayRef(ArrayRef *from)
{
ArrayRef *newnode = makeNode(ArrayRef);
COPY_SCALAR_FIELD(refrestype);
COPY_SCALAR_FIELD(refattrlength);
COPY_SCALAR_FIELD(refelemlength);
COPY_SCALAR_FIELD(refelembyval);
COPY_SCALAR_FIELD(refelemalign);
COPY_NODE_FIELD(refupperindexpr);
COPY_NODE_FIELD(reflowerindexpr);
COPY_NODE_FIELD(refexpr);
COPY_NODE_FIELD(refassgnexpr);
return newnode;
}
/*
* _copyFuncExpr
*/
static FuncExpr *
_copyFuncExpr(FuncExpr *from)
{
FuncExpr *newnode = makeNode(FuncExpr);
COPY_SCALAR_FIELD(funcid);
COPY_SCALAR_FIELD(funcresulttype);
COPY_SCALAR_FIELD(funcretset);
COPY_SCALAR_FIELD(funcformat);
COPY_NODE_FIELD(args);
/* Do not copy the run-time state, if any */
newnode->func_fcache = NULL;
return newnode;
}
/*
* _copyOpExpr
*/
static OpExpr *
_copyOpExpr(OpExpr *from)
{
OpExpr *newnode = makeNode(OpExpr);
COPY_SCALAR_FIELD(opno);
COPY_SCALAR_FIELD(opfuncid);
COPY_SCALAR_FIELD(opresulttype);
COPY_SCALAR_FIELD(opretset);
COPY_NODE_FIELD(args);
/* Do not copy the run-time state, if any */
newnode->op_fcache = NULL;
return newnode;
}
/*
* _copyDistinctExpr
*/
static DistinctExpr *
_copyDistinctExpr(DistinctExpr *from)
{
DistinctExpr *newnode = makeNode(DistinctExpr);
COPY_SCALAR_FIELD(opno);
COPY_SCALAR_FIELD(opfuncid);
COPY_SCALAR_FIELD(opresulttype);
COPY_SCALAR_FIELD(opretset);
COPY_NODE_FIELD(args);
/* Do not copy the run-time state, if any */
newnode->op_fcache = NULL;
return newnode;
}
/*
* _copyBoolExpr
*/
static BoolExpr *
_copyBoolExpr(BoolExpr *from)
{
BoolExpr *newnode = makeNode(BoolExpr);
COPY_SCALAR_FIELD(boolop);
COPY_NODE_FIELD(args);
return newnode;
}
@@ -802,6 +827,26 @@ _copySubLink(SubLink *from)
return newnode;
}
/*
* _copySubPlanExpr
*/
static SubPlanExpr *
_copySubPlanExpr(SubPlanExpr *from)
{
SubPlanExpr *newnode = makeNode(SubPlanExpr);
COPY_SCALAR_FIELD(typeOid);
COPY_NODE_FIELD(plan);
COPY_SCALAR_FIELD(plan_id);
COPY_NODE_FIELD(rtable);
COPY_INTLIST_FIELD(setParam);
COPY_INTLIST_FIELD(parParam);
COPY_NODE_FIELD(args);
COPY_NODE_FIELD(sublink);
return newnode;
}
/*
* _copyFieldSelect
*/
@@ -834,6 +879,112 @@ _copyRelabelType(RelabelType *from)
return newnode;
}
/*
* _copyCaseExpr
*/
static CaseExpr *
_copyCaseExpr(CaseExpr *from)
{
CaseExpr *newnode = makeNode(CaseExpr);
COPY_SCALAR_FIELD(casetype);
COPY_NODE_FIELD(arg);
COPY_NODE_FIELD(args);
COPY_NODE_FIELD(defresult);
return newnode;
}
/*
* _copyCaseWhen
*/
static CaseWhen *
_copyCaseWhen(CaseWhen *from)
{
CaseWhen *newnode = makeNode(CaseWhen);
COPY_NODE_FIELD(expr);
COPY_NODE_FIELD(result);
return newnode;
}
/*
* _copyNullTest
*/
static NullTest *
_copyNullTest(NullTest *from)
{
NullTest *newnode = makeNode(NullTest);
COPY_NODE_FIELD(arg);
COPY_SCALAR_FIELD(nulltesttype);
return newnode;
}
/*
* _copyBooleanTest
*/
static BooleanTest *
_copyBooleanTest(BooleanTest *from)
{
BooleanTest *newnode = makeNode(BooleanTest);
COPY_NODE_FIELD(arg);
COPY_SCALAR_FIELD(booltesttype);
return newnode;
}
/*
* _copyConstraintTest
*/
static ConstraintTest *
_copyConstraintTest(ConstraintTest *from)
{
ConstraintTest *newnode = makeNode(ConstraintTest);
COPY_NODE_FIELD(arg);
COPY_SCALAR_FIELD(testtype);
COPY_STRING_FIELD(name);
COPY_STRING_FIELD(domname);
COPY_NODE_FIELD(check_expr);
return newnode;
}
/*
* _copyConstraintTestValue
*/
static ConstraintTestValue *
_copyConstraintTestValue(ConstraintTestValue *from)
{
ConstraintTestValue *newnode = makeNode(ConstraintTestValue);
COPY_SCALAR_FIELD(typeId);
COPY_SCALAR_FIELD(typeMod);
return newnode;
}
/*
* _copyTargetEntry
*/
static TargetEntry *
_copyTargetEntry(TargetEntry *from)
{
TargetEntry *newnode = makeNode(TargetEntry);
COPY_NODE_FIELD(resdom);
COPY_NODE_FIELD(expr);
return newnode;
}
/*
* _copyRangeTblRef
*/
static RangeTblRef *
_copyRangeTblRef(RangeTblRef *from)
{
@@ -844,6 +995,9 @@ _copyRangeTblRef(RangeTblRef *from)
return newnode;
}
/*
* _copyJoinExpr
*/
static JoinExpr *
_copyJoinExpr(JoinExpr *from)
{
@@ -861,6 +1015,9 @@ _copyJoinExpr(JoinExpr *from)
return newnode;
}
/*
* _copyFromExpr
*/
static FromExpr *
_copyFromExpr(FromExpr *from)
{
@@ -872,24 +1029,6 @@ _copyFromExpr(FromExpr *from)
return newnode;
}
static ArrayRef *
_copyArrayRef(ArrayRef *from)
{
ArrayRef *newnode = makeNode(ArrayRef);
COPY_SCALAR_FIELD(refrestype);
COPY_SCALAR_FIELD(refattrlength);
COPY_SCALAR_FIELD(refelemlength);
COPY_SCALAR_FIELD(refelembyval);
COPY_SCALAR_FIELD(refelemalign);
COPY_NODE_FIELD(refupperindexpr);
COPY_NODE_FIELD(reflowerindexpr);
COPY_NODE_FIELD(refexpr);
COPY_NODE_FIELD(refassgnexpr);
return newnode;
}
/* ****************************************************************
* relation.h copy functions
*
@@ -964,18 +1103,6 @@ _copyJoinInfo(JoinInfo *from)
* ****************************************************************
*/
static TargetEntry *
_copyTargetEntry(TargetEntry *from)
{
TargetEntry *newnode = makeNode(TargetEntry);
COPY_NODE_FIELD(resdom);
COPY_NODE_FIELD(fjoin);
COPY_NODE_FIELD(expr);
return newnode;
}
static RangeTblEntry *
_copyRangeTblEntry(RangeTblEntry *from)
{
@@ -1170,6 +1297,14 @@ _copyTypeName(TypeName *from)
return newnode;
}
static DomainConstraintValue *
_copyDomainConstraintValue(DomainConstraintValue *from)
{
DomainConstraintValue *newnode = makeNode(DomainConstraintValue);
return newnode;
}
static SortGroupBy *
_copySortGroupBy(SortGroupBy *from)
{
@@ -1260,85 +1395,6 @@ _copyConstraint(Constraint *from)
return newnode;
}
static CaseExpr *
_copyCaseExpr(CaseExpr *from)
{
CaseExpr *newnode = makeNode(CaseExpr);
COPY_SCALAR_FIELD(casetype);
COPY_NODE_FIELD(arg);
COPY_NODE_FIELD(args);
COPY_NODE_FIELD(defresult);
return newnode;
}
static CaseWhen *
_copyCaseWhen(CaseWhen *from)
{
CaseWhen *newnode = makeNode(CaseWhen);
COPY_NODE_FIELD(expr);
COPY_NODE_FIELD(result);
return newnode;
}
static NullTest *
_copyNullTest(NullTest *from)
{
NullTest *newnode = makeNode(NullTest);
COPY_NODE_FIELD(arg);
COPY_SCALAR_FIELD(nulltesttype);
return newnode;
}
static BooleanTest *
_copyBooleanTest(BooleanTest *from)
{
BooleanTest *newnode = makeNode(BooleanTest);
COPY_NODE_FIELD(arg);
COPY_SCALAR_FIELD(booltesttype);
return newnode;
}
static ConstraintTest *
_copyConstraintTest(ConstraintTest *from)
{
ConstraintTest *newnode = makeNode(ConstraintTest);
COPY_NODE_FIELD(arg);
COPY_SCALAR_FIELD(testtype);
COPY_STRING_FIELD(name);
COPY_STRING_FIELD(domname);
COPY_NODE_FIELD(check_expr);
return newnode;
}
static DomainConstraintValue *
_copyDomainConstraintValue(DomainConstraintValue *from)
{
DomainConstraintValue *newnode = makeNode(DomainConstraintValue);
return newnode;
}
static ConstraintTestValue *
_copyConstraintTestValue(ConstraintTestValue *from)
{
ConstraintTestValue *newnode = makeNode(ConstraintTestValue);
COPY_SCALAR_FIELD(typeId);
COPY_SCALAR_FIELD(typeMod);
return newnode;
}
static DefElem *
_copyDefElem(DefElem *from)
{
@@ -2350,9 +2406,6 @@ copyObject(void *from)
case T_Limit:
retval = _copyLimit(from);
break;
case T_SubPlan:
retval = _copySubPlan(from);
break;
/*
* PRIMITIVE NODES
@@ -2360,45 +2413,72 @@ copyObject(void *from)
case T_Resdom:
retval = _copyResdom(from);
break;
case T_Fjoin:
retval = _copyFjoin(from);
break;
case T_Alias:
retval = _copyAlias(from);
break;
case T_RangeVar:
retval = _copyRangeVar(from);
break;
case T_Expr:
retval = _copyExpr(from);
break;
case T_Var:
retval = _copyVar(from);
break;
case T_Oper:
retval = _copyOper(from);
break;
case T_Const:
retval = _copyConst(from);
break;
case T_Param:
retval = _copyParam(from);
break;
case T_Func:
retval = _copyFunc(from);
break;
case T_Aggref:
retval = _copyAggref(from);
break;
case T_ArrayRef:
retval = _copyArrayRef(from);
break;
case T_FuncExpr:
retval = _copyFuncExpr(from);
break;
case T_OpExpr:
retval = _copyOpExpr(from);
break;
case T_DistinctExpr:
retval = _copyDistinctExpr(from);
break;
case T_BoolExpr:
retval = _copyBoolExpr(from);
break;
case T_SubLink:
retval = _copySubLink(from);
break;
case T_SubPlanExpr:
retval = _copySubPlanExpr(from);
break;
case T_FieldSelect:
retval = _copyFieldSelect(from);
break;
case T_RelabelType:
retval = _copyRelabelType(from);
break;
case T_CaseExpr:
retval = _copyCaseExpr(from);
break;
case T_CaseWhen:
retval = _copyCaseWhen(from);
break;
case T_NullTest:
retval = _copyNullTest(from);
break;
case T_BooleanTest:
retval = _copyBooleanTest(from);
break;
case T_ConstraintTest:
retval = _copyConstraintTest(from);
break;
case T_ConstraintTestValue:
retval = _copyConstraintTestValue(from);
break;
case T_TargetEntry:
retval = _copyTargetEntry(from);
break;
case T_RangeTblRef:
retval = _copyRangeTblRef(from);
break;
@@ -2408,9 +2488,6 @@ copyObject(void *from)
case T_FromExpr:
retval = _copyFromExpr(from);
break;
case T_ArrayRef:
retval = _copyArrayRef(from);
break;
/*
* RELATION NODES
@@ -2686,6 +2763,9 @@ copyObject(void *from)
case T_TypeCast:
retval = _copyTypeCast(from);
break;
case T_DomainConstraintValue:
retval = _copyDomainConstraintValue(from);
break;
case T_SortGroupBy:
retval = _copySortGroupBy(from);
break;
@@ -2710,9 +2790,6 @@ copyObject(void *from)
case T_DefElem:
retval = _copyDefElem(from);
break;
case T_TargetEntry:
retval = _copyTargetEntry(from);
break;
case T_RangeTblEntry:
retval = _copyRangeTblEntry(from);
break;
@@ -2722,24 +2799,6 @@ copyObject(void *from)
case T_GroupClause:
retval = _copyGroupClause(from);
break;
case T_CaseExpr:
retval = _copyCaseExpr(from);
break;
case T_CaseWhen:
retval = _copyCaseWhen(from);
break;
case T_NullTest:
retval = _copyNullTest(from);
break;
case T_BooleanTest:
retval = _copyBooleanTest(from);
break;
case T_ConstraintTest:
retval = _copyConstraintTest(from);
break;
case T_ConstraintTestValue:
retval = _copyConstraintTestValue(from);
break;
case T_FkConstraint:
retval = _copyFkConstraint(from);
break;
@@ -2752,9 +2811,6 @@ copyObject(void *from)
case T_InsertDefault:
retval = _copyInsertDefault(from);
break;
case T_DomainConstraintValue:
retval = _copyDomainConstraintValue(from);
break;
default:
elog(ERROR, "copyObject: don't know how to copy node type %d",

437
src/backend/nodes/equalfuncs.c
View File

@@ -18,7 +18,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.174 2002/12/06 05:00:18 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.175 2002/12/12 15:49:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -27,7 +27,6 @@
#include "nodes/params.h"
#include "nodes/parsenodes.h"
#include "nodes/plannodes.h"
#include "nodes/relation.h"
#include "utils/datum.h"
@@ -98,18 +97,6 @@ _equalResdom(Resdom *a, Resdom *b)
return true;
}
static bool
_equalFjoin(Fjoin *a, Fjoin *b)
{
COMPARE_SCALAR_FIELD(fj_initialized);
COMPARE_SCALAR_FIELD(fj_nNodes);
COMPARE_NODE_FIELD(fj_innerNode);
COMPARE_POINTER_FIELD(fj_results, a->fj_nNodes * sizeof(Datum));
COMPARE_POINTER_FIELD(fj_alwaysDone, a->fj_nNodes * sizeof(bool));
return true;
}
static bool
_equalAlias(Alias *a, Alias *b)
{
@@ -132,20 +119,12 @@ _equalRangeVar(RangeVar *a, RangeVar *b)
return true;
}
static bool
_equalExpr(Expr *a, Expr *b)
{
/*
* We do not examine typeOid, since the optimizer often doesn't bother
* to set it in created nodes, and it is logically a derivative of the
* oper field anyway.
*/
COMPARE_SCALAR_FIELD(opType);
COMPARE_NODE_FIELD(oper);
COMPARE_NODE_FIELD(args);
return true;
}
/*
* We don't need an _equalExpr because Expr is an abstract supertype which
* should never actually get instantiated. Also, since it has no common
* fields except NodeTag, there's no need for a helper routine to factor
* out comparing the common fields...
*/
static bool
_equalVar(Var *a, Var *b)
@@ -161,28 +140,6 @@ _equalVar(Var *a, Var *b)
return true;
}
static bool
_equalOper(Oper *a, Oper *b)
{
COMPARE_SCALAR_FIELD(opno);
COMPARE_SCALAR_FIELD(opresulttype);
COMPARE_SCALAR_FIELD(opretset);
/*
* We do not examine opid or op_fcache, since these are logically
* derived from opno, and they may not be set yet depending on how far
* along the node is in the parse/plan pipeline.
*
* (Besides, op_fcache is executor state, which we don't check --- see
* notes at head of file.)
*
* It's probably not really necessary to check opresulttype or opretset,
* either...
*/
return true;
}
static bool
_equalConst(Const *a, Const *b)
{
@@ -226,7 +183,35 @@ _equalParam(Param *a, Param *b)
}
static bool
_equalFunc(Func *a, Func *b)
_equalAggref(Aggref *a, Aggref *b)
{
COMPARE_SCALAR_FIELD(aggfnoid);
COMPARE_SCALAR_FIELD(aggtype);
COMPARE_NODE_FIELD(target);
COMPARE_SCALAR_FIELD(aggstar);
COMPARE_SCALAR_FIELD(aggdistinct);
return true;
}
static bool
_equalArrayRef(ArrayRef *a, ArrayRef *b)
{
COMPARE_SCALAR_FIELD(refrestype);
COMPARE_SCALAR_FIELD(refattrlength);
COMPARE_SCALAR_FIELD(refelemlength);
COMPARE_SCALAR_FIELD(refelembyval);
COMPARE_SCALAR_FIELD(refelemalign);
COMPARE_NODE_FIELD(refupperindexpr);
COMPARE_NODE_FIELD(reflowerindexpr);
COMPARE_NODE_FIELD(refexpr);
COMPARE_NODE_FIELD(refassgnexpr);
return true;
}
static bool
_equalFuncExpr(FuncExpr *a, FuncExpr *b)
{
COMPARE_SCALAR_FIELD(funcid);
COMPARE_SCALAR_FIELD(funcresulttype);
@@ -240,20 +225,60 @@ _equalFunc(Func *a, Func *b)
b->funcformat != COERCE_DONTCARE)
return false;
/* Note we do not look at func_fcache; see notes for _equalOper */
COMPARE_NODE_FIELD(args);
return true;
}
static bool
_equalAggref(Aggref *a, Aggref *b)
_equalOpExpr(OpExpr *a, OpExpr *b)
{
COMPARE_SCALAR_FIELD(aggfnoid);
COMPARE_SCALAR_FIELD(aggtype);
COMPARE_NODE_FIELD(target);
COMPARE_SCALAR_FIELD(aggstar);
COMPARE_SCALAR_FIELD(aggdistinct);
/* ignore aggno, which is only a private field for the executor */
COMPARE_SCALAR_FIELD(opno);
/*
* Special-case opfuncid: it is allowable for it to differ if one
* node contains zero and the other doesn't. This just means that the
* one node isn't as far along in the parse/plan pipeline and hasn't
* had the opfuncid cache filled yet.
*/
if (a->opfuncid != b->opfuncid &&
a->opfuncid != 0 &&
b->opfuncid != 0)
return false;
COMPARE_SCALAR_FIELD(opresulttype);
COMPARE_SCALAR_FIELD(opretset);
COMPARE_NODE_FIELD(args);
return true;
}
static bool
_equalDistinctExpr(DistinctExpr *a, DistinctExpr *b)
{
COMPARE_SCALAR_FIELD(opno);
/*
* Special-case opfuncid: it is allowable for it to differ if one
* node contains zero and the other doesn't. This just means that the
* one node isn't as far along in the parse/plan pipeline and hasn't
* had the opfuncid cache filled yet.
*/
if (a->opfuncid != b->opfuncid &&
a->opfuncid != 0 &&
b->opfuncid != 0)
return false;
COMPARE_SCALAR_FIELD(opresulttype);
COMPARE_SCALAR_FIELD(opretset);
COMPARE_NODE_FIELD(args);
return true;
}
static bool
_equalBoolExpr(BoolExpr *a, BoolExpr *b)
{
COMPARE_SCALAR_FIELD(boolop);
COMPARE_NODE_FIELD(args);
return true;
}
@@ -270,6 +295,21 @@ _equalSubLink(SubLink *a, SubLink *b)
return true;
}
static bool
_equalSubPlanExpr(SubPlanExpr *a, SubPlanExpr *b)
{
COMPARE_SCALAR_FIELD(typeOid);
/* should compare plans, but have to settle for comparing plan IDs */
COMPARE_SCALAR_FIELD(plan_id);
COMPARE_NODE_FIELD(rtable);
COMPARE_INTLIST_FIELD(setParam);
COMPARE_INTLIST_FIELD(parParam);
COMPARE_NODE_FIELD(args);
COMPARE_NODE_FIELD(sublink);
return true;
}
static bool
_equalFieldSelect(FieldSelect *a, FieldSelect *b)
{
@@ -299,6 +339,74 @@ _equalRelabelType(RelabelType *a, RelabelType *b)
return true;
}
static bool
_equalCaseExpr(CaseExpr *a, CaseExpr *b)
{
COMPARE_SCALAR_FIELD(casetype);
COMPARE_NODE_FIELD(arg);
COMPARE_NODE_FIELD(args);
COMPARE_NODE_FIELD(defresult);
return true;
}
static bool
_equalCaseWhen(CaseWhen *a, CaseWhen *b)
{
COMPARE_NODE_FIELD(expr);
COMPARE_NODE_FIELD(result);
return true;
}
static bool
_equalNullTest(NullTest *a, NullTest *b)
{
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(nulltesttype);
return true;
}
static bool
_equalBooleanTest(BooleanTest *a, BooleanTest *b)
{
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(booltesttype);
return true;
}
static bool
_equalConstraintTest(ConstraintTest *a, ConstraintTest *b)
{
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(testtype);
COMPARE_STRING_FIELD(name);
COMPARE_STRING_FIELD(domname);
COMPARE_NODE_FIELD(check_expr);
return true;
}
static bool
_equalConstraintTestValue(ConstraintTestValue *a, ConstraintTestValue *b)
{
COMPARE_SCALAR_FIELD(typeId);
COMPARE_SCALAR_FIELD(typeMod);
return true;
}
static bool
_equalTargetEntry(TargetEntry *a, TargetEntry *b)
{
COMPARE_NODE_FIELD(resdom);
COMPARE_NODE_FIELD(expr);
return true;
}
static bool
_equalRangeTblRef(RangeTblRef *a, RangeTblRef *b)
{
@@ -331,39 +439,6 @@ _equalFromExpr(FromExpr *a, FromExpr *b)
return true;
}
static bool
_equalArrayRef(ArrayRef *a, ArrayRef *b)
{
COMPARE_SCALAR_FIELD(refrestype);
COMPARE_SCALAR_FIELD(refattrlength);
COMPARE_SCALAR_FIELD(refelemlength);
COMPARE_SCALAR_FIELD(refelembyval);
COMPARE_SCALAR_FIELD(refelemalign);
COMPARE_NODE_FIELD(refupperindexpr);
COMPARE_NODE_FIELD(reflowerindexpr);
COMPARE_NODE_FIELD(refexpr);
COMPARE_NODE_FIELD(refassgnexpr);
return true;
}
/*
* Stuff from plannodes.h
*/
static bool
_equalSubPlan(SubPlan *a, SubPlan *b)
{
/* should compare plans, but have to settle for comparing plan IDs */
COMPARE_SCALAR_FIELD(plan_id);
COMPARE_NODE_FIELD(rtable);
COMPARE_NODE_FIELD(sublink);
return true;
}
/*
* Stuff from relation.h
@@ -573,6 +648,12 @@ _equalInsertDefault(InsertDefault *a, InsertDefault *b)
return true;
}
static bool
_equalDomainConstraintValue(DomainConstraintValue *a, DomainConstraintValue *b)
{
return true;
}
static bool
_equalClosePortalStmt(ClosePortalStmt *a, ClosePortalStmt *b)
{
@@ -1340,16 +1421,6 @@ _equalDefElem(DefElem *a, DefElem *b)
return true;
}
static bool
_equalTargetEntry(TargetEntry *a, TargetEntry *b)
{
COMPARE_NODE_FIELD(resdom);
COMPARE_NODE_FIELD(fjoin);
COMPARE_NODE_FIELD(expr);
return true;
}
static bool
_equalRangeTblEntry(RangeTblEntry *a, RangeTblEntry *b)
{
@@ -1397,71 +1468,6 @@ _equalFkConstraint(FkConstraint *a, FkConstraint *b)
return true;
}
static bool
_equalCaseExpr(CaseExpr *a, CaseExpr *b)
{
COMPARE_SCALAR_FIELD(casetype);
COMPARE_NODE_FIELD(arg);
COMPARE_NODE_FIELD(args);
COMPARE_NODE_FIELD(defresult);
return true;
}
static bool
_equalCaseWhen(CaseWhen *a, CaseWhen *b)
{
COMPARE_NODE_FIELD(expr);
COMPARE_NODE_FIELD(result);
return true;
}
static bool
_equalNullTest(NullTest *a, NullTest *b)
{
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(nulltesttype);
return true;
}
static bool
_equalBooleanTest(BooleanTest *a, BooleanTest *b)
{
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(booltesttype);
return true;
}
static bool
_equalConstraintTest(ConstraintTest *a, ConstraintTest *b)
{
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(testtype);
COMPARE_STRING_FIELD(name);
COMPARE_STRING_FIELD(domname);
COMPARE_NODE_FIELD(check_expr);
return true;
}
static bool
_equalDomainConstraintValue(DomainConstraintValue *a, DomainConstraintValue *b)
{
return true;
}
static bool
_equalConstraintTestValue(ConstraintTestValue *a, ConstraintTestValue *b)
{
COMPARE_SCALAR_FIELD(typeId);
COMPARE_SCALAR_FIELD(typeMod);
return true;
}
/*
* Stuff from pg_list.h
@@ -1519,25 +1525,21 @@ equal(void *a, void *b)
switch (nodeTag(a))
{
case T_SubPlan:
retval = _equalSubPlan(a, b);
break;
/*
* PRIMITIVE NODES
*/
case T_Resdom:
retval = _equalResdom(a, b);
break;
case T_Fjoin:
retval = _equalFjoin(a, b);
case T_Alias:
retval = _equalAlias(a, b);
break;
case T_Expr:
retval = _equalExpr(a, b);
case T_RangeVar:
retval = _equalRangeVar(a, b);
break;
case T_Var:
retval = _equalVar(a, b);
break;
case T_Oper:
retval = _equalOper(a, b);
break;
case T_Const:
retval = _equalConst(a, b);
break;
@@ -1547,21 +1549,54 @@ equal(void *a, void *b)
case T_Aggref:
retval = _equalAggref(a, b);
break;
case T_ArrayRef:
retval = _equalArrayRef(a, b);
break;
case T_FuncExpr:
retval = _equalFuncExpr(a, b);
break;
case T_OpExpr:
retval = _equalOpExpr(a, b);
break;
case T_DistinctExpr:
retval = _equalDistinctExpr(a, b);
break;
case T_BoolExpr:
retval = _equalBoolExpr(a, b);
break;
case T_SubLink:
retval = _equalSubLink(a, b);
break;
case T_Func:
retval = _equalFunc(a, b);
case T_SubPlanExpr:
retval = _equalSubPlanExpr(a, b);
break;
case T_FieldSelect:
retval = _equalFieldSelect(a, b);
break;
case T_ArrayRef:
retval = _equalArrayRef(a, b);
break;
case T_RelabelType:
retval = _equalRelabelType(a, b);
break;
case T_CaseExpr:
retval = _equalCaseExpr(a, b);
break;
case T_CaseWhen:
retval = _equalCaseWhen(a, b);
break;
case T_NullTest:
retval = _equalNullTest(a, b);
break;
case T_BooleanTest:
retval = _equalBooleanTest(a, b);
break;
case T_ConstraintTest:
retval = _equalConstraintTest(a, b);
break;
case T_ConstraintTestValue:
retval = _equalConstraintTestValue(a, b);
break;
case T_TargetEntry:
retval = _equalTargetEntry(a, b);
break;
case T_RangeTblRef:
retval = _equalRangeTblRef(a, b);
break;
@@ -1572,6 +1607,9 @@ equal(void *a, void *b)
retval = _equalJoinExpr(a, b);
break;
/*
* RELATION NODES
*/
case T_PathKeyItem:
retval = _equalPathKeyItem(a, b);
break;
@@ -1582,6 +1620,9 @@ equal(void *a, void *b)
retval = _equalJoinInfo(a, b);
break;
/*
* LIST NODES
*/
case T_List:
{
List *la = (List *) a;
@@ -1612,6 +1653,9 @@ equal(void *a, void *b)
retval = _equalValue(a, b);
break;
/*
* PARSE NODES
*/
case T_Query:
retval = _equalQuery(a, b);
break;
@@ -1844,12 +1888,6 @@ equal(void *a, void *b)
case T_SortGroupBy:
retval = _equalSortGroupBy(a, b);
break;
case T_Alias:
retval = _equalAlias(a, b);
break;
case T_RangeVar:
retval = _equalRangeVar(a, b);
break;
case T_RangeSubselect:
retval = _equalRangeSubselect(a, b);
break;
@@ -1871,9 +1909,6 @@ equal(void *a, void *b)
case T_DefElem:
retval = _equalDefElem(a, b);
break;
case T_TargetEntry:
retval = _equalTargetEntry(a, b);
break;
case T_RangeTblEntry:
retval = _equalRangeTblEntry(a, b);
break;
@@ -1884,24 +1919,6 @@ equal(void *a, void *b)
/* GroupClause is equivalent to SortClause */
retval = _equalSortClause(a, b);
break;
case T_CaseExpr:
retval = _equalCaseExpr(a, b);
break;
case T_CaseWhen:
retval = _equalCaseWhen(a, b);
break;
case T_NullTest:
retval = _equalNullTest(a, b);
break;
case T_BooleanTest:
retval = _equalBooleanTest(a, b);
break;
case T_ConstraintTest:
retval = _equalConstraintTest(a, b);
break;
case T_ConstraintTestValue:
retval = _equalConstraintTestValue(a, b);
break;
case T_FkConstraint:
retval = _equalFkConstraint(a, b);
break;

49
src/backend/nodes/makefuncs.c
View File

@@ -1,4 +1,5 @@
/*
/*-------------------------------------------------------------------------
*
* makefuncs.c
* creator functions for primitive nodes. The functions here are for
* the most frequently created nodes.
@@ -8,7 +9,9 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/nodes/makefuncs.c,v 1.36 2002/11/25 21:29:36 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/nodes/makefuncs.c,v 1.37 2002/12/12 15:49:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
@@ -49,30 +52,9 @@ makeSimpleA_Expr(int oper, const char *name,
return a;
}
/*
* makeOper -
* creates an Oper node
*/
Oper *
makeOper(Oid opno,
Oid opid,
Oid opresulttype,
bool opretset)
{
Oper *oper = makeNode(Oper);
oper->opno = opno;
oper->opid = opid;
oper->opresulttype = opresulttype;
oper->opretset = opretset;
oper->op_fcache = NULL;
return oper;
}
/*
* makeVar -
* creates a Var node
*
*/
Var *
makeVar(Index varno,
@@ -104,10 +86,10 @@ makeVar(Index varno,
/*
* makeTargetEntry -
* creates a TargetEntry node(contains a Resdom)
* creates a TargetEntry node (contains a Resdom)
*/
TargetEntry *
makeTargetEntry(Resdom *resdom, Node *expr)
makeTargetEntry(Resdom *resdom, Expr *expr)
{
TargetEntry *rt = makeNode(TargetEntry);
@@ -188,6 +170,21 @@ makeNullConst(Oid consttype)
typByVal);
}
/*
* makeBoolExpr -
* creates a BoolExpr node
*/
Expr *
makeBoolExpr(BoolExprType boolop, List *args)
{
BoolExpr *b = makeNode(BoolExpr);
b->boolop = boolop;
b->args = args;
return (Expr *) b;
}
/*
* makeAlias -
* creates an Alias node
@@ -210,7 +207,7 @@ makeAlias(const char *aliasname, List *colnames)
* creates a RelabelType node
*/
RelabelType *
makeRelabelType(Node *arg, Oid rtype, int32 rtypmod, CoercionForm rformat)
makeRelabelType(Expr *arg, Oid rtype, int32 rtypmod, CoercionForm rformat)
{
RelabelType *r = makeNode(RelabelType);

47
src/backend/nodes/nodeFuncs.c
View File

@@ -8,12 +8,10 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/nodes/nodeFuncs.c,v 1.19 2002/09/02 02:47:02 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/nodes/nodeFuncs.c,v 1.20 2002/12/12 15:49:28 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "nodes/nodeFuncs.h"
@@ -21,6 +19,7 @@
static bool var_is_inner(Var *var);
/*
* single_node -
* Returns t if node corresponds to a single-noded expression
@@ -79,41 +78,15 @@ var_is_rel(Var *var)
*****************************************************************************/
/*
* replace_opid -
*
* Given a oper node, resets the opfid field with the
* procedure OID (regproc id).
*
* Returns the modified oper node.
* set_opfuncid -
*
* Set the opfuncid (procedure OID) in an OpExpr node,
* if it hasn't been set already.
*/
Oper *
replace_opid(Oper *oper)
void
set_opfuncid(OpExpr *opexpr)
{
oper->opid = get_opcode(oper->opno);
oper->op_fcache = NULL;
return oper;
if (opexpr->opfuncid == InvalidOid)
opexpr->opfuncid = get_opcode(opexpr->opno);
opexpr->op_fcache = NULL; /* XXX will go away soon */
}
/*****************************************************************************
* constant (CONST, PARAM) nodes
*****************************************************************************/
#ifdef NOT_USED
/*
* non_null -
* Returns t if the node is a non-null constant, e.g., if the node has a
* valid `constvalue' field.
*/
bool
non_null(Expr *c)
{
if (IsA(c, Const) &&
!((Const *) c)->constisnull)
return true;
else
return false;
}
#endif

1051
src/backend/nodes/outfuncs.c
View File

File diff suppressed because it is too large Load Diff

6
src/backend/nodes/print.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/nodes/print.c,v 1.57 2002/09/04 20:31:20 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/nodes/print.c,v 1.58 2002/12/12 15:49:28 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
@@ -371,7 +371,7 @@ print_expr(Node *expr, List *rtable)
char *opname;
print_expr((Node *) get_leftop(e), rtable);
opname = get_opname(((Oper *) e->oper)->opno);
opname = get_opname(((OpExpr *) e)->opno);
printf(" %s ", ((opname != NULL) ? opname : "(invalid operator)"));
print_expr((Node *) get_rightop(e), rtable);
}
@@ -432,7 +432,7 @@ print_tl(List *tlist, List *rtable)
printf("(%d):\t", tle->resdom->reskey);
else
printf(" :\t");
print_expr(tle->expr, rtable);
print_expr((Node *) tle->expr, rtable);
printf("\n");
}
printf(")\n");

466
src/backend/nodes/readfuncs.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.140 2002/11/25 21:29:38 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.141 2002/12/12 15:49:28 tgl Exp $
*
* NOTES
* Path and Plan nodes do not have any readfuncs support, because we
@@ -302,38 +302,30 @@ _readResdom(void)
READ_DONE();
}
/*
* _readExpr
*/
static Expr *
_readExpr(void)
static Alias *
_readAlias(void)
{
READ_LOCALS(Expr);
READ_LOCALS(Alias);
READ_OID_FIELD(typeOid);
READ_STRING_FIELD(aliasname);
READ_NODE_FIELD(colnames);
/* do-it-yourself enum representation */
token = pg_strtok(&length); /* skip :opType */
token = pg_strtok(&length); /* get field value */
if (strncmp(token, "op", 2) == 0)
local_node->opType = OP_EXPR;
else if (strncmp(token, "distinct", 8) == 0)
local_node->opType = DISTINCT_EXPR;
else if (strncmp(token, "func", 4) == 0)
local_node->opType = FUNC_EXPR;
else if (strncmp(token, "or", 2) == 0)
local_node->opType = OR_EXPR;
else if (strncmp(token, "and", 3) == 0)
local_node->opType = AND_EXPR;
else if (strncmp(token, "not", 3) == 0)
local_node->opType = NOT_EXPR;
else if (strncmp(token, "subp", 4) == 0)
local_node->opType = SUBPLAN_EXPR;
else
elog(ERROR, "_readExpr: unknown opType \"%.*s\"", length, token);
READ_DONE();
}
READ_NODE_FIELD(oper);
READ_NODE_FIELD(args);
static RangeVar *
_readRangeVar(void)
{
READ_LOCALS(RangeVar);
local_node->catalogname = NULL; /* not currently saved in output
* format */
READ_STRING_FIELD(schemaname);
READ_STRING_FIELD(relname);
READ_ENUM_FIELD(inhOpt, InhOption);
READ_BOOL_FIELD(istemp);
READ_NODE_FIELD(alias);
READ_DONE();
}
@@ -357,27 +349,6 @@ _readVar(void)
READ_DONE();
}
/*
* _readArrayRef
*/
static ArrayRef *
_readArrayRef(void)
{
READ_LOCALS(ArrayRef);
READ_OID_FIELD(refrestype);
READ_INT_FIELD(refattrlength);
READ_INT_FIELD(refelemlength);
READ_BOOL_FIELD(refelembyval);
READ_CHAR_FIELD(refelemalign);
READ_NODE_FIELD(refupperindexpr);
READ_NODE_FIELD(reflowerindexpr);
READ_NODE_FIELD(refexpr);
READ_NODE_FIELD(refassgnexpr);
READ_DONE();
}
/*
* _readConst
*/
@@ -400,42 +371,6 @@ _readConst(void)
READ_DONE();
}
/*
* _readFunc
*/
static Func *
_readFunc(void)
{
READ_LOCALS(Func);
READ_OID_FIELD(funcid);
READ_OID_FIELD(funcresulttype);
READ_BOOL_FIELD(funcretset);
READ_ENUM_FIELD(funcformat, CoercionForm);
local_node->func_fcache = NULL;
READ_DONE();
}
/*
* _readOper
*/
static Oper *
_readOper(void)
{
READ_LOCALS(Oper);
READ_OID_FIELD(opno);
READ_OID_FIELD(opid);
READ_OID_FIELD(opresulttype);
READ_BOOL_FIELD(opretset);
local_node->op_fcache = NULL;
READ_DONE();
}
/*
* _readParam
*/
@@ -465,24 +400,129 @@ _readAggref(void)
READ_NODE_FIELD(target);
READ_BOOL_FIELD(aggstar);
READ_BOOL_FIELD(aggdistinct);
/* aggno is not saved since it is just executor state */
READ_DONE();
}
static RangeVar *
_readRangeVar(void)
/*
* _readArrayRef
*/
static ArrayRef *
_readArrayRef(void)
{
READ_LOCALS(RangeVar);
READ_LOCALS(ArrayRef);
local_node->catalogname = NULL; /* not currently saved in output
* format */
READ_OID_FIELD(refrestype);
READ_INT_FIELD(refattrlength);
READ_INT_FIELD(refelemlength);
READ_BOOL_FIELD(refelembyval);
READ_CHAR_FIELD(refelemalign);
READ_NODE_FIELD(refupperindexpr);
READ_NODE_FIELD(reflowerindexpr);
READ_NODE_FIELD(refexpr);
READ_NODE_FIELD(refassgnexpr);
READ_STRING_FIELD(schemaname);
READ_STRING_FIELD(relname);
READ_ENUM_FIELD(inhOpt, InhOption);
READ_BOOL_FIELD(istemp);
READ_NODE_FIELD(alias);
READ_DONE();
}
/*
* _readFuncExpr
*/
static FuncExpr *
_readFuncExpr(void)
{
READ_LOCALS(FuncExpr);
READ_OID_FIELD(funcid);
READ_OID_FIELD(funcresulttype);
READ_BOOL_FIELD(funcretset);
READ_ENUM_FIELD(funcformat, CoercionForm);
READ_NODE_FIELD(args);
local_node->func_fcache = NULL;
READ_DONE();
}
/*
* _readOpExpr
*/
static OpExpr *
_readOpExpr(void)
{
READ_LOCALS(OpExpr);
READ_OID_FIELD(opno);
READ_OID_FIELD(opfuncid);
/*
* The opfuncid is stored in the textual format primarily for debugging
* and documentation reasons. We want to always read it as zero to force
* it to be re-looked-up in the pg_operator entry. This ensures that
* stored rules don't have hidden dependencies on operators' functions.
* (We don't currently support an ALTER OPERATOR command, but might
* someday.)
*/
local_node->opfuncid = InvalidOid;
READ_OID_FIELD(opresulttype);
READ_BOOL_FIELD(opretset);
READ_NODE_FIELD(args);
local_node->op_fcache = NULL;
READ_DONE();
}
/*
* _readDistinctExpr
*/
static DistinctExpr *
_readDistinctExpr(void)
{
READ_LOCALS(DistinctExpr);
READ_OID_FIELD(opno);
READ_OID_FIELD(opfuncid);
/*
* The opfuncid is stored in the textual format primarily for debugging
* and documentation reasons. We want to always read it as zero to force
* it to be re-looked-up in the pg_operator entry. This ensures that
* stored rules don't have hidden dependencies on operators' functions.
* (We don't currently support an ALTER OPERATOR command, but might
* someday.)
*/
local_node->opfuncid = InvalidOid;
READ_OID_FIELD(opresulttype);
READ_BOOL_FIELD(opretset);
READ_NODE_FIELD(args);
local_node->op_fcache = NULL;
READ_DONE();
}
/*
* _readBoolExpr
*/
static BoolExpr *
_readBoolExpr(void)
{
READ_LOCALS(BoolExpr);
/* do-it-yourself enum representation */
token = pg_strtok(&length); /* skip :boolop */
token = pg_strtok(&length); /* get field value */
if (strncmp(token, "and", 3) == 0)
local_node->boolop = AND_EXPR;
else if (strncmp(token, "or", 2) == 0)
local_node->boolop = OR_EXPR;
else if (strncmp(token, "not", 3) == 0)
local_node->boolop = NOT_EXPR;
else
elog(ERROR, "_readBoolExpr: unknown boolop \"%.*s\"", length, token);
READ_NODE_FIELD(args);
READ_DONE();
}
@@ -504,6 +544,10 @@ _readSubLink(void)
READ_DONE();
}
/*
* _readSubPlanExpr is not needed since it doesn't appear in stored rules.
*/
/*
* _readFieldSelect
*/
@@ -536,58 +580,6 @@ _readRelabelType(void)
READ_DONE();
}
/*
* _readRangeTblRef
*/
static RangeTblRef *
_readRangeTblRef(void)
{
READ_LOCALS(RangeTblRef);
READ_INT_FIELD(rtindex);
READ_DONE();
}
/*
* _readJoinExpr
*/
static JoinExpr *
_readJoinExpr(void)
{
READ_LOCALS(JoinExpr);
READ_ENUM_FIELD(jointype, JoinType);
READ_BOOL_FIELD(isNatural);
READ_NODE_FIELD(larg);
READ_NODE_FIELD(rarg);
READ_NODE_FIELD(using);
READ_NODE_FIELD(quals);
READ_NODE_FIELD(alias);
READ_INT_FIELD(rtindex);
READ_DONE();
}
/*
* _readFromExpr
*/
static FromExpr *
_readFromExpr(void)
{
READ_LOCALS(FromExpr);
READ_NODE_FIELD(fromlist);
READ_NODE_FIELD(quals);
READ_DONE();
}
/*
* Stuff from parsenodes.h.
*/
/*
* _readCaseExpr
*/
@@ -663,17 +655,6 @@ _readConstraintTest(void)
READ_DONE();
}
/*
* _readDomainConstraintValue
*/
static DomainConstraintValue *
_readDomainConstraintValue(void)
{
READ_LOCALS_NO_FIELDS(DomainConstraintValue);
READ_DONE();
}
/*
* _readConstraintTestValue
*/
@@ -697,12 +678,63 @@ _readTargetEntry(void)
READ_LOCALS(TargetEntry);
READ_NODE_FIELD(resdom);
/* fjoin not supported ... */
READ_NODE_FIELD(expr);
READ_DONE();
}
/*
* _readRangeTblRef
*/
static RangeTblRef *
_readRangeTblRef(void)
{
READ_LOCALS(RangeTblRef);
READ_INT_FIELD(rtindex);
READ_DONE();
}
/*
* _readJoinExpr
*/
static JoinExpr *
_readJoinExpr(void)
{
READ_LOCALS(JoinExpr);
READ_ENUM_FIELD(jointype, JoinType);
READ_BOOL_FIELD(isNatural);
READ_NODE_FIELD(larg);
READ_NODE_FIELD(rarg);
READ_NODE_FIELD(using);
READ_NODE_FIELD(quals);
READ_NODE_FIELD(alias);
READ_INT_FIELD(rtindex);
READ_DONE();
}
/*
* _readFromExpr
*/
static FromExpr *
_readFromExpr(void)
{
READ_LOCALS(FromExpr);
READ_NODE_FIELD(fromlist);
READ_NODE_FIELD(quals);
READ_DONE();
}
/*
* Stuff from parsenodes.h.
*/
static ColumnRef *
_readColumnRef(void)
{
@@ -760,13 +792,13 @@ _readExprFieldSelect(void)
READ_DONE();
}
static Alias *
_readAlias(void)
/*
* _readDomainConstraintValue
*/
static DomainConstraintValue *
_readDomainConstraintValue(void)
{
READ_LOCALS(Alias);
READ_STRING_FIELD(aliasname);
READ_NODE_FIELD(colnames);
READ_LOCALS_NO_FIELDS(DomainConstraintValue);
READ_DONE();
}
@@ -835,53 +867,7 @@ parseNodeString(void)
#define MATCH(tokname, namelen) \
(length == namelen && strncmp(token, tokname, namelen) == 0)
if (MATCH("AGGREF", 6))
return_value = _readAggref();
else if (MATCH("SUBLINK", 7))
return_value = _readSubLink();
else if (MATCH("FIELDSELECT", 11))
return_value = _readFieldSelect();
else if (MATCH("RELABELTYPE", 11))
return_value = _readRelabelType();
else if (MATCH("RANGETBLREF", 11))
return_value = _readRangeTblRef();
else if (MATCH("FROMEXPR", 8))
return_value = _readFromExpr();
else if (MATCH("JOINEXPR", 8))
return_value = _readJoinExpr();
else if (MATCH("RESDOM", 6))
return_value = _readResdom();
else if (MATCH("EXPR", 4))
return_value = _readExpr();
else if (MATCH("ARRAYREF", 8))
return_value = _readArrayRef();
else if (MATCH("VAR", 3))
return_value = _readVar();
else if (MATCH("CONST", 5))
return_value = _readConst();
else if (MATCH("FUNC", 4))
return_value = _readFunc();
else if (MATCH("OPER", 4))
return_value = _readOper();
else if (MATCH("PARAM", 5))
return_value = _readParam();
else if (MATCH("TARGETENTRY", 11))
return_value = _readTargetEntry();
else if (MATCH("RANGEVAR", 8))
return_value = _readRangeVar();
else if (MATCH("COLUMNREF", 9))
return_value = _readColumnRef();
else if (MATCH("COLUMNDEF", 9))
return_value = _readColumnDef();
else if (MATCH("TYPENAME", 8))
return_value = _readTypeName();
else if (MATCH("EXPRFIELDSELECT", 15))
return_value = _readExprFieldSelect();
else if (MATCH("ALIAS", 5))
return_value = _readAlias();
else if (MATCH("RTE", 3))
return_value = _readRangeTblEntry();
else if (MATCH("QUERY", 5))
if (MATCH("QUERY", 5))
return_value = _readQuery();
else if (MATCH("NOTIFY", 6))
return_value = _readNotifyStmt();
@@ -891,6 +877,36 @@ parseNodeString(void)
return_value = _readGroupClause();
else if (MATCH("SETOPERATIONSTMT", 16))
return_value = _readSetOperationStmt();
else if (MATCH("RESDOM", 6))
return_value = _readResdom();
else if (MATCH("ALIAS", 5))
return_value = _readAlias();
else if (MATCH("RANGEVAR", 8))
return_value = _readRangeVar();
else if (MATCH("VAR", 3))
return_value = _readVar();
else if (MATCH("CONST", 5))
return_value = _readConst();
else if (MATCH("PARAM", 5))
return_value = _readParam();
else if (MATCH("AGGREF", 6))
return_value = _readAggref();
else if (MATCH("ARRAYREF", 8))
return_value = _readArrayRef();
else if (MATCH("FUNCEXPR", 8))
return_value = _readFuncExpr();
else if (MATCH("OPEXPR", 6))
return_value = _readOpExpr();
else if (MATCH("DISTINCTEXPR", 12))
return_value = _readDistinctExpr();
else if (MATCH("BOOLEXPR", 8))
return_value = _readBoolExpr();
else if (MATCH("SUBLINK", 7))
return_value = _readSubLink();
else if (MATCH("FIELDSELECT", 11))
return_value = _readFieldSelect();
else if (MATCH("RELABELTYPE", 11))
return_value = _readRelabelType();
else if (MATCH("CASE", 4))
return_value = _readCaseExpr();
else if (MATCH("WHEN", 4))
@@ -901,10 +917,28 @@ parseNodeString(void)
return_value = _readBooleanTest();
else if (MATCH("CONSTRAINTTEST", 14))
return_value = _readConstraintTest();
else if (MATCH("DOMAINCONSTRAINTVALUE", 21))
return_value = _readDomainConstraintValue();
else if (MATCH("CONSTRAINTTESTVALUE", 19))
return_value = _readConstraintTestValue();
else if (MATCH("TARGETENTRY", 11))
return_value = _readTargetEntry();
else if (MATCH("RANGETBLREF", 11))
return_value = _readRangeTblRef();
else if (MATCH("JOINEXPR", 8))
return_value = _readJoinExpr();
else if (MATCH("FROMEXPR", 8))
return_value = _readFromExpr();
else if (MATCH("COLUMNREF", 9))
return_value = _readColumnRef();
else if (MATCH("COLUMNDEF", 9))
return_value = _readColumnDef();
else if (MATCH("TYPENAME", 8))
return_value = _readTypeName();
else if (MATCH("EXPRFIELDSELECT", 15))
return_value = _readExprFieldSelect();
else if (MATCH("DOMAINCONSTRAINTVALUE", 21))
return_value = _readDomainConstraintValue();
else if (MATCH("RTE", 3))
return_value = _readRangeTblEntry();
else
{
elog(ERROR, "badly formatted node string \"%.32s\"...", token);