diff options
Diffstat (limited to 'src/backend/nodes')
| -rw-r--r-- | src/backend/nodes/copyfuncs.c | 510 | ||||
| -rw-r--r-- | src/backend/nodes/equalfuncs.c | 435 | ||||
| -rw-r--r-- | src/backend/nodes/makefuncs.c | 49 | ||||
| -rw-r--r-- | src/backend/nodes/nodeFuncs.c | 47 | ||||
| -rw-r--r-- | src/backend/nodes/outfuncs.c | 1039 | ||||
| -rw-r--r-- | src/backend/nodes/print.c | 6 | ||||
| -rw-r--r-- | src/backend/nodes/readfuncs.c | 458 |
7 files changed, 1319 insertions, 1225 deletions
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c index a978e233e3d..f7aa8fcb7ec 100644 --- a/src/backend/nodes/copyfuncs.c +++ b/src/backend/nodes/copyfuncs.c @@ -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 @@ -679,25 +647,6 @@ _copyVar(Var *from) } /* - * _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 */ static Const * @@ -749,17 +698,57 @@ _copyParam(Param *from) } /* - * _copyFunc + * _copyAggref */ -static Func * -_copyFunc(Func *from) +static Aggref * +_copyAggref(Aggref *from) { - Func *newnode = makeNode(Func); + Aggref *newnode = makeNode(Aggref); + + COPY_SCALAR_FIELD(aggfnoid); + COPY_SCALAR_FIELD(aggtype); + COPY_NODE_FIELD(target); + COPY_SCALAR_FIELD(aggstar); + COPY_SCALAR_FIELD(aggdistinct); + 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; @@ -768,19 +757,55 @@ _copyFunc(Func *from) } /* - * _copyAggref + * _copyOpExpr */ -static Aggref * -_copyAggref(Aggref *from) +static OpExpr * +_copyOpExpr(OpExpr *from) { - Aggref *newnode = makeNode(Aggref); + OpExpr *newnode = makeNode(OpExpr); - COPY_SCALAR_FIELD(aggfnoid); - COPY_SCALAR_FIELD(aggtype); - COPY_NODE_FIELD(target); - COPY_SCALAR_FIELD(aggstar); - COPY_SCALAR_FIELD(aggdistinct); - COPY_SCALAR_FIELD(aggno); /* probably not necessary */ + 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; } @@ -803,6 +828,26 @@ _copySubLink(SubLink *from) } /* + * _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 */ static FieldSelect * @@ -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", diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c index 71227097104..3b510382068 100644 --- a/src/backend/nodes/equalfuncs.c +++ b/src/backend/nodes/equalfuncs.c @@ -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" @@ -99,18 +98,6 @@ _equalResdom(Resdom *a, Resdom *b) } 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) { COMPARE_STRING_FIELD(aliasname); @@ -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) @@ -162,28 +141,6 @@ _equalVar(Var *a, Var *b) } 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) { COMPARE_SCALAR_FIELD(consttype); @@ -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; } @@ -271,6 +296,21 @@ _equalSubLink(SubLink *a, SubLink *b) } 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) { COMPARE_NODE_FIELD(arg); @@ -300,66 +340,101 @@ _equalRelabelType(RelabelType *a, RelabelType *b) } static bool -_equalRangeTblRef(RangeTblRef *a, RangeTblRef *b) +_equalCaseExpr(CaseExpr *a, CaseExpr *b) { - COMPARE_SCALAR_FIELD(rtindex); + COMPARE_SCALAR_FIELD(casetype); + COMPARE_NODE_FIELD(arg); + COMPARE_NODE_FIELD(args); + COMPARE_NODE_FIELD(defresult); return true; } static bool -_equalJoinExpr(JoinExpr *a, JoinExpr *b) +_equalCaseWhen(CaseWhen *a, CaseWhen *b) { - COMPARE_SCALAR_FIELD(jointype); - COMPARE_SCALAR_FIELD(isNatural); - COMPARE_NODE_FIELD(larg); - COMPARE_NODE_FIELD(rarg); - COMPARE_NODE_FIELD(using); - COMPARE_NODE_FIELD(quals); - COMPARE_NODE_FIELD(alias); - COMPARE_SCALAR_FIELD(rtindex); + COMPARE_NODE_FIELD(expr); + COMPARE_NODE_FIELD(result); return true; } static bool -_equalFromExpr(FromExpr *a, FromExpr *b) +_equalNullTest(NullTest *a, NullTest *b) { - COMPARE_NODE_FIELD(fromlist); - COMPARE_NODE_FIELD(quals); + COMPARE_NODE_FIELD(arg); + COMPARE_SCALAR_FIELD(nulltesttype); return true; } static bool -_equalArrayRef(ArrayRef *a, ArrayRef *b) +_equalBooleanTest(BooleanTest *a, BooleanTest *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); + 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); -/* - * Stuff from plannodes.h - */ + return true; +} static bool -_equalSubPlan(SubPlan *a, SubPlan *b) +_equalConstraintTestValue(ConstraintTestValue *a, ConstraintTestValue *b) { - /* should compare plans, but have to settle for comparing plan IDs */ - COMPARE_SCALAR_FIELD(plan_id); + COMPARE_SCALAR_FIELD(typeId); + COMPARE_SCALAR_FIELD(typeMod); - COMPARE_NODE_FIELD(rtable); - COMPARE_NODE_FIELD(sublink); + 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) +{ + COMPARE_SCALAR_FIELD(rtindex); + + return true; +} + +static bool +_equalJoinExpr(JoinExpr *a, JoinExpr *b) +{ + COMPARE_SCALAR_FIELD(jointype); + COMPARE_SCALAR_FIELD(isNatural); + COMPARE_NODE_FIELD(larg); + COMPARE_NODE_FIELD(rarg); + COMPARE_NODE_FIELD(using); + COMPARE_NODE_FIELD(quals); + COMPARE_NODE_FIELD(alias); + COMPARE_SCALAR_FIELD(rtindex); + + return true; +} + +static bool +_equalFromExpr(FromExpr *a, FromExpr *b) +{ + COMPARE_NODE_FIELD(fromlist); + COMPARE_NODE_FIELD(quals); return true; } @@ -574,6 +649,12 @@ _equalInsertDefault(InsertDefault *a, InsertDefault *b) } static bool +_equalDomainConstraintValue(DomainConstraintValue *a, DomainConstraintValue *b) +{ + return true; +} + +static bool _equalClosePortalStmt(ClosePortalStmt *a, ClosePortalStmt *b) { COMPARE_STRING_FIELD(portalname); @@ -1341,16 +1422,6 @@ _equalDefElem(DefElem *a, DefElem *b) } 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) { COMPARE_SCALAR_FIELD(rtekind); @@ -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; diff --git a/src/backend/nodes/makefuncs.c b/src/backend/nodes/makefuncs.c index a97a6df2fda..de13e943d5e 100644 --- a/src/backend/nodes/makefuncs.c +++ b/src/backend/nodes/makefuncs.c @@ -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" @@ -50,29 +53,8 @@ makeSimpleA_Expr(int oper, const char *name, } /* - * 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); @@ -189,6 +171,21 @@ makeNullConst(Oid consttype) } /* + * 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); diff --git a/src/backend/nodes/nodeFuncs.c b/src/backend/nodes/nodeFuncs.c index f2bfb0a7d2d..299c910cc3b 100644 --- a/src/backend/nodes/nodeFuncs.c +++ b/src/backend/nodes/nodeFuncs.c @@ -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 diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c index 2c254001eec..bd44816e6fa 100644 --- a/src/backend/nodes/outfuncs.c +++ b/src/backend/nodes/outfuncs.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.186 2002/12/05 15:50:35 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.187 2002/12/12 15:49:28 tgl Exp $ * * NOTES * Every node type that can appear in stored rules' parsetrees *must* @@ -99,9 +99,9 @@ #define booltostr(x) ((x) ? "true" : "false") -static void _outDatum(StringInfo str, Datum value, int typlen, bool typbyval); static void _outNode(StringInfo str, void *obj); + /* * _outToken * Convert an ordinary string (eg, an identifier) into a form that @@ -172,196 +172,41 @@ _outOidList(StringInfo str, List *list) appendStringInfoChar(str, ')'); } +/* + * Print the value of a Datum given its type. + */ static void -_outCreateStmt(StringInfo str, CreateStmt *node) -{ - WRITE_NODE_TYPE("CREATE"); - - WRITE_NODE_FIELD(relation); - WRITE_NODE_FIELD(tableElts); - WRITE_NODE_FIELD(inhRelations); - WRITE_NODE_FIELD(constraints); - WRITE_BOOL_FIELD(hasoids); - WRITE_ENUM_FIELD(oncommit, OnCommitAction); -} - -static void -_outIndexStmt(StringInfo str, IndexStmt *node) -{ - WRITE_NODE_TYPE("INDEX"); - - WRITE_STRING_FIELD(idxname); - WRITE_NODE_FIELD(relation); - WRITE_STRING_FIELD(accessMethod); - WRITE_NODE_FIELD(indexParams); - WRITE_NODE_FIELD(whereClause); - WRITE_NODE_FIELD(rangetable); - WRITE_BOOL_FIELD(unique); - WRITE_BOOL_FIELD(primary); - WRITE_BOOL_FIELD(isconstraint); -} - -static void -_outNotifyStmt(StringInfo str, NotifyStmt *node) -{ - WRITE_NODE_TYPE("NOTIFY"); - - WRITE_NODE_FIELD(relation); -} - -static void -_outSelectStmt(StringInfo str, SelectStmt *node) -{ - WRITE_NODE_TYPE("SELECT"); - - /* XXX this is pretty durn incomplete */ - WRITE_NODE_FIELD(whereClause); -} - -static void -_outFuncCall(StringInfo str, FuncCall *node) -{ - WRITE_NODE_TYPE("FUNCCALL"); - - WRITE_NODE_FIELD(funcname); - WRITE_NODE_FIELD(args); - WRITE_BOOL_FIELD(agg_star); - WRITE_BOOL_FIELD(agg_distinct); -} - -static void -_outColumnDef(StringInfo str, ColumnDef *node) -{ - WRITE_NODE_TYPE("COLUMNDEF"); - - WRITE_STRING_FIELD(colname); - WRITE_NODE_FIELD(typename); - WRITE_INT_FIELD(inhcount); - WRITE_BOOL_FIELD(is_local); - WRITE_BOOL_FIELD(is_not_null); - WRITE_NODE_FIELD(raw_default); - WRITE_STRING_FIELD(cooked_default); - WRITE_NODE_FIELD(constraints); - WRITE_NODE_FIELD(support); -} - -static void -_outTypeName(StringInfo str, TypeName *node) -{ - WRITE_NODE_TYPE("TYPENAME"); - - WRITE_NODE_FIELD(names); - WRITE_OID_FIELD(typeid); - WRITE_BOOL_FIELD(timezone); - WRITE_BOOL_FIELD(setof); - WRITE_BOOL_FIELD(pct_type); - WRITE_INT_FIELD(typmod); - WRITE_NODE_FIELD(arrayBounds); -} - -static void -_outTypeCast(StringInfo str, TypeCast *node) -{ - WRITE_NODE_TYPE("TYPECAST"); - - WRITE_NODE_FIELD(arg); - WRITE_NODE_FIELD(typename); -} - -static void -_outIndexElem(StringInfo str, IndexElem *node) -{ - WRITE_NODE_TYPE("INDEXELEM"); - - WRITE_STRING_FIELD(name); - WRITE_NODE_FIELD(funcname); - WRITE_NODE_FIELD(args); - WRITE_NODE_FIELD(opclass); -} - -static void -_outQuery(StringInfo str, Query *node) +_outDatum(StringInfo str, Datum value, int typlen, bool typbyval) { - WRITE_NODE_TYPE("QUERY"); + Size length, + i; + char *s; - WRITE_ENUM_FIELD(commandType, CmdType); - WRITE_ENUM_FIELD(querySource, QuerySource); + length = datumGetSize(value, typbyval, typlen); - /* - * Hack to work around missing outfuncs routines for a lot of the - * utility-statement node types. (The only one we actually *need* for - * rules support is NotifyStmt.) Someday we ought to support 'em all, - * but for the meantime do this to avoid getting lots of warnings when - * running with debug_print_parse on. - */ - if (node->utilityStmt) + if (typbyval) { - switch (nodeTag(node->utilityStmt)) + s = (char *) (&value); + appendStringInfo(str, "%u [ ", (unsigned int) length); + for (i = 0; i < (Size) sizeof(Datum); i++) + appendStringInfo(str, "%d ", (int) (s[i])); + appendStringInfo(str, "]"); + } + else + { + s = (char *) DatumGetPointer(value); + if (!PointerIsValid(s)) + appendStringInfo(str, "0 [ ]"); + else { - case T_CreateStmt: - case T_IndexStmt: - case T_NotifyStmt: - WRITE_NODE_FIELD(utilityStmt); - break; - default: - appendStringInfo(str, " :utilityStmt ?"); - break; + appendStringInfo(str, "%u [ ", (unsigned int) length); + for (i = 0; i < length; i++) + appendStringInfo(str, "%d ", (int) (s[i])); + appendStringInfo(str, "]"); } } - else - appendStringInfo(str, " :utilityStmt <>"); - - WRITE_INT_FIELD(resultRelation); - WRITE_NODE_FIELD(into); - WRITE_BOOL_FIELD(isPortal); - WRITE_BOOL_FIELD(isBinary); - WRITE_BOOL_FIELD(hasAggs); - WRITE_BOOL_FIELD(hasSubLinks); - WRITE_NODE_FIELD(rtable); - WRITE_NODE_FIELD(jointree); - WRITE_INTLIST_FIELD(rowMarks); - WRITE_NODE_FIELD(targetList); - WRITE_NODE_FIELD(groupClause); - WRITE_NODE_FIELD(havingQual); - WRITE_NODE_FIELD(distinctClause); - WRITE_NODE_FIELD(sortClause); - WRITE_NODE_FIELD(limitOffset); - WRITE_NODE_FIELD(limitCount); - WRITE_NODE_FIELD(setOperations); - WRITE_INTLIST_FIELD(resultRelations); - - /* planner-internal fields are not written out */ } -static void -_outSortClause(StringInfo str, SortClause *node) -{ - WRITE_NODE_TYPE("SORTCLAUSE"); - - WRITE_UINT_FIELD(tleSortGroupRef); - WRITE_OID_FIELD(sortop); -} - -static void -_outGroupClause(StringInfo str, GroupClause *node) -{ - WRITE_NODE_TYPE("GROUPCLAUSE"); - - WRITE_UINT_FIELD(tleSortGroupRef); - WRITE_OID_FIELD(sortop); -} - -static void -_outSetOperationStmt(StringInfo str, SetOperationStmt *node) -{ - WRITE_NODE_TYPE("SETOPERATIONSTMT"); - - WRITE_ENUM_FIELD(op, SetOperation); - WRITE_BOOL_FIELD(all); - WRITE_NODE_FIELD(larg); - WRITE_NODE_FIELD(rarg); - WRITE_OIDLIST_FIELD(colTypes); -} /* * Stuff from plannodes.h @@ -631,19 +476,6 @@ _outHash(StringInfo str, Hash *node) WRITE_NODE_FIELD(hashkeys); } -static void -_outSubPlan(StringInfo str, SubPlan *node) -{ - WRITE_NODE_TYPE("SUBPLAN"); - - WRITE_NODE_FIELD(plan); - WRITE_INT_FIELD(plan_id); - WRITE_NODE_FIELD(rtable); - WRITE_INTLIST_FIELD(setParam); - WRITE_INTLIST_FIELD(parParam); - WRITE_NODE_FIELD(sublink); -} - /***************************************************************************** * * Stuff from primnodes.h. @@ -666,44 +498,28 @@ _outResdom(StringInfo str, Resdom *node) } static void -_outExpr(StringInfo str, Expr *node) +_outAlias(StringInfo str, Alias *node) { - char *opstr = NULL; - - WRITE_NODE_TYPE("EXPR"); + WRITE_NODE_TYPE("ALIAS"); - WRITE_OID_FIELD(typeOid); + WRITE_STRING_FIELD(aliasname); + WRITE_NODE_FIELD(colnames); +} - /* do-it-yourself enum representation */ - switch (node->opType) - { - case OP_EXPR: - opstr = "op"; - break; - case DISTINCT_EXPR: - opstr = "distinct"; - break; - case FUNC_EXPR: - opstr = "func"; - break; - case OR_EXPR: - opstr = "or"; - break; - case AND_EXPR: - opstr = "and"; - break; - case NOT_EXPR: - opstr = "not"; - break; - case SUBPLAN_EXPR: - opstr = "subp"; - break; - } - appendStringInfo(str, " :opType "); - _outToken(str, opstr); +static void +_outRangeVar(StringInfo str, RangeVar *node) +{ + WRITE_NODE_TYPE("RANGEVAR"); - WRITE_NODE_FIELD(oper); - WRITE_NODE_FIELD(args); + /* + * we deliberately ignore catalogname here, since it is presently not + * semantically meaningful + */ + WRITE_STRING_FIELD(schemaname); + WRITE_STRING_FIELD(relname); + WRITE_ENUM_FIELD(inhOpt, InhOption); + WRITE_BOOL_FIELD(istemp); + WRITE_NODE_FIELD(alias); } static void @@ -738,6 +554,17 @@ _outConst(StringInfo str, Const *node) } static void +_outParam(StringInfo str, Param *node) +{ + WRITE_NODE_TYPE("PARAM"); + + WRITE_INT_FIELD(paramkind); + WRITE_INT_FIELD(paramid); + WRITE_STRING_FIELD(paramname); + WRITE_OID_FIELD(paramtype); +} + +static void _outAggref(StringInfo str, Aggref *node) { WRITE_NODE_TYPE("AGGREF"); @@ -747,19 +574,6 @@ _outAggref(StringInfo str, Aggref *node) WRITE_NODE_FIELD(target); WRITE_BOOL_FIELD(aggstar); WRITE_BOOL_FIELD(aggdistinct); - /* aggno is not saved since it is just executor state */ -} - -static void -_outSubLink(StringInfo str, SubLink *node) -{ - WRITE_NODE_TYPE("SUBLINK"); - - WRITE_ENUM_FIELD(subLinkType, SubLinkType); - WRITE_BOOL_FIELD(useor); - WRITE_NODE_FIELD(lefthand); - WRITE_NODE_FIELD(oper); - WRITE_NODE_FIELD(subselect); } static void @@ -779,36 +593,92 @@ _outArrayRef(StringInfo str, ArrayRef *node) } static void -_outFunc(StringInfo str, Func *node) +_outFuncExpr(StringInfo str, FuncExpr *node) { - WRITE_NODE_TYPE("FUNC"); + WRITE_NODE_TYPE("FUNCEXPR"); WRITE_OID_FIELD(funcid); WRITE_OID_FIELD(funcresulttype); WRITE_BOOL_FIELD(funcretset); WRITE_ENUM_FIELD(funcformat, CoercionForm); + WRITE_NODE_FIELD(args); } static void -_outOper(StringInfo str, Oper *node) +_outOpExpr(StringInfo str, OpExpr *node) { - WRITE_NODE_TYPE("OPER"); + WRITE_NODE_TYPE("OPEXPR"); WRITE_OID_FIELD(opno); - WRITE_OID_FIELD(opid); + WRITE_OID_FIELD(opfuncid); WRITE_OID_FIELD(opresulttype); WRITE_BOOL_FIELD(opretset); + WRITE_NODE_FIELD(args); } static void -_outParam(StringInfo str, Param *node) +_outDistinctExpr(StringInfo str, DistinctExpr *node) { - WRITE_NODE_TYPE("PARAM"); + WRITE_NODE_TYPE("DISTINCTEXPR"); - WRITE_INT_FIELD(paramkind); - WRITE_INT_FIELD(paramid); - WRITE_STRING_FIELD(paramname); - WRITE_OID_FIELD(paramtype); + WRITE_OID_FIELD(opno); + WRITE_OID_FIELD(opfuncid); + WRITE_OID_FIELD(opresulttype); + WRITE_BOOL_FIELD(opretset); + WRITE_NODE_FIELD(args); +} + +static void +_outBoolExpr(StringInfo str, BoolExpr *node) +{ + char *opstr = NULL; + + WRITE_NODE_TYPE("BOOLEXPR"); + + /* do-it-yourself enum representation */ + switch (node->boolop) + { + case AND_EXPR: + opstr = "and"; + break; + case OR_EXPR: + opstr = "or"; + break; + case NOT_EXPR: + opstr = "not"; + break; + } + appendStringInfo(str, " :boolop "); + _outToken(str, opstr); + + WRITE_NODE_FIELD(args); +} + +static void +_outSubLink(StringInfo str, SubLink *node) +{ + WRITE_NODE_TYPE("SUBLINK"); + + WRITE_ENUM_FIELD(subLinkType, SubLinkType); + WRITE_BOOL_FIELD(useor); + WRITE_NODE_FIELD(lefthand); + WRITE_NODE_FIELD(oper); + WRITE_NODE_FIELD(subselect); +} + +static void +_outSubPlanExpr(StringInfo str, SubPlanExpr *node) +{ + WRITE_NODE_TYPE("SUBPLANEXPR"); + + WRITE_OID_FIELD(typeOid); + WRITE_NODE_FIELD(plan); + WRITE_INT_FIELD(plan_id); + WRITE_NODE_FIELD(rtable); + WRITE_INTLIST_FIELD(setParam); + WRITE_INTLIST_FIELD(parParam); + WRITE_NODE_FIELD(args); + WRITE_NODE_FIELD(sublink); } static void @@ -834,35 +704,62 @@ _outRelabelType(StringInfo str, RelabelType *node) } static void -_outRangeTblRef(StringInfo str, RangeTblRef *node) +_outCaseExpr(StringInfo str, CaseExpr *node) { - WRITE_NODE_TYPE("RANGETBLREF"); + WRITE_NODE_TYPE("CASE"); - WRITE_INT_FIELD(rtindex); + WRITE_OID_FIELD(casetype); + WRITE_NODE_FIELD(arg); + WRITE_NODE_FIELD(args); + WRITE_NODE_FIELD(defresult); } static void -_outJoinExpr(StringInfo str, JoinExpr *node) +_outCaseWhen(StringInfo str, CaseWhen *node) { - WRITE_NODE_TYPE("JOINEXPR"); + WRITE_NODE_TYPE("WHEN"); - WRITE_ENUM_FIELD(jointype, JoinType); - WRITE_BOOL_FIELD(isNatural); - WRITE_NODE_FIELD(larg); - WRITE_NODE_FIELD(rarg); - WRITE_NODE_FIELD(using); - WRITE_NODE_FIELD(quals); - WRITE_NODE_FIELD(alias); - WRITE_INT_FIELD(rtindex); + WRITE_NODE_FIELD(expr); + WRITE_NODE_FIELD(result); } static void -_outFromExpr(StringInfo str, FromExpr *node) +_outNullTest(StringInfo str, NullTest *node) { - WRITE_NODE_TYPE("FROMEXPR"); + WRITE_NODE_TYPE("NULLTEST"); - WRITE_NODE_FIELD(fromlist); - WRITE_NODE_FIELD(quals); + WRITE_NODE_FIELD(arg); + WRITE_ENUM_FIELD(nulltesttype, NullTestType); +} + +static void +_outBooleanTest(StringInfo str, BooleanTest *node) +{ + WRITE_NODE_TYPE("BOOLEANTEST"); + + WRITE_NODE_FIELD(arg); + WRITE_ENUM_FIELD(booltesttype, BoolTestType); +} + +static void +_outConstraintTest(StringInfo str, ConstraintTest *node) +{ + WRITE_NODE_TYPE("CONSTRAINTTEST"); + + WRITE_NODE_FIELD(arg); + WRITE_ENUM_FIELD(testtype, ConstraintTestType); + WRITE_STRING_FIELD(name); + WRITE_STRING_FIELD(domname); + WRITE_NODE_FIELD(check_expr); +} + +static void +_outConstraintTestValue(StringInfo str, ConstraintTestValue *node) +{ + WRITE_NODE_TYPE("CONSTRAINTTESTVALUE"); + + WRITE_OID_FIELD(typeId); + WRITE_INT_FIELD(typeMod); } static void @@ -871,58 +768,47 @@ _outTargetEntry(StringInfo str, TargetEntry *node) WRITE_NODE_TYPE("TARGETENTRY"); WRITE_NODE_FIELD(resdom); - /* fjoin not supported ... */ WRITE_NODE_FIELD(expr); } static void -_outAlias(StringInfo str, Alias *node) +_outRangeTblRef(StringInfo str, RangeTblRef *node) { - WRITE_NODE_TYPE("ALIAS"); + WRITE_NODE_TYPE("RANGETBLREF"); - WRITE_STRING_FIELD(aliasname); - WRITE_NODE_FIELD(colnames); + WRITE_INT_FIELD(rtindex); } static void -_outRangeTblEntry(StringInfo str, RangeTblEntry *node) +_outJoinExpr(StringInfo str, JoinExpr *node) { - WRITE_NODE_TYPE("RTE"); + WRITE_NODE_TYPE("JOINEXPR"); - /* put alias + eref first to make dump more legible */ + WRITE_ENUM_FIELD(jointype, JoinType); + WRITE_BOOL_FIELD(isNatural); + WRITE_NODE_FIELD(larg); + WRITE_NODE_FIELD(rarg); + WRITE_NODE_FIELD(using); + WRITE_NODE_FIELD(quals); WRITE_NODE_FIELD(alias); - WRITE_NODE_FIELD(eref); - WRITE_ENUM_FIELD(rtekind, RTEKind); + WRITE_INT_FIELD(rtindex); +} - switch (node->rtekind) - { - case RTE_RELATION: - case RTE_SPECIAL: - WRITE_OID_FIELD(relid); - break; - case RTE_SUBQUERY: - WRITE_NODE_FIELD(subquery); - break; - case RTE_FUNCTION: - WRITE_NODE_FIELD(funcexpr); - WRITE_NODE_FIELD(coldeflist); - break; - case RTE_JOIN: - WRITE_ENUM_FIELD(jointype, JoinType); - WRITE_NODE_FIELD(joinaliasvars); - break; - default: - elog(ERROR, "bogus rte kind %d", (int) node->rtekind); - break; - } +static void +_outFromExpr(StringInfo str, FromExpr *node) +{ + WRITE_NODE_TYPE("FROMEXPR"); - WRITE_BOOL_FIELD(inh); - WRITE_BOOL_FIELD(inFromCl); - WRITE_BOOL_FIELD(checkForRead); - WRITE_BOOL_FIELD(checkForWrite); - WRITE_OID_FIELD(checkAsUser); + WRITE_NODE_FIELD(fromlist); + WRITE_NODE_FIELD(quals); } +/***************************************************************************** + * + * Stuff from relation.h. + * + *****************************************************************************/ + /* * print the basic stuff of all nodes that inherit from Path * @@ -1078,39 +964,240 @@ _outJoinInfo(StringInfo str, JoinInfo *node) WRITE_NODE_FIELD(jinfo_restrictinfo); } -/* - * Print the value of a Datum given its type. - */ +/***************************************************************************** + * + * Stuff from parsenodes.h. + * + *****************************************************************************/ + static void -_outDatum(StringInfo str, Datum value, int typlen, bool typbyval) +_outCreateStmt(StringInfo str, CreateStmt *node) { - Size length, - i; - char *s; + WRITE_NODE_TYPE("CREATE"); - length = datumGetSize(value, typbyval, typlen); + WRITE_NODE_FIELD(relation); + WRITE_NODE_FIELD(tableElts); + WRITE_NODE_FIELD(inhRelations); + WRITE_NODE_FIELD(constraints); + WRITE_BOOL_FIELD(hasoids); + WRITE_ENUM_FIELD(oncommit, OnCommitAction); +} - if (typbyval) +static void +_outIndexStmt(StringInfo str, IndexStmt *node) +{ + WRITE_NODE_TYPE("INDEX"); + + WRITE_STRING_FIELD(idxname); + WRITE_NODE_FIELD(relation); + WRITE_STRING_FIELD(accessMethod); + WRITE_NODE_FIELD(indexParams); + WRITE_NODE_FIELD(whereClause); + WRITE_NODE_FIELD(rangetable); + WRITE_BOOL_FIELD(unique); + WRITE_BOOL_FIELD(primary); + WRITE_BOOL_FIELD(isconstraint); +} + +static void +_outNotifyStmt(StringInfo str, NotifyStmt *node) +{ + WRITE_NODE_TYPE("NOTIFY"); + + WRITE_NODE_FIELD(relation); +} + +static void +_outSelectStmt(StringInfo str, SelectStmt *node) +{ + WRITE_NODE_TYPE("SELECT"); + + /* XXX this is pretty durn incomplete */ + WRITE_NODE_FIELD(whereClause); +} + +static void +_outFuncCall(StringInfo str, FuncCall *node) +{ + WRITE_NODE_TYPE("FUNCCALL"); + + WRITE_NODE_FIELD(funcname); + WRITE_NODE_FIELD(args); + WRITE_BOOL_FIELD(agg_star); + WRITE_BOOL_FIELD(agg_distinct); +} + +static void +_outColumnDef(StringInfo str, ColumnDef *node) +{ + WRITE_NODE_TYPE("COLUMNDEF"); + + WRITE_STRING_FIELD(colname); + WRITE_NODE_FIELD(typename); + WRITE_INT_FIELD(inhcount); + WRITE_BOOL_FIELD(is_local); + WRITE_BOOL_FIELD(is_not_null); + WRITE_NODE_FIELD(raw_default); + WRITE_STRING_FIELD(cooked_default); + WRITE_NODE_FIELD(constraints); + WRITE_NODE_FIELD(support); +} + +static void +_outTypeName(StringInfo str, TypeName *node) +{ + WRITE_NODE_TYPE("TYPENAME"); + + WRITE_NODE_FIELD(names); + WRITE_OID_FIELD(typeid); + WRITE_BOOL_FIELD(timezone); + WRITE_BOOL_FIELD(setof); + WRITE_BOOL_FIELD(pct_type); + WRITE_INT_FIELD(typmod); + WRITE_NODE_FIELD(arrayBounds); +} + +static void +_outTypeCast(StringInfo str, TypeCast *node) +{ + WRITE_NODE_TYPE("TYPECAST"); + + WRITE_NODE_FIELD(arg); + WRITE_NODE_FIELD(typename); +} + +static void +_outIndexElem(StringInfo str, IndexElem *node) +{ + WRITE_NODE_TYPE("INDEXELEM"); + + WRITE_STRING_FIELD(name); + WRITE_NODE_FIELD(funcname); + WRITE_NODE_FIELD(args); + WRITE_NODE_FIELD(opclass); +} + +static void +_outQuery(StringInfo str, Query *node) +{ + WRITE_NODE_TYPE("QUERY"); + + WRITE_ENUM_FIELD(commandType, CmdType); + WRITE_ENUM_FIELD(querySource, QuerySource); + + /* + * Hack to work around missing outfuncs routines for a lot of the + * utility-statement node types. (The only one we actually *need* for + * rules support is NotifyStmt.) Someday we ought to support 'em all, + * but for the meantime do this to avoid getting lots of warnings when + * running with debug_print_parse on. + */ + if (node->utilityStmt) { - s = (char *) (&value); - appendStringInfo(str, "%u [ ", (unsigned int) length); - for (i = 0; i < (Size) sizeof(Datum); i++) - appendStringInfo(str, "%d ", (int) (s[i])); - appendStringInfo(str, "]"); + switch (nodeTag(node->utilityStmt)) + { + case T_CreateStmt: + case T_IndexStmt: + case T_NotifyStmt: + WRITE_NODE_FIELD(utilityStmt); + break; + default: + appendStringInfo(str, " :utilityStmt ?"); + break; + } } else + appendStringInfo(str, " :utilityStmt <>"); + + WRITE_INT_FIELD(resultRelation); + WRITE_NODE_FIELD(into); + WRITE_BOOL_FIELD(isPortal); + WRITE_BOOL_FIELD(isBinary); + WRITE_BOOL_FIELD(hasAggs); + WRITE_BOOL_FIELD(hasSubLinks); + WRITE_NODE_FIELD(rtable); + WRITE_NODE_FIELD(jointree); + WRITE_INTLIST_FIELD(rowMarks); + WRITE_NODE_FIELD(targetList); + WRITE_NODE_FIELD(groupClause); + WRITE_NODE_FIELD(havingQual); + WRITE_NODE_FIELD(distinctClause); + WRITE_NODE_FIELD(sortClause); + WRITE_NODE_FIELD(limitOffset); + WRITE_NODE_FIELD(limitCount); + WRITE_NODE_FIELD(setOperations); + WRITE_INTLIST_FIELD(resultRelations); + + /* planner-internal fields are not written out */ +} + +static void +_outSortClause(StringInfo str, SortClause *node) +{ + WRITE_NODE_TYPE("SORTCLAUSE"); + + WRITE_UINT_FIELD(tleSortGroupRef); + WRITE_OID_FIELD(sortop); +} + +static void +_outGroupClause(StringInfo str, GroupClause *node) +{ + WRITE_NODE_TYPE("GROUPCLAUSE"); + + WRITE_UINT_FIELD(tleSortGroupRef); + WRITE_OID_FIELD(sortop); +} + +static void +_outSetOperationStmt(StringInfo str, SetOperationStmt *node) +{ + WRITE_NODE_TYPE("SETOPERATIONSTMT"); + + WRITE_ENUM_FIELD(op, SetOperation); + WRITE_BOOL_FIELD(all); + WRITE_NODE_FIELD(larg); + WRITE_NODE_FIELD(rarg); + WRITE_OIDLIST_FIELD(colTypes); +} + +static void +_outRangeTblEntry(StringInfo str, RangeTblEntry *node) +{ + WRITE_NODE_TYPE("RTE"); + + /* put alias + eref first to make dump more legible */ + WRITE_NODE_FIELD(alias); + WRITE_NODE_FIELD(eref); + WRITE_ENUM_FIELD(rtekind, RTEKind); + + switch (node->rtekind) { - s = (char *) DatumGetPointer(value); - if (!PointerIsValid(s)) - appendStringInfo(str, "0 [ ]"); - else - { - appendStringInfo(str, "%u [ ", (unsigned int) length); - for (i = 0; i < length; i++) - appendStringInfo(str, "%d ", (int) (s[i])); - appendStringInfo(str, "]"); - } + case RTE_RELATION: + case RTE_SPECIAL: + WRITE_OID_FIELD(relid); + break; + case RTE_SUBQUERY: + WRITE_NODE_FIELD(subquery); + break; + case RTE_FUNCTION: + WRITE_NODE_FIELD(funcexpr); + WRITE_NODE_FIELD(coldeflist); + break; + case RTE_JOIN: + WRITE_ENUM_FIELD(jointype, JoinType); + WRITE_NODE_FIELD(joinaliasvars); + break; + default: + elog(ERROR, "bogus rte kind %d", (int) node->rtekind); + break; } + + WRITE_BOOL_FIELD(inh); + WRITE_BOOL_FIELD(inFromCl); + WRITE_BOOL_FIELD(checkForRead); + WRITE_BOOL_FIELD(checkForWrite); + WRITE_OID_FIELD(checkAsUser); } static void @@ -1175,22 +1262,6 @@ _outValue(StringInfo str, Value *value) } static void -_outRangeVar(StringInfo str, RangeVar *node) -{ - WRITE_NODE_TYPE("RANGEVAR"); - - /* - * we deliberately ignore catalogname here, since it is presently not - * semantically meaningful - */ - WRITE_STRING_FIELD(schemaname); - WRITE_STRING_FIELD(relname); - WRITE_ENUM_FIELD(inhOpt, InhOption); - WRITE_BOOL_FIELD(istemp); - WRITE_NODE_FIELD(alias); -} - -static void _outColumnRef(StringInfo str, ColumnRef *node) { WRITE_NODE_TYPE("COLUMNREF"); @@ -1229,6 +1300,12 @@ _outExprFieldSelect(StringInfo str, ExprFieldSelect *node) } static void +_outDomainConstraintValue(StringInfo str, DomainConstraintValue *node) +{ + WRITE_NODE_TYPE("DOMAINCONSTRAINTVALUE"); +} + +static void _outConstraint(StringInfo str, Constraint *node) { WRITE_NODE_TYPE("CONSTRAINT"); @@ -1287,71 +1364,6 @@ _outFkConstraint(StringInfo str, FkConstraint *node) WRITE_BOOL_FIELD(skip_validation); } -static void -_outCaseExpr(StringInfo str, CaseExpr *node) -{ - WRITE_NODE_TYPE("CASE"); - - WRITE_OID_FIELD(casetype); - WRITE_NODE_FIELD(arg); - WRITE_NODE_FIELD(args); - WRITE_NODE_FIELD(defresult); -} - -static void -_outCaseWhen(StringInfo str, CaseWhen *node) -{ - WRITE_NODE_TYPE("WHEN"); - - WRITE_NODE_FIELD(expr); - WRITE_NODE_FIELD(result); -} - -static void -_outNullTest(StringInfo str, NullTest *node) -{ - WRITE_NODE_TYPE("NULLTEST"); - - WRITE_NODE_FIELD(arg); - WRITE_ENUM_FIELD(nulltesttype, NullTestType); -} - -static void -_outBooleanTest(StringInfo str, BooleanTest *node) -{ - WRITE_NODE_TYPE("BOOLEANTEST"); - - WRITE_NODE_FIELD(arg); - WRITE_ENUM_FIELD(booltesttype, BoolTestType); -} - -static void -_outConstraintTest(StringInfo str, ConstraintTest *node) -{ - WRITE_NODE_TYPE("CONSTRAINTTEST"); - - WRITE_NODE_FIELD(arg); - WRITE_ENUM_FIELD(testtype, ConstraintTestType); - WRITE_STRING_FIELD(name); - WRITE_STRING_FIELD(domname); - WRITE_NODE_FIELD(check_expr); -} - -static void -_outDomainConstraintValue(StringInfo str, DomainConstraintValue *node) -{ - WRITE_NODE_TYPE("DOMAINCONSTRAINTVALUE"); -} - -static void -_outConstraintTestValue(StringInfo str, ConstraintTestValue *node) -{ - WRITE_NODE_TYPE("CONSTRAINTTESTVALUE"); - - WRITE_OID_FIELD(typeId); - WRITE_INT_FIELD(typeMod); -} - /* * _outNode - @@ -1392,42 +1404,6 @@ _outNode(StringInfo str, void *obj) appendStringInfoChar(str, '{'); switch (nodeTag(obj)) { - case T_CreateStmt: - _outCreateStmt(str, obj); - break; - case T_IndexStmt: - _outIndexStmt(str, obj); - break; - case T_NotifyStmt: - _outNotifyStmt(str, obj); - break; - case T_SelectStmt: - _outSelectStmt(str, obj); - break; - case T_ColumnDef: - _outColumnDef(str, obj); - break; - case T_TypeName: - _outTypeName(str, obj); - break; - case T_TypeCast: - _outTypeCast(str, obj); - break; - case T_IndexElem: - _outIndexElem(str, obj); - break; - case T_Query: - _outQuery(str, obj); - break; - case T_SortClause: - _outSortClause(str, obj); - break; - case T_GroupClause: - _outGroupClause(str, obj); - break; - case T_SetOperationStmt: - _outSetOperationStmt(str, obj); - break; case T_Plan: _outPlan(str, obj); break; @@ -1437,18 +1413,6 @@ _outNode(StringInfo str, void *obj) case T_Append: _outAppend(str, obj); break; - case T_Join: - _outJoin(str, obj); - break; - case T_NestLoop: - _outNestLoop(str, obj); - break; - case T_MergeJoin: - _outMergeJoin(str, obj); - break; - case T_HashJoin: - _outHashJoin(str, obj); - break; case T_Scan: _outScan(str, obj); break; @@ -1467,11 +1431,17 @@ _outNode(StringInfo str, void *obj) case T_FunctionScan: _outFunctionScan(str, obj); break; - case T_Material: - _outMaterial(str, obj); + case T_Join: + _outJoin(str, obj); break; - case T_Sort: - _outSort(str, obj); + case T_NestLoop: + _outNestLoop(str, obj); + break; + case T_MergeJoin: + _outMergeJoin(str, obj); + break; + case T_HashJoin: + _outHashJoin(str, obj); break; case T_Agg: _outAgg(str, obj); @@ -1479,6 +1449,12 @@ _outNode(StringInfo str, void *obj) case T_Group: _outGroup(str, obj); break; + case T_Material: + _outMaterial(str, obj); + break; + case T_Sort: + _outSort(str, obj); + break; case T_Unique: _outUnique(str, obj); break; @@ -1491,14 +1467,14 @@ _outNode(StringInfo str, void *obj) case T_Hash: _outHash(str, obj); break; - case T_SubPlan: - _outSubPlan(str, obj); - break; case T_Resdom: _outResdom(str, obj); break; - case T_Expr: - _outExpr(str, obj); + case T_Alias: + _outAlias(str, obj); + break; + case T_RangeVar: + _outRangeVar(str, obj); break; case T_Var: _outVar(str, obj); @@ -1506,23 +1482,32 @@ _outNode(StringInfo str, void *obj) case T_Const: _outConst(str, obj); break; + case T_Param: + _outParam(str, obj); + break; case T_Aggref: _outAggref(str, obj); break; - case T_SubLink: - _outSubLink(str, obj); - break; case T_ArrayRef: _outArrayRef(str, obj); break; - case T_Func: - _outFunc(str, obj); + case T_FuncExpr: + _outFuncExpr(str, obj); break; - case T_Oper: - _outOper(str, obj); + case T_OpExpr: + _outOpExpr(str, obj); break; - case T_Param: - _outParam(str, obj); + case T_DistinctExpr: + _outDistinctExpr(str, obj); + break; + case T_BoolExpr: + _outBoolExpr(str, obj); + break; + case T_SubLink: + _outSubLink(str, obj); + break; + case T_SubPlanExpr: + _outSubPlanExpr(str, obj); break; case T_FieldSelect: _outFieldSelect(str, obj); @@ -1530,24 +1515,37 @@ _outNode(StringInfo str, void *obj) case T_RelabelType: _outRelabelType(str, obj); break; - case T_RangeTblRef: - _outRangeTblRef(str, obj); + case T_CaseExpr: + _outCaseExpr(str, obj); break; - case T_FromExpr: - _outFromExpr(str, obj); + case T_CaseWhen: + _outCaseWhen(str, obj); break; - case T_JoinExpr: - _outJoinExpr(str, obj); + case T_NullTest: + _outNullTest(str, obj); + break; + case T_BooleanTest: + _outBooleanTest(str, obj); + break; + case T_ConstraintTest: + _outConstraintTest(str, obj); + break; + case T_ConstraintTestValue: + _outConstraintTestValue(str, obj); break; case T_TargetEntry: _outTargetEntry(str, obj); break; - case T_Alias: - _outAlias(str, obj); + case T_RangeTblRef: + _outRangeTblRef(str, obj); break; - case T_RangeTblEntry: - _outRangeTblEntry(str, obj); + case T_JoinExpr: + _outJoinExpr(str, obj); + break; + case T_FromExpr: + _outFromExpr(str, obj); break; + case T_Path: _outPath(str, obj); break; @@ -1584,12 +1582,49 @@ _outNode(StringInfo str, void *obj) case T_JoinInfo: _outJoinInfo(str, obj); break; + + case T_CreateStmt: + _outCreateStmt(str, obj); + break; + case T_IndexStmt: + _outIndexStmt(str, obj); + break; + case T_NotifyStmt: + _outNotifyStmt(str, obj); + break; + case T_SelectStmt: + _outSelectStmt(str, obj); + break; + case T_ColumnDef: + _outColumnDef(str, obj); + break; + case T_TypeName: + _outTypeName(str, obj); + break; + case T_TypeCast: + _outTypeCast(str, obj); + break; + case T_IndexElem: + _outIndexElem(str, obj); + break; + case T_Query: + _outQuery(str, obj); + break; + case T_SortClause: + _outSortClause(str, obj); + break; + case T_GroupClause: + _outGroupClause(str, obj); + break; + case T_SetOperationStmt: + _outSetOperationStmt(str, obj); + break; + case T_RangeTblEntry: + _outRangeTblEntry(str, obj); + break; case T_A_Expr: _outAExpr(str, obj); break; - case T_RangeVar: - _outRangeVar(str, obj); - break; case T_ColumnRef: _outColumnRef(str, obj); break; @@ -1602,36 +1637,18 @@ _outNode(StringInfo str, void *obj) case T_ExprFieldSelect: _outExprFieldSelect(str, obj); break; + case T_DomainConstraintValue: + _outDomainConstraintValue(str, obj); + break; case T_Constraint: _outConstraint(str, obj); break; case T_FkConstraint: _outFkConstraint(str, obj); break; - case T_CaseExpr: - _outCaseExpr(str, obj); - break; - case T_CaseWhen: - _outCaseWhen(str, obj); - break; - case T_NullTest: - _outNullTest(str, obj); - break; - case T_BooleanTest: - _outBooleanTest(str, obj); - break; - case T_ConstraintTest: - _outConstraintTest(str, obj); - break; - case T_ConstraintTestValue: - _outConstraintTestValue(str, obj); - break; case T_FuncCall: _outFuncCall(str, obj); break; - case T_DomainConstraintValue: - _outDomainConstraintValue(str, obj); - break; default: elog(WARNING, "_outNode: don't know how to print type %d", diff --git a/src/backend/nodes/print.c b/src/backend/nodes/print.c index e8afda6b208..dd5186860bf 100644 --- a/src/backend/nodes/print.c +++ b/src/backend/nodes/print.c @@ -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"); diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c index eca2e3017b0..bb4a565a8b5 100644 --- a/src/backend/nodes/readfuncs.c +++ b/src/backend/nodes/readfuncs.c @@ -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(); } @@ -358,27 +350,6 @@ _readVar(void) } /* - * _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 */ static Const * @@ -401,17 +372,72 @@ _readConst(void) } /* - * _readFunc + * _readParam + */ +static Param * +_readParam(void) +{ + READ_LOCALS(Param); + + READ_INT_FIELD(paramkind); + READ_INT_FIELD(paramid); + READ_STRING_FIELD(paramname); + READ_OID_FIELD(paramtype); + + READ_DONE(); +} + +/* + * _readAggref + */ +static Aggref * +_readAggref(void) +{ + READ_LOCALS(Aggref); + + READ_OID_FIELD(aggfnoid); + READ_OID_FIELD(aggtype); + READ_NODE_FIELD(target); + READ_BOOL_FIELD(aggstar); + READ_BOOL_FIELD(aggdistinct); + + READ_DONE(); +} + +/* + * _readArrayRef */ -static Func * -_readFunc(void) +static ArrayRef * +_readArrayRef(void) { - READ_LOCALS(Func); + 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(); +} + +/* + * _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; @@ -419,17 +445,28 @@ _readFunc(void) } /* - * _readOper + * _readOpExpr */ -static Oper * -_readOper(void) +static OpExpr * +_readOpExpr(void) { - READ_LOCALS(Oper); + READ_LOCALS(OpExpr); READ_OID_FIELD(opno); - READ_OID_FIELD(opid); + 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; @@ -437,52 +474,55 @@ _readOper(void) } /* - * _readParam + * _readDistinctExpr */ -static Param * -_readParam(void) +static DistinctExpr * +_readDistinctExpr(void) { - READ_LOCALS(Param); - - READ_INT_FIELD(paramkind); - READ_INT_FIELD(paramid); - READ_STRING_FIELD(paramname); - READ_OID_FIELD(paramtype); + READ_LOCALS(DistinctExpr); - READ_DONE(); -} + 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; -/* - * _readAggref - */ -static Aggref * -_readAggref(void) -{ - READ_LOCALS(Aggref); + READ_OID_FIELD(opresulttype); + READ_BOOL_FIELD(opretset); + READ_NODE_FIELD(args); - READ_OID_FIELD(aggfnoid); - READ_OID_FIELD(aggtype); - READ_NODE_FIELD(target); - READ_BOOL_FIELD(aggstar); - READ_BOOL_FIELD(aggdistinct); - /* aggno is not saved since it is just executor state */ + local_node->op_fcache = NULL; READ_DONE(); } -static RangeVar * -_readRangeVar(void) +/* + * _readBoolExpr + */ +static BoolExpr * +_readBoolExpr(void) { - READ_LOCALS(RangeVar); + READ_LOCALS(BoolExpr); - local_node->catalogname = NULL; /* not currently saved in output - * format */ + /* 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_STRING_FIELD(schemaname); - READ_STRING_FIELD(relname); - READ_ENUM_FIELD(inhOpt, InhOption); - READ_BOOL_FIELD(istemp); - READ_NODE_FIELD(alias); + READ_NODE_FIELD(args); READ_DONE(); } @@ -505,6 +545,10 @@ _readSubLink(void) } /* + * _readSubPlanExpr is not needed since it doesn't appear in stored rules. + */ + +/* * _readFieldSelect */ static FieldSelect * @@ -537,58 +581,6 @@ _readRelabelType(void) } /* - * _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 */ static CaseExpr * @@ -664,17 +656,6 @@ _readConstraintTest(void) } /* - * _readDomainConstraintValue - */ -static DomainConstraintValue * -_readDomainConstraintValue(void) -{ - READ_LOCALS_NO_FIELDS(DomainConstraintValue); - - READ_DONE(); -} - -/* * _readConstraintTestValue */ static ConstraintTestValue * @@ -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); |