diff options
Diffstat (limited to 'src/backend/nodes/readfuncs.c')
| -rw-r--r-- | src/backend/nodes/readfuncs.c | 2428 |
1 files changed, 497 insertions, 1931 deletions
diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c index 43fe5bbd35f..ab5d1821ce5 100644 --- a/src/backend/nodes/readfuncs.c +++ b/src/backend/nodes/readfuncs.c @@ -8,18 +8,12 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.138 2002/11/24 21:52:13 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.139 2002/11/25 18:12:10 tgl Exp $ * * NOTES - * Most of the read functions for plan nodes are tested. (In fact, they - * pass the regression test as of 11/8/94.) The rest (for path selection) - * are probably never used. No effort has been made to get them to work. - * The simplest way to test these functions is by doing the following in - * ProcessQuery (before executing the plan): - * plan = stringToNode(nodeToString(plan)); - * Then, run the regression test. Let's just say you'll notice if either - * of the above function are not properly done. - * - ay 11/94 + * Path and Plan nodes do not have any readfuncs support, because we + * never have occasion to read them in. (There was once code here that + * claimed to read them, but it was broken as well as unused.) * *------------------------------------------------------------------------- */ @@ -27,9 +21,98 @@ #include <math.h> -#include "nodes/plannodes.h" +#include "nodes/parsenodes.h" #include "nodes/readfuncs.h" -#include "nodes/relation.h" + + +/* + * Macros to simplify reading of different kinds of fields. Use these + * wherever possible to reduce the chance for silly typos. Note that these + * hard-wire conventions about the names of the local variables in a Read + * routine. + */ + +/* Declare appropriate local variables */ +#define READ_LOCALS(nodeTypeName) \ + nodeTypeName *local_node = makeNode(nodeTypeName); \ + char *token; \ + int length + +/* A few guys need only local_node */ +#define READ_LOCALS_NO_FIELDS(nodeTypeName) \ + nodeTypeName *local_node = makeNode(nodeTypeName) + +/* And a few guys need only the pg_strtok support fields */ +#define READ_TEMP_LOCALS() \ + char *token; \ + int length + +/* Read an integer field (anything written as ":fldname %d") */ +#define READ_INT_FIELD(fldname) \ + token = pg_strtok(&length); /* skip :fldname */ \ + token = pg_strtok(&length); /* get field value */ \ + local_node->fldname = atoi(token) + +/* Read an unsigned integer field (anything written as ":fldname %u") */ +#define READ_UINT_FIELD(fldname) \ + token = pg_strtok(&length); /* skip :fldname */ \ + token = pg_strtok(&length); /* get field value */ \ + local_node->fldname = atoui(token) + +/* Read an OID field (don't hard-wire assumption that OID is same as uint) */ +#define READ_OID_FIELD(fldname) \ + token = pg_strtok(&length); /* skip :fldname */ \ + token = pg_strtok(&length); /* get field value */ \ + local_node->fldname = atooid(token) + +/* Read a char field (ie, one ascii character) */ +#define READ_CHAR_FIELD(fldname) \ + token = pg_strtok(&length); /* skip :fldname */ \ + token = pg_strtok(&length); /* get field value */ \ + local_node->fldname = token[0] + +/* Read an enumerated-type field that was written as an integer code */ +#define READ_ENUM_FIELD(fldname, enumtype) \ + token = pg_strtok(&length); /* skip :fldname */ \ + token = pg_strtok(&length); /* get field value */ \ + local_node->fldname = (enumtype) atoi(token) + +/* Read a float field */ +#define READ_FLOAT_FIELD(fldname) \ + token = pg_strtok(&length); /* skip :fldname */ \ + token = pg_strtok(&length); /* get field value */ \ + local_node->fldname = atof(token) + +/* Read a boolean field */ +#define READ_BOOL_FIELD(fldname) \ + token = pg_strtok(&length); /* skip :fldname */ \ + token = pg_strtok(&length); /* get field value */ \ + local_node->fldname = strtobool(token) + +/* Read a character-string field */ +#define READ_STRING_FIELD(fldname) \ + token = pg_strtok(&length); /* skip :fldname */ \ + token = pg_strtok(&length); /* get field value */ \ + local_node->fldname = nullable_string(token, length) + +/* Read a Node field */ +#define READ_NODE_FIELD(fldname) \ + token = pg_strtok(&length); /* skip :fldname */ \ + local_node->fldname = nodeRead(true) + +/* Read an integer-list field */ +#define READ_INTLIST_FIELD(fldname) \ + token = pg_strtok(&length); /* skip :fldname */ \ + local_node->fldname = toIntList(nodeRead(true)) + +/* Read an OID-list field */ +#define READ_OIDLIST_FIELD(fldname) \ + token = pg_strtok(&length); /* skip :fldname */ \ + local_node->fldname = toOidList(nodeRead(true)) + +/* Routine exit */ +#define READ_DONE() \ + return local_node /* @@ -51,11 +134,6 @@ static Datum readDatum(bool typbyval); -/* ---------------- - * node creator declarations - * ---------------- - */ - /* Convert Value list returned by nodeRead into list of integers */ static List * toIntList(List *list) @@ -106,694 +184,137 @@ toOidList(List *list) return list; } -/* ---------------- - * _readQuery - * ---------------- +/* + * _readQuery */ static Query * _readQuery(void) { - Query *local_node; - char *token; - int length; - - local_node = makeNode(Query); - - token = pg_strtok(&length); /* skip :command */ - token = pg_strtok(&length); /* get commandType */ - local_node->commandType = atoi(token); - - token = pg_strtok(&length); /* skip :source */ - token = pg_strtok(&length); /* get querySource */ - local_node->querySource = atoi(token); - - token = pg_strtok(&length); /* skip :utility */ - local_node->utilityStmt = nodeRead(true); - - token = pg_strtok(&length); /* skip :resultRelation */ - token = pg_strtok(&length); /* get the resultRelation */ - local_node->resultRelation = atoi(token); - - token = pg_strtok(&length); /* skip :into */ - local_node->into = nodeRead(true); - - token = pg_strtok(&length); /* skip :isPortal */ - token = pg_strtok(&length); /* get isPortal */ - local_node->isPortal = strtobool(token); - - token = pg_strtok(&length); /* skip :isBinary */ - token = pg_strtok(&length); /* get isBinary */ - local_node->isBinary = strtobool(token); - - token = pg_strtok(&length); /* skip the :hasAggs */ - token = pg_strtok(&length); /* get hasAggs */ - local_node->hasAggs = strtobool(token); - - token = pg_strtok(&length); /* skip the :hasSubLinks */ - token = pg_strtok(&length); /* get hasSubLinks */ - local_node->hasSubLinks = strtobool(token); - - token = pg_strtok(&length); /* skip :rtable */ - local_node->rtable = nodeRead(true); - - token = pg_strtok(&length); /* skip :jointree */ - local_node->jointree = nodeRead(true); - - token = pg_strtok(&length); /* skip :rowMarks */ - local_node->rowMarks = toIntList(nodeRead(true)); - - token = pg_strtok(&length); /* skip :targetlist */ - local_node->targetList = nodeRead(true); - - token = pg_strtok(&length); /* skip :groupClause */ - local_node->groupClause = nodeRead(true); - - token = pg_strtok(&length); /* skip :havingQual */ - local_node->havingQual = nodeRead(true); - - token = pg_strtok(&length); /* skip :distinctClause */ - local_node->distinctClause = nodeRead(true); - - token = pg_strtok(&length); /* skip :sortClause */ - local_node->sortClause = nodeRead(true); - - token = pg_strtok(&length); /* skip :limitOffset */ - local_node->limitOffset = nodeRead(true); - - token = pg_strtok(&length); /* skip :limitCount */ - local_node->limitCount = nodeRead(true); - - token = pg_strtok(&length); /* skip :setOperations */ - local_node->setOperations = nodeRead(true); - - token = pg_strtok(&length); /* skip :resultRelations */ - local_node->resultRelations = toIntList(nodeRead(true)); + READ_LOCALS(Query); + + READ_ENUM_FIELD(commandType, CmdType); + READ_ENUM_FIELD(querySource, QuerySource); + READ_NODE_FIELD(utilityStmt); + READ_INT_FIELD(resultRelation); + READ_NODE_FIELD(into); + READ_BOOL_FIELD(isPortal); + READ_BOOL_FIELD(isBinary); + READ_BOOL_FIELD(hasAggs); + READ_BOOL_FIELD(hasSubLinks); + READ_NODE_FIELD(rtable); + READ_NODE_FIELD(jointree); + READ_INTLIST_FIELD(rowMarks); + READ_NODE_FIELD(targetList); + READ_NODE_FIELD(groupClause); + READ_NODE_FIELD(havingQual); + READ_NODE_FIELD(distinctClause); + READ_NODE_FIELD(sortClause); + READ_NODE_FIELD(limitOffset); + READ_NODE_FIELD(limitCount); + READ_NODE_FIELD(setOperations); + READ_INTLIST_FIELD(resultRelations); /* planner-internal fields are left zero */ - return local_node; + READ_DONE(); } -/* ---------------- - * _readNotifyStmt - * ---------------- +/* + * _readNotifyStmt */ static NotifyStmt * _readNotifyStmt(void) { - NotifyStmt *local_node; - char *token; - int length; + READ_LOCALS(NotifyStmt); - local_node = makeNode(NotifyStmt); + READ_NODE_FIELD(relation); - token = pg_strtok(&length); /* skip :relation */ - local_node->relation = nodeRead(true); - - return local_node; + READ_DONE(); } -/* ---------------- - * _readSortClause - * ---------------- +/* + * _readSortClause */ static SortClause * _readSortClause(void) { - SortClause *local_node; - char *token; - int length; - - local_node = makeNode(SortClause); - - token = pg_strtok(&length); /* skip :tleSortGroupRef */ - token = pg_strtok(&length); /* get tleSortGroupRef */ - local_node->tleSortGroupRef = atoui(token); + READ_LOCALS(SortClause); - token = pg_strtok(&length); /* skip :sortop */ - token = pg_strtok(&length); /* get sortop */ - local_node->sortop = atooid(token); + READ_UINT_FIELD(tleSortGroupRef); + READ_OID_FIELD(sortop); - return local_node; + READ_DONE(); } -/* ---------------- - * _readGroupClause - * ---------------- +/* + * _readGroupClause */ static GroupClause * _readGroupClause(void) { - GroupClause *local_node; - char *token; - int length; + READ_LOCALS(GroupClause); - local_node = makeNode(GroupClause); + READ_UINT_FIELD(tleSortGroupRef); + READ_OID_FIELD(sortop); - token = pg_strtok(&length); /* skip :tleSortGroupRef */ - token = pg_strtok(&length); /* get tleSortGroupRef */ - local_node->tleSortGroupRef = atoui(token); - - token = pg_strtok(&length); /* skip :sortop */ - token = pg_strtok(&length); /* get sortop */ - local_node->sortop = atooid(token); - - return local_node; + READ_DONE(); } -/* ---------------- - * _readSetOperationStmt - * ---------------- +/* + * _readSetOperationStmt */ static SetOperationStmt * _readSetOperationStmt(void) { - SetOperationStmt *local_node; - char *token; - int length; - - local_node = makeNode(SetOperationStmt); - - token = pg_strtok(&length); /* eat :op */ - token = pg_strtok(&length); /* get op */ - local_node->op = (SetOperation) atoi(token); - - token = pg_strtok(&length); /* eat :all */ - token = pg_strtok(&length); /* get all */ - local_node->all = strtobool(token); - - token = pg_strtok(&length); /* eat :larg */ - local_node->larg = nodeRead(true); /* get larg */ - - token = pg_strtok(&length); /* eat :rarg */ - local_node->rarg = nodeRead(true); /* get rarg */ - - token = pg_strtok(&length); /* eat :colTypes */ - local_node->colTypes = toOidList(nodeRead(true)); - - return local_node; -} - -/* ---------------- - * _getPlan - * ---------------- - */ -static void -_getPlan(Plan *node) -{ - char *token; - int length; - - token = pg_strtok(&length); /* first token is :startup_cost */ - token = pg_strtok(&length); /* next is the actual cost */ - node->startup_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* skip the :total_cost */ - token = pg_strtok(&length); /* next is the actual cost */ - node->total_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* skip the :rows */ - token = pg_strtok(&length); /* get the plan_rows */ - node->plan_rows = atof(token); - - token = pg_strtok(&length); /* skip the :width */ - token = pg_strtok(&length); /* get the plan_width */ - node->plan_width = atoi(token); - - token = pg_strtok(&length); /* eat :qptargetlist */ - node->targetlist = nodeRead(true); - - token = pg_strtok(&length); /* eat :qpqual */ - node->qual = nodeRead(true); - - token = pg_strtok(&length); /* eat :lefttree */ - node->lefttree = (Plan *) nodeRead(true); - - token = pg_strtok(&length); /* eat :righttree */ - node->righttree = (Plan *) nodeRead(true); - - node->state = (EState *) NULL; /* never read in */ - - return; -} - -/* - * Stuff from plannodes.h - */ - -/* ---------------- - * _readPlan - * ---------------- - */ -static Plan * -_readPlan(void) -{ - Plan *local_node; - - local_node = makeNode(Plan); - - _getPlan(local_node); - - return local_node; -} - -/* ---------------- - * _readResult - * ---------------- - */ -static Result * -_readResult(void) -{ - Result *local_node; - char *token; - int length; - - local_node = makeNode(Result); - - _getPlan((Plan *) local_node); - - token = pg_strtok(&length); /* eat :resconstantqual */ - local_node->resconstantqual = nodeRead(true); /* now read it */ - - return local_node; -} - -/* ---------------- - * _readAppend - * - * Append is a subclass of Plan. - * ---------------- - */ - -static Append * -_readAppend(void) -{ - Append *local_node; - char *token; - int length; - - local_node = makeNode(Append); - - _getPlan((Plan *) local_node); - - token = pg_strtok(&length); /* eat :appendplans */ - local_node->appendplans = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :isTarget */ - token = pg_strtok(&length); /* get isTarget */ - local_node->isTarget = strtobool(token); - - return local_node; -} - -/* ---------------- - * _getJoin - * ---------------- - */ -static void -_getJoin(Join *node) -{ - char *token; - int length; - - _getPlan((Plan *) node); - - token = pg_strtok(&length); /* skip the :jointype */ - token = pg_strtok(&length); /* get the jointype */ - node->jointype = (JoinType) atoi(token); - - token = pg_strtok(&length); /* skip the :joinqual */ - node->joinqual = nodeRead(true); /* get the joinqual */ -} - - -/* ---------------- - * _readJoin - * - * Join is a subclass of Plan - * ---------------- - */ -static Join * -_readJoin(void) -{ - Join *local_node; - - local_node = makeNode(Join); - - _getJoin(local_node); - - return local_node; -} - -/* ---------------- - * _readNestLoop - * - * NestLoop is a subclass of Join - * ---------------- - */ - -static NestLoop * -_readNestLoop(void) -{ - NestLoop *local_node; - - local_node = makeNode(NestLoop); - - _getJoin((Join *) local_node); - - return local_node; -} - -/* ---------------- - * _readMergeJoin - * - * MergeJoin is a subclass of Join - * ---------------- - */ -static MergeJoin * -_readMergeJoin(void) -{ - MergeJoin *local_node; - char *token; - int length; - - local_node = makeNode(MergeJoin); - - _getJoin((Join *) local_node); - - token = pg_strtok(&length); /* eat :mergeclauses */ - local_node->mergeclauses = nodeRead(true); /* now read it */ - - return local_node; -} - -/* ---------------- - * _readHashJoin - * - * HashJoin is a subclass of Join. - * ---------------- - */ -static HashJoin * -_readHashJoin(void) -{ - HashJoin *local_node; - char *token; - int length; - - local_node = makeNode(HashJoin); - - _getJoin((Join *) local_node); - - token = pg_strtok(&length); /* eat :hashclauses */ - local_node->hashclauses = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :hashjoinop */ - token = pg_strtok(&length); /* get hashjoinop */ - local_node->hashjoinop = atooid(token); - - return local_node; -} - -/* ---------------- - * _getScan - * - * Scan is a subclass of Plan. - * - * Scan gets its own get function since stuff inherits it. - * ---------------- - */ -static void -_getScan(Scan *node) -{ - char *token; - int length; - - _getPlan((Plan *) node); - - token = pg_strtok(&length); /* eat :scanrelid */ - token = pg_strtok(&length); /* get scanrelid */ - node->scanrelid = atoui(token); -} - -/* ---------------- - * _readScan - * - * Scan is a subclass of Plan. - * ---------------- - */ -static Scan * -_readScan(void) -{ - Scan *local_node; - - local_node = makeNode(Scan); - - _getScan(local_node); - - return local_node; -} - -/* ---------------- - * _readSeqScan - * - * SeqScan is a subclass of Scan - * ---------------- - */ -static SeqScan * -_readSeqScan(void) -{ - SeqScan *local_node; - - local_node = makeNode(SeqScan); - - _getScan((Scan *) local_node); - - return local_node; -} - -/* ---------------- - * _readIndexScan - * - * IndexScan is a subclass of Scan - * ---------------- - */ -static IndexScan * -_readIndexScan(void) -{ - IndexScan *local_node; - char *token; - int length; - - local_node = makeNode(IndexScan); - - _getScan((Scan *) local_node); - - token = pg_strtok(&length); /* eat :indxid */ - local_node->indxid = toOidList(nodeRead(true)); /* now read it */ - - token = pg_strtok(&length); /* eat :indxqual */ - local_node->indxqual = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :indxqualorig */ - local_node->indxqualorig = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :indxorderdir */ - token = pg_strtok(&length); /* get indxorderdir */ - local_node->indxorderdir = atoi(token); - - return local_node; -} - -/* ---------------- - * _readTidScan - * - * TidScan is a subclass of Scan - * ---------------- - */ -static TidScan * -_readTidScan(void) -{ - TidScan *local_node; - char *token; - int length; - - local_node = makeNode(TidScan); - - _getScan((Scan *) local_node); - - token = pg_strtok(&length); /* eat :needrescan */ - token = pg_strtok(&length); /* get needrescan */ - local_node->needRescan = atoi(token); - - token = pg_strtok(&length); /* eat :tideval */ - local_node->tideval = nodeRead(true); /* now read it */ - - return local_node; -} - -/* ---------------- - * _readSubqueryScan - * - * SubqueryScan is a subclass of Scan - * ---------------- - */ -static SubqueryScan * -_readSubqueryScan(void) -{ - SubqueryScan *local_node; - char *token; - int length; - - local_node = makeNode(SubqueryScan); - - _getScan((Scan *) local_node); - - token = pg_strtok(&length); /* eat :subplan */ - local_node->subplan = nodeRead(true); /* now read it */ - - return local_node; -} - -/* ---------------- - * _readFunctionScan - * - * FunctionScan is a subclass of Scan - * ---------------- - */ -static FunctionScan * -_readFunctionScan(void) -{ - FunctionScan *local_node; - - local_node = makeNode(FunctionScan); - - _getScan((Scan *) local_node); - - return local_node; -} - -/* ---------------- - * _readSort - * - * Sort is a subclass of Plan - * ---------------- - */ -static Sort * -_readSort(void) -{ - Sort *local_node; - char *token; - int length; + READ_LOCALS(SetOperationStmt); - local_node = makeNode(Sort); + READ_ENUM_FIELD(op, SetOperation); + READ_BOOL_FIELD(all); + READ_NODE_FIELD(larg); + READ_NODE_FIELD(rarg); + READ_OIDLIST_FIELD(colTypes); - _getPlan((Plan *) local_node); - - token = pg_strtok(&length); /* eat :keycount */ - token = pg_strtok(&length); /* get keycount */ - local_node->keycount = atoi(token); - - return local_node; + READ_DONE(); } -/* ---------------- - * _readHash - * - * Hash is a subclass of Plan - * ---------------- - */ -static Hash * -_readHash(void) -{ - Hash *local_node; - char *token; - int length; - - local_node = makeNode(Hash); - - _getPlan((Plan *) local_node); - - token = pg_strtok(&length); /* eat :hashkey */ - local_node->hashkey = nodeRead(true); - - return local_node; -} /* * Stuff from primnodes.h. */ -/* ---------------- - * _readResdom - * - * Resdom is a subclass of Node - * ---------------- +/* + * _readResdom */ static Resdom * _readResdom(void) { - Resdom *local_node; - char *token; - int length; - - local_node = makeNode(Resdom); - - token = pg_strtok(&length); /* eat :resno */ - token = pg_strtok(&length); /* get resno */ - local_node->resno = atoi(token); - - token = pg_strtok(&length); /* eat :restype */ - token = pg_strtok(&length); /* get restype */ - local_node->restype = atooid(token); - - token = pg_strtok(&length); /* eat :restypmod */ - token = pg_strtok(&length); /* get restypmod */ - local_node->restypmod = atoi(token); - - token = pg_strtok(&length); /* eat :resname */ - token = pg_strtok(&length); /* get the name */ - local_node->resname = nullable_string(token, length); - - token = pg_strtok(&length); /* eat :reskey */ - token = pg_strtok(&length); /* get reskey */ - local_node->reskey = atoui(token); - - token = pg_strtok(&length); /* eat :reskeyop */ - token = pg_strtok(&length); /* get reskeyop */ - local_node->reskeyop = atooid(token); - - token = pg_strtok(&length); /* eat :ressortgroupref */ - token = pg_strtok(&length); /* get ressortgroupref */ - local_node->ressortgroupref = atoui(token); + READ_LOCALS(Resdom); - token = pg_strtok(&length); /* eat :resjunk */ - token = pg_strtok(&length); /* get resjunk */ - local_node->resjunk = strtobool(token); + READ_INT_FIELD(resno); + READ_OID_FIELD(restype); + READ_INT_FIELD(restypmod); + READ_STRING_FIELD(resname); + READ_UINT_FIELD(ressortgroupref); + READ_UINT_FIELD(reskey); + READ_OID_FIELD(reskeyop); + READ_BOOL_FIELD(resjunk); - return local_node; + READ_DONE(); } -/* ---------------- - * _readExpr - * - * Expr is a subclass of Node - * ---------------- +/* + * _readExpr */ static Expr * _readExpr(void) { - Expr *local_node; - char *token; - int length; + READ_LOCALS(Expr); - local_node = makeNode(Expr); + READ_OID_FIELD(typeOid); - token = pg_strtok(&length); /* eat :typeOid */ - token = pg_strtok(&length); /* get typeOid */ - local_node->typeOid = atooid(token); - - token = pg_strtok(&length); /* eat :opType */ - token = pg_strtok(&length); /* get opType */ + /* 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) @@ -811,1551 +332,596 @@ _readExpr(void) else elog(ERROR, "_readExpr: unknown opType \"%.*s\"", length, token); - token = pg_strtok(&length); /* eat :oper */ - local_node->oper = nodeRead(true); - - token = pg_strtok(&length); /* eat :args */ - local_node->args = nodeRead(true); /* now read it */ - - return local_node; -} - -/* ---------------- - * _readCaseExpr - * - * CaseExpr is a subclass of Node - * ---------------- - */ -static CaseExpr * -_readCaseExpr(void) -{ - CaseExpr *local_node; - char *token; - int length; - - local_node = makeNode(CaseExpr); - - token = pg_strtok(&length); /* eat :casetype */ - token = pg_strtok(&length); /* get casetype */ - local_node->casetype = atooid(token); - - token = pg_strtok(&length); /* eat :arg */ - local_node->arg = nodeRead(true); - - token = pg_strtok(&length); /* eat :args */ - local_node->args = nodeRead(true); - - token = pg_strtok(&length); /* eat :defresult */ - local_node->defresult = nodeRead(true); - - return local_node; -} - -/* ---------------- - * _readCaseWhen - * - * CaseWhen is a subclass of Node - * ---------------- - */ -static CaseWhen * -_readCaseWhen(void) -{ - CaseWhen *local_node; - char *token; - int length; - - local_node = makeNode(CaseWhen); - - local_node->expr = nodeRead(true); - token = pg_strtok(&length); /* eat :then */ - local_node->result = nodeRead(true); - - return local_node; -} - -/* ---------------- - * _readNullTest - * - * NullTest is a subclass of Node - * ---------------- - */ -static NullTest * -_readNullTest(void) -{ - NullTest *local_node; - char *token; - int length; - - local_node = makeNode(NullTest); - - token = pg_strtok(&length); /* eat :arg */ - local_node->arg = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :nulltesttype */ - token = pg_strtok(&length); /* get nulltesttype */ - local_node->nulltesttype = (NullTestType) atoi(token); - - return local_node; -} - -/* ---------------- - * _readBooleanTest - * - * BooleanTest is a subclass of Node - * ---------------- - */ -static BooleanTest * -_readBooleanTest(void) -{ - BooleanTest *local_node; - char *token; - int length; - - local_node = makeNode(BooleanTest); - - token = pg_strtok(&length); /* eat :arg */ - local_node->arg = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :booltesttype */ - token = pg_strtok(&length); /* get booltesttype */ - local_node->booltesttype = (BoolTestType) atoi(token); - - return local_node; -} - -/* ---------------- - * _readConstraintTest - * - * ConstraintTest is a subclass of Node - * ---------------- - */ -static ConstraintTest * -_readConstraintTest(void) -{ - ConstraintTest *local_node; - char *token; - int length; - - local_node = makeNode(ConstraintTest); + READ_NODE_FIELD(oper); + READ_NODE_FIELD(args); - token = pg_strtok(&length); /* eat :arg */ - local_node->arg = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :testtype */ - token = pg_strtok(&length); /* get testtype */ - local_node->testtype = (ConstraintTestType) atoi(token); - - token = pg_strtok(&length); /* get :name */ - token = pg_strtok(&length); /* now read it */ - local_node->name = nullable_string(token, length); - - token = pg_strtok(&length); /* get :domname */ - token = pg_strtok(&length); /* get domname */ - local_node->domname = nullable_string(token, length); - - token = pg_strtok(&length); /* eat :check_expr */ - local_node->check_expr = nodeRead(true); /* now read it */ - - return local_node; -} - -/* ---------------- - * _readConstraintTestValue - * - * ConstraintTestValue is a subclass of Node - * ---------------- - */ -static ConstraintTestValue * -_readConstraintTestValue(void) -{ - ConstraintTestValue *local_node; - char *token; - int length; - - local_node = makeNode(ConstraintTestValue); - token = pg_strtok(&length); /* eat :typeid */ - token = pg_strtok(&length); /* get typeid */ - local_node->typeId = atooid(token); - token = pg_strtok(&length); /* eat :typemod */ - token = pg_strtok(&length); /* get typemod */ - local_node->typeMod = atoi(token); - - return local_node; + READ_DONE(); } -/* ---------------- - * _readDomainConstraintValue - * - * DomainConstraintValue is a subclass of Node - * ---------------- - */ -static DomainConstraintValue * -_readDomainConstraintValue(void) -{ - DomainConstraintValue *local_node; - - local_node = makeNode(DomainConstraintValue); - - return local_node; -} - -/* ---------------- - * _readVar - * - * Var is a subclass of Expr - * ---------------- +/* + * _readVar */ static Var * _readVar(void) { - Var *local_node; - char *token; - int length; - - local_node = makeNode(Var); - - token = pg_strtok(&length); /* eat :varno */ - token = pg_strtok(&length); /* get varno */ - local_node->varno = atoui(token); - - token = pg_strtok(&length); /* eat :varattno */ - token = pg_strtok(&length); /* get varattno */ - local_node->varattno = atoi(token); - - token = pg_strtok(&length); /* eat :vartype */ - token = pg_strtok(&length); /* get vartype */ - local_node->vartype = atooid(token); + READ_LOCALS(Var); - token = pg_strtok(&length); /* eat :vartypmod */ - token = pg_strtok(&length); /* get vartypmod */ - local_node->vartypmod = atoi(token); + READ_UINT_FIELD(varno); + READ_INT_FIELD(varattno); + READ_OID_FIELD(vartype); + READ_INT_FIELD(vartypmod); + READ_UINT_FIELD(varlevelsup); + READ_UINT_FIELD(varnoold); + READ_INT_FIELD(varoattno); - token = pg_strtok(&length); /* eat :varlevelsup */ - token = pg_strtok(&length); /* get varlevelsup */ - local_node->varlevelsup = atoui(token); - - token = pg_strtok(&length); /* eat :varnoold */ - token = pg_strtok(&length); /* get varnoold */ - local_node->varnoold = atoui(token); - - token = pg_strtok(&length); /* eat :varoattno */ - token = pg_strtok(&length); /* eat :varoattno */ - local_node->varoattno = atoi(token); - - return local_node; + READ_DONE(); } -/* ---------------- +/* * _readArrayRef - * - * ArrayRef is a subclass of Expr - * ---------------- */ static ArrayRef * _readArrayRef(void) { - ArrayRef *local_node; - char *token; - int length; - - local_node = makeNode(ArrayRef); - - token = pg_strtok(&length); /* eat :refrestype */ - token = pg_strtok(&length); /* get refrestype */ - local_node->refrestype = atooid(token); - - token = pg_strtok(&length); /* eat :refattrlength */ - token = pg_strtok(&length); /* get refattrlength */ - local_node->refattrlength = atoi(token); - - token = pg_strtok(&length); /* eat :refelemlength */ - token = pg_strtok(&length); /* get refelemlength */ - local_node->refelemlength = atoi(token); - - token = pg_strtok(&length); /* eat :refelembyval */ - token = pg_strtok(&length); /* get refelembyval */ - local_node->refelembyval = strtobool(token); - - token = pg_strtok(&length); /* eat :refelemalign */ - token = pg_strtok(&length); /* get refelemalign */ - local_node->refelemalign = token[0]; - - token = pg_strtok(&length); /* eat :refupperindexpr */ - local_node->refupperindexpr = nodeRead(true); - - token = pg_strtok(&length); /* eat :reflowerindexpr */ - local_node->reflowerindexpr = nodeRead(true); - - token = pg_strtok(&length); /* eat :refexpr */ - local_node->refexpr = nodeRead(true); + READ_LOCALS(ArrayRef); - token = pg_strtok(&length); /* eat :refassgnexpr */ - local_node->refassgnexpr = nodeRead(true); + 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); - return local_node; + READ_DONE(); } -/* ---------------- - * _readConst - * - * Const is a subclass of Expr - * ---------------- +/* + * _readConst */ static Const * _readConst(void) { - Const *local_node; - char *token; - int length; - - local_node = makeNode(Const); - - token = pg_strtok(&length); /* get :consttype */ - token = pg_strtok(&length); /* now read it */ - local_node->consttype = atooid(token); - - token = pg_strtok(&length); /* get :constlen */ - token = pg_strtok(&length); /* now read it */ - local_node->constlen = atoi(token); + READ_LOCALS(Const); - token = pg_strtok(&length); /* get :constbyval */ - token = pg_strtok(&length); /* now read it */ - local_node->constbyval = strtobool(token); - - token = pg_strtok(&length); /* get :constisnull */ - token = pg_strtok(&length); /* now read it */ - local_node->constisnull = strtobool(token); - - token = pg_strtok(&length); /* get :constvalue */ + READ_OID_FIELD(consttype); + READ_INT_FIELD(constlen); + READ_BOOL_FIELD(constbyval); + READ_BOOL_FIELD(constisnull); + /* XXX what about constisset, constiscast? */ + token = pg_strtok(&length); /* skip :constvalue */ if (local_node->constisnull) - { - token = pg_strtok(&length); /* skip "NIL" */ - } + token = pg_strtok(&length); /* skip "<>" */ else local_node->constvalue = readDatum(local_node->constbyval); - return local_node; + READ_DONE(); } -/* ---------------- - * _readFunc - * - * Func is a subclass of Expr - * ---------------- +/* + * _readFunc */ static Func * _readFunc(void) { - Func *local_node; - char *token; - int length; - - local_node = makeNode(Func); - - token = pg_strtok(&length); /* get :funcid */ - token = pg_strtok(&length); /* now read it */ - local_node->funcid = atooid(token); - - token = pg_strtok(&length); /* get :funcresulttype */ - token = pg_strtok(&length); /* now read it */ - local_node->funcresulttype = atooid(token); - - token = pg_strtok(&length); /* get :funcretset */ - token = pg_strtok(&length); /* now read it */ - local_node->funcretset = strtobool(token); + READ_LOCALS(Func); - token = pg_strtok(&length); /* get :funcformat */ - token = pg_strtok(&length); /* now read it */ - local_node->funcformat = (CoercionForm) atoi(token); + READ_OID_FIELD(funcid); + READ_OID_FIELD(funcresulttype); + READ_BOOL_FIELD(funcretset); + READ_ENUM_FIELD(funcformat, CoercionForm); local_node->func_fcache = NULL; - return local_node; + READ_DONE(); } -/* ---------------- - * _readOper - * - * Oper is a subclass of Expr - * ---------------- +/* + * _readOper */ static Oper * _readOper(void) { - Oper *local_node; - char *token; - int length; - - local_node = makeNode(Oper); - - token = pg_strtok(&length); /* get :opno */ - token = pg_strtok(&length); /* now read it */ - local_node->opno = atooid(token); + READ_LOCALS(Oper); - token = pg_strtok(&length); /* get :opid */ - token = pg_strtok(&length); /* now read it */ - local_node->opid = atooid(token); - - token = pg_strtok(&length); /* get :opresulttype */ - token = pg_strtok(&length); /* now read it */ - local_node->opresulttype = atooid(token); - - token = pg_strtok(&length); /* get :opretset */ - token = pg_strtok(&length); /* now read it */ - local_node->opretset = strtobool(token); + READ_OID_FIELD(opno); + READ_OID_FIELD(opid); + READ_OID_FIELD(opresulttype); + READ_BOOL_FIELD(opretset); local_node->op_fcache = NULL; - return local_node; + READ_DONE(); } -/* ---------------- - * _readParam - * - * Param is a subclass of Expr - * ---------------- +/* + * _readParam */ static Param * _readParam(void) { - Param *local_node; - char *token; - int length; - - local_node = makeNode(Param); + READ_LOCALS(Param); - token = pg_strtok(&length); /* get :paramkind */ - token = pg_strtok(&length); /* now read it */ - local_node->paramkind = atoi(token); + READ_INT_FIELD(paramkind); + READ_INT_FIELD(paramid); + READ_STRING_FIELD(paramname); + READ_OID_FIELD(paramtype); - token = pg_strtok(&length); /* get :paramid */ - token = pg_strtok(&length); /* now read it */ - local_node->paramid = atoi(token); - - token = pg_strtok(&length); /* get :paramname */ - token = pg_strtok(&length); /* now read it */ - local_node->paramname = nullable_string(token, length); - - token = pg_strtok(&length); /* get :paramtype */ - token = pg_strtok(&length); /* now read it */ - local_node->paramtype = atooid(token); - - return local_node; + READ_DONE(); } -/* ---------------- - * _readAggref - * - * Aggref is a subclass of Node - * ---------------- +/* + * _readAggref */ static Aggref * _readAggref(void) { - Aggref *local_node; - char *token; - int length; - - local_node = makeNode(Aggref); + READ_LOCALS(Aggref); - token = pg_strtok(&length); /* eat :aggfnoid */ - token = pg_strtok(&length); /* get aggfnoid */ - local_node->aggfnoid = atooid(token); + 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 */ - token = pg_strtok(&length); /* eat :aggtype */ - token = pg_strtok(&length); /* get aggtype */ - local_node->aggtype = atooid(token); + READ_DONE(); +} - token = pg_strtok(&length); /* eat :target */ - local_node->target = nodeRead(true); /* now read it */ +static RangeVar * +_readRangeVar(void) +{ + READ_LOCALS(RangeVar); - token = pg_strtok(&length); /* eat :aggstar */ - token = pg_strtok(&length); /* get aggstar */ - local_node->aggstar = strtobool(token); + local_node->catalogname = NULL; /* not currently saved in output + * format */ - token = pg_strtok(&length); /* eat :aggdistinct */ - token = pg_strtok(&length); /* get aggdistinct */ - local_node->aggdistinct = strtobool(token); + READ_STRING_FIELD(schemaname); + READ_STRING_FIELD(relname); + READ_ENUM_FIELD(inhOpt, InhOption); + READ_BOOL_FIELD(istemp); + READ_NODE_FIELD(alias); - return local_node; + READ_DONE(); } -/* ---------------- - * _readSubLink - * - * SubLink is a subclass of Node - * ---------------- +/* + * _readSubLink */ static SubLink * _readSubLink(void) { - SubLink *local_node; - char *token; - int length; - - local_node = makeNode(SubLink); - - token = pg_strtok(&length); /* eat :subLinkType */ - token = pg_strtok(&length); /* get subLinkType */ - local_node->subLinkType = atoi(token); - - token = pg_strtok(&length); /* eat :useor */ - token = pg_strtok(&length); /* get useor */ - local_node->useor = strtobool(token); - - token = pg_strtok(&length); /* eat :lefthand */ - local_node->lefthand = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :oper */ - local_node->oper = nodeRead(true); /* now read it */ + READ_LOCALS(SubLink); - token = pg_strtok(&length); /* eat :subselect */ - local_node->subselect = nodeRead(true); /* now read it */ + READ_ENUM_FIELD(subLinkType, SubLinkType); + READ_BOOL_FIELD(useor); + READ_NODE_FIELD(lefthand); + READ_NODE_FIELD(oper); + READ_NODE_FIELD(subselect); - return local_node; + READ_DONE(); } -/* ---------------- - * _readFieldSelect - * - * FieldSelect is a subclass of Node - * ---------------- +/* + * _readFieldSelect */ static FieldSelect * _readFieldSelect(void) { - FieldSelect *local_node; - char *token; - int length; - - local_node = makeNode(FieldSelect); - - token = pg_strtok(&length); /* eat :arg */ - local_node->arg = nodeRead(true); /* now read it */ + READ_LOCALS(FieldSelect); - token = pg_strtok(&length); /* eat :fieldnum */ - token = pg_strtok(&length); /* get fieldnum */ - local_node->fieldnum = (AttrNumber) atoi(token); + READ_NODE_FIELD(arg); + READ_INT_FIELD(fieldnum); + READ_OID_FIELD(resulttype); + READ_INT_FIELD(resulttypmod); - token = pg_strtok(&length); /* eat :resulttype */ - token = pg_strtok(&length); /* get resulttype */ - local_node->resulttype = atooid(token); - - token = pg_strtok(&length); /* eat :resulttypmod */ - token = pg_strtok(&length); /* get resulttypmod */ - local_node->resulttypmod = atoi(token); - - return local_node; + READ_DONE(); } -/* ---------------- - * _readRelabelType - * - * RelabelType is a subclass of Node - * ---------------- +/* + * _readRelabelType */ static RelabelType * _readRelabelType(void) { - RelabelType *local_node; - char *token; - int length; - - local_node = makeNode(RelabelType); + READ_LOCALS(RelabelType); - token = pg_strtok(&length); /* eat :arg */ - local_node->arg = nodeRead(true); /* now read it */ + READ_NODE_FIELD(arg); + READ_OID_FIELD(resulttype); + READ_INT_FIELD(resulttypmod); + READ_ENUM_FIELD(relabelformat, CoercionForm); - token = pg_strtok(&length); /* eat :resulttype */ - token = pg_strtok(&length); /* get resulttype */ - local_node->resulttype = atooid(token); - - token = pg_strtok(&length); /* eat :resulttypmod */ - token = pg_strtok(&length); /* get resulttypmod */ - local_node->resulttypmod = atoi(token); - - token = pg_strtok(&length); /* eat :relabelformat */ - token = pg_strtok(&length); /* get relabelformat */ - local_node->relabelformat = (CoercionForm) atoi(token); - - return local_node; + READ_DONE(); } -/* ---------------- - * _readRangeTblRef - * - * RangeTblRef is a subclass of Node - * ---------------- +/* + * _readRangeTblRef */ static RangeTblRef * _readRangeTblRef(void) { - RangeTblRef *local_node; - char *token; - int length; + READ_LOCALS(RangeTblRef); - local_node = makeNode(RangeTblRef); + READ_INT_FIELD(rtindex); - token = pg_strtok(&length); /* get rtindex */ - local_node->rtindex = atoi(token); + READ_DONE(); +} - return local_node; +/* + * _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 - * - * FromExpr is a subclass of Node - * ---------------- +/* + * _readFromExpr */ static FromExpr * _readFromExpr(void) { - FromExpr *local_node; - char *token; - int length; + READ_LOCALS(FromExpr); - local_node = makeNode(FromExpr); + READ_NODE_FIELD(fromlist); + READ_NODE_FIELD(quals); - token = pg_strtok(&length); /* eat :fromlist */ - local_node->fromlist = nodeRead(true); /* now read it */ + READ_DONE(); +} - token = pg_strtok(&length); /* eat :quals */ - local_node->quals = nodeRead(true); /* now read it */ - return local_node; -} +/* + * Stuff from parsenodes.h. + */ -/* ---------------- - * _readJoinExpr - * - * JoinExpr is a subclass of Node - * ---------------- +/* + * _readCaseExpr */ -static JoinExpr * -_readJoinExpr(void) +static CaseExpr * +_readCaseExpr(void) { - JoinExpr *local_node; - char *token; - int length; - - local_node = makeNode(JoinExpr); + READ_LOCALS(CaseExpr); - token = pg_strtok(&length); /* eat :jointype */ - token = pg_strtok(&length); /* get jointype */ - local_node->jointype = (JoinType) atoi(token); + READ_OID_FIELD(casetype); + READ_NODE_FIELD(arg); + READ_NODE_FIELD(args); + READ_NODE_FIELD(defresult); - token = pg_strtok(&length); /* eat :isNatural */ - token = pg_strtok(&length); /* get isNatural */ - local_node->isNatural = strtobool(token); - - token = pg_strtok(&length); /* eat :larg */ - local_node->larg = nodeRead(true); /* now read it */ + READ_DONE(); +} - token = pg_strtok(&length); /* eat :rarg */ - local_node->rarg = nodeRead(true); /* now read it */ +/* + * _readCaseWhen + */ +static CaseWhen * +_readCaseWhen(void) +{ + READ_LOCALS(CaseWhen); - token = pg_strtok(&length); /* eat :using */ - local_node->using = nodeRead(true); /* now read it */ + READ_NODE_FIELD(expr); + READ_NODE_FIELD(result); - token = pg_strtok(&length); /* eat :quals */ - local_node->quals = nodeRead(true); /* now read it */ + READ_DONE(); +} - token = pg_strtok(&length); /* eat :alias */ - local_node->alias = nodeRead(true); /* now read it */ +/* + * _readNullTest + */ +static NullTest * +_readNullTest(void) +{ + READ_LOCALS(NullTest); - token = pg_strtok(&length); /* eat :rtindex */ - token = pg_strtok(&length); /* get rtindex */ - local_node->rtindex = atoi(token); + READ_NODE_FIELD(arg); + READ_ENUM_FIELD(nulltesttype, NullTestType); - return local_node; + READ_DONE(); } -/* ---------------- - * _readTargetEntry - * ---------------- +/* + * _readBooleanTest */ -static TargetEntry * -_readTargetEntry(void) +static BooleanTest * +_readBooleanTest(void) { - TargetEntry *local_node; - char *token; - int length; + READ_LOCALS(BooleanTest); - local_node = makeNode(TargetEntry); + READ_NODE_FIELD(arg); + READ_ENUM_FIELD(booltesttype, BoolTestType); - token = pg_strtok(&length); /* get :resdom */ - local_node->resdom = nodeRead(true); /* now read it */ + READ_DONE(); +} - token = pg_strtok(&length); /* get :expr */ - local_node->expr = nodeRead(true); /* now read it */ +/* + * _readConstraintTest + */ +static ConstraintTest * +_readConstraintTest(void) +{ + READ_LOCALS(ConstraintTest); - return local_node; + READ_NODE_FIELD(arg); + READ_ENUM_FIELD(testtype, ConstraintTestType); + READ_STRING_FIELD(name); + READ_STRING_FIELD(domname); + READ_NODE_FIELD(check_expr); + + READ_DONE(); } -static RangeVar * -_readRangeVar(void) +/* + * _readDomainConstraintValue + */ +static DomainConstraintValue * +_readDomainConstraintValue(void) { - RangeVar *local_node; - char *token; - int length; + READ_LOCALS_NO_FIELDS(DomainConstraintValue); - local_node = makeNode(RangeVar); - - local_node->catalogname = NULL; /* not currently saved in output - * format */ + READ_DONE(); +} - token = pg_strtok(&length); /* eat :relation */ - token = pg_strtok(&length); /* get schemaname */ - local_node->schemaname = nullable_string(token, length); +/* + * _readConstraintTestValue + */ +static ConstraintTestValue * +_readConstraintTestValue(void) +{ + READ_LOCALS(ConstraintTestValue); - token = pg_strtok(&length); /* eat "." */ - token = pg_strtok(&length); /* get relname */ - local_node->relname = nullable_string(token, length); + READ_OID_FIELD(typeId); + READ_INT_FIELD(typeMod); - token = pg_strtok(&length); /* eat :inhopt */ - token = pg_strtok(&length); /* get inhopt */ - local_node->inhOpt = (InhOption) atoi(token); + READ_DONE(); +} - token = pg_strtok(&length); /* eat :istemp */ - token = pg_strtok(&length); /* get istemp */ - local_node->istemp = strtobool(token); +/* + * _readTargetEntry + */ +static TargetEntry * +_readTargetEntry(void) +{ + READ_LOCALS(TargetEntry); - token = pg_strtok(&length); /* eat :alias */ - local_node->alias = nodeRead(true); /* now read it */ + READ_NODE_FIELD(resdom); + /* fjoin not supported ... */ + READ_NODE_FIELD(expr); - return local_node; + READ_DONE(); } static ColumnRef * _readColumnRef(void) { - ColumnRef *local_node; - char *token; - int length; - - local_node = makeNode(ColumnRef); - - token = pg_strtok(&length); /* eat :fields */ - local_node->fields = nodeRead(true); /* now read it */ + READ_LOCALS(ColumnRef); - token = pg_strtok(&length); /* eat :indirection */ - local_node->indirection = nodeRead(true); /* now read it */ + READ_NODE_FIELD(fields); + READ_NODE_FIELD(indirection); - return local_node; + READ_DONE(); } static ColumnDef * _readColumnDef(void) { - ColumnDef *local_node; - char *token; - int length; - - local_node = makeNode(ColumnDef); - - token = pg_strtok(&length); /* eat :colname */ - token = pg_strtok(&length); /* now read it */ - local_node->colname = nullable_string(token, length); - - token = pg_strtok(&length); /* eat :typename */ - local_node->typename = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :inhcount */ - token = pg_strtok(&length); /* get :inhcount */ - local_node->inhcount = atoi(token); - - token = pg_strtok(&length); /* eat :is_local */ - token = pg_strtok(&length); /* get :is_local */ - local_node->is_local = strtobool(token); + READ_LOCALS(ColumnDef); - token = pg_strtok(&length); /* eat :is_not_null */ - token = pg_strtok(&length); /* get :is_not_null */ - local_node->is_not_null = strtobool(token); + READ_STRING_FIELD(colname); + READ_NODE_FIELD(typename); + READ_INT_FIELD(inhcount); + READ_BOOL_FIELD(is_local); + READ_BOOL_FIELD(is_not_null); + READ_NODE_FIELD(raw_default); + READ_STRING_FIELD(cooked_default); + READ_NODE_FIELD(constraints); + READ_NODE_FIELD(support); - token = pg_strtok(&length); /* eat :raw_default */ - local_node->raw_default = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :cooked_default */ - token = pg_strtok(&length); /* now read it */ - local_node->cooked_default = nullable_string(token, length); - - token = pg_strtok(&length); /* eat :constraints */ - local_node->constraints = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :support */ - local_node->support = nodeRead(true); /* now read it */ - - return local_node; + READ_DONE(); } static TypeName * _readTypeName(void) { - TypeName *local_node; - char *token; - int length; + READ_LOCALS(TypeName); - local_node = makeNode(TypeName); + READ_NODE_FIELD(names); + READ_OID_FIELD(typeid); + READ_BOOL_FIELD(timezone); + READ_BOOL_FIELD(setof); + READ_BOOL_FIELD(pct_type); + READ_INT_FIELD(typmod); + READ_NODE_FIELD(arrayBounds); - token = pg_strtok(&length); /* eat :names */ - local_node->names = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :typeid */ - token = pg_strtok(&length); /* get typeid */ - local_node->typeid = atooid(token); - - token = pg_strtok(&length); /* eat :timezone */ - token = pg_strtok(&length); /* get timezone */ - local_node->timezone = strtobool(token); - - token = pg_strtok(&length); /* eat :setof */ - token = pg_strtok(&length); /* get setof */ - local_node->setof = strtobool(token); - - token = pg_strtok(&length); /* eat :pct_type */ - token = pg_strtok(&length); /* get pct_type */ - local_node->pct_type = strtobool(token); - - token = pg_strtok(&length); /* eat :typmod */ - token = pg_strtok(&length); /* get typmod */ - local_node->typmod = atoi(token); - - token = pg_strtok(&length); /* eat :arrayBounds */ - local_node->arrayBounds = nodeRead(true); /* now read it */ - - return local_node; + READ_DONE(); } static ExprFieldSelect * _readExprFieldSelect(void) { - ExprFieldSelect *local_node; - char *token; - int length; - - local_node = makeNode(ExprFieldSelect); - - token = pg_strtok(&length); /* eat :arg */ - local_node->arg = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :fields */ - local_node->fields = nodeRead(true); /* now read it */ + READ_LOCALS(ExprFieldSelect); - token = pg_strtok(&length); /* eat :indirection */ - local_node->indirection = nodeRead(true); /* now read it */ + READ_NODE_FIELD(arg); + READ_NODE_FIELD(fields); + READ_NODE_FIELD(indirection); - return local_node; + READ_DONE(); } static Alias * _readAlias(void) { - Alias *local_node; - char *token; - int length; - - local_node = makeNode(Alias); - - token = pg_strtok(&length); /* eat :aliasname */ - token = pg_strtok(&length); /* get aliasname */ - local_node->aliasname = debackslash(token, length); + READ_LOCALS(Alias); - token = pg_strtok(&length); /* eat :colnames */ - local_node->colnames = nodeRead(true); /* now read it */ + READ_STRING_FIELD(aliasname); + READ_NODE_FIELD(colnames); - return local_node; + READ_DONE(); } -/* ---------------- - * _readRangeTblEntry - * ---------------- +/* + * _readRangeTblEntry */ static RangeTblEntry * _readRangeTblEntry(void) { - RangeTblEntry *local_node; - char *token; - int length; + READ_LOCALS(RangeTblEntry); - local_node = makeNode(RangeTblEntry); - - token = pg_strtok(&length); /* eat :alias */ - local_node->alias = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :eref */ - local_node->eref = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :rtekind */ - token = pg_strtok(&length); /* get rtekind */ - local_node->rtekind = (RTEKind) atoi(token); + /* put alias + eref first to make dump more legible */ + READ_NODE_FIELD(alias); + READ_NODE_FIELD(eref); + READ_ENUM_FIELD(rtekind, RTEKind); switch (local_node->rtekind) { case RTE_RELATION: case RTE_SPECIAL: - token = pg_strtok(&length); /* eat :relid */ - token = pg_strtok(&length); /* get :relid */ - local_node->relid = atooid(token); + READ_OID_FIELD(relid); break; - case RTE_SUBQUERY: - token = pg_strtok(&length); /* eat :subquery */ - local_node->subquery = nodeRead(true); /* now read it */ + READ_NODE_FIELD(subquery); break; - case RTE_FUNCTION: - token = pg_strtok(&length); /* eat :funcexpr */ - local_node->funcexpr = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* eat :coldeflist */ - local_node->coldeflist = nodeRead(true); /* now read it */ - + READ_NODE_FIELD(funcexpr); + READ_NODE_FIELD(coldeflist); break; - case RTE_JOIN: - token = pg_strtok(&length); /* eat :jointype */ - token = pg_strtok(&length); /* get jointype */ - local_node->jointype = (JoinType) atoi(token); - - token = pg_strtok(&length); /* eat :joinaliasvars */ - local_node->joinaliasvars = nodeRead(true); /* now read it */ + READ_ENUM_FIELD(jointype, JoinType); + READ_NODE_FIELD(joinaliasvars); break; - default: elog(ERROR, "bogus rte kind %d", (int) local_node->rtekind); break; } - token = pg_strtok(&length); /* eat :inh */ - token = pg_strtok(&length); /* get :inh */ - local_node->inh = strtobool(token); - - token = pg_strtok(&length); /* eat :inFromCl */ - token = pg_strtok(&length); /* get :inFromCl */ - local_node->inFromCl = strtobool(token); - - token = pg_strtok(&length); /* eat :checkForRead */ - token = pg_strtok(&length); /* get :checkForRead */ - local_node->checkForRead = strtobool(token); - - token = pg_strtok(&length); /* eat :checkForWrite */ - token = pg_strtok(&length); /* get :checkForWrite */ - local_node->checkForWrite = strtobool(token); - - token = pg_strtok(&length); /* eat :checkAsUser */ - token = pg_strtok(&length); /* get :checkAsUser */ - local_node->checkAsUser = atooid(token); - - return local_node; -} - -/* ---------------- - * _readPath - * - * Path is a subclass of Node. - * ---------------- - */ -static Path * -_readPath(void) -{ - Path *local_node; - char *token; - int length; - - local_node = makeNode(Path); - - token = pg_strtok(&length); /* get :pathtype */ - token = pg_strtok(&length); /* now read it */ - local_node->pathtype = atoi(token); - - token = pg_strtok(&length); /* get :startup_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->startup_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :total_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->total_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :pathkeys */ - local_node->pathkeys = nodeRead(true); /* now read it */ - - return local_node; -} - -/* ---------------- - * _readIndexPath - * - * IndexPath is a subclass of Path. - * ---------------- - */ -static IndexPath * -_readIndexPath(void) -{ - IndexPath *local_node; - char *token; - int length; - - local_node = makeNode(IndexPath); - - token = pg_strtok(&length); /* get :pathtype */ - token = pg_strtok(&length); /* now read it */ - local_node->path.pathtype = atoi(token); - - token = pg_strtok(&length); /* get :startup_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->path.startup_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :total_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->path.total_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :pathkeys */ - local_node->path.pathkeys = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :indexinfo */ - local_node->indexinfo = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :indexqual */ - local_node->indexqual = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :indexscandir */ - token = pg_strtok(&length); /* now read it */ - local_node->indexscandir = (ScanDirection) atoi(token); - - token = pg_strtok(&length); /* get :rows */ - token = pg_strtok(&length); /* now read it */ - local_node->rows = atof(token); - - return local_node; -} - -/* ---------------- - * _readTidPath - * - * TidPath is a subclass of Path. - * ---------------- - */ -static TidPath * -_readTidPath(void) -{ - TidPath *local_node; - char *token; - int length; - - local_node = makeNode(TidPath); - - token = pg_strtok(&length); /* get :pathtype */ - token = pg_strtok(&length); /* now read it */ - local_node->path.pathtype = atoi(token); - - token = pg_strtok(&length); /* get :startup_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->path.startup_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :total_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->path.total_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :pathkeys */ - local_node->path.pathkeys = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :tideval */ - local_node->tideval = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :unjoined_relids */ - local_node->unjoined_relids = toIntList(nodeRead(true)); - - return local_node; -} - -/* ---------------- - * _readAppendPath - * - * AppendPath is a subclass of Path. - * ---------------- - */ -static AppendPath * -_readAppendPath(void) -{ - AppendPath *local_node; - char *token; - int length; - - local_node = makeNode(AppendPath); - - token = pg_strtok(&length); /* get :pathtype */ - token = pg_strtok(&length); /* now read it */ - local_node->path.pathtype = atoi(token); - - token = pg_strtok(&length); /* get :startup_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->path.startup_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :total_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->path.total_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :pathkeys */ - local_node->path.pathkeys = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :subpaths */ - local_node->subpaths = nodeRead(true); /* now read it */ - - return local_node; -} - -/* ---------------- - * _readResultPath - * - * ResultPath is a subclass of Path. - * ---------------- - */ -static ResultPath * -_readResultPath(void) -{ - ResultPath *local_node; - char *token; - int length; - - local_node = makeNode(ResultPath); - - token = pg_strtok(&length); /* get :pathtype */ - token = pg_strtok(&length); /* now read it */ - local_node->path.pathtype = atoi(token); - - token = pg_strtok(&length); /* get :startup_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->path.startup_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :total_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->path.total_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :pathkeys */ - local_node->path.pathkeys = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :subpath */ - local_node->subpath = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :constantqual */ - local_node->constantqual = nodeRead(true); /* now read it */ - - return local_node; -} - -/* ---------------- - * _readNestPath - * - * NestPath is a subclass of Path - * ---------------- - */ -static NestPath * -_readNestPath(void) -{ - NestPath *local_node; - char *token; - int length; - - local_node = makeNode(NestPath); + READ_BOOL_FIELD(inh); + READ_BOOL_FIELD(inFromCl); + READ_BOOL_FIELD(checkForRead); + READ_BOOL_FIELD(checkForWrite); + READ_OID_FIELD(checkAsUser); - token = pg_strtok(&length); /* get :pathtype */ - token = pg_strtok(&length); /* now read it */ - local_node->path.pathtype = atoi(token); - - token = pg_strtok(&length); /* get :startup_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->path.startup_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :total_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->path.total_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :pathkeys */ - local_node->path.pathkeys = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :jointype */ - token = pg_strtok(&length); /* now read it */ - local_node->jointype = (JoinType) atoi(token); - - token = pg_strtok(&length); /* get :outerjoinpath */ - local_node->outerjoinpath = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :innerjoinpath */ - local_node->innerjoinpath = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :joinrestrictinfo */ - local_node->joinrestrictinfo = nodeRead(true); /* now read it */ - - return local_node; -} - -/* ---------------- - * _readMergePath - * - * MergePath is a subclass of NestPath. - * ---------------- - */ -static MergePath * -_readMergePath(void) -{ - MergePath *local_node; - char *token; - int length; - - local_node = makeNode(MergePath); - - token = pg_strtok(&length); /* get :pathtype */ - token = pg_strtok(&length); /* now read it */ - local_node->jpath.path.pathtype = atoi(token); - - token = pg_strtok(&length); /* get :startup_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->jpath.path.startup_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :total_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->jpath.path.total_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :pathkeys */ - local_node->jpath.path.pathkeys = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :jointype */ - token = pg_strtok(&length); /* now read it */ - local_node->jpath.jointype = (JoinType) atoi(token); - - token = pg_strtok(&length); /* get :outerjoinpath */ - local_node->jpath.outerjoinpath = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :innerjoinpath */ - local_node->jpath.innerjoinpath = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :joinrestrictinfo */ - local_node->jpath.joinrestrictinfo = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :path_mergeclauses */ - local_node->path_mergeclauses = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :outersortkeys */ - local_node->outersortkeys = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :innersortkeys */ - local_node->innersortkeys = nodeRead(true); /* now read it */ - - return local_node; -} - -/* ---------------- - * _readHashPath - * - * HashPath is a subclass of NestPath. - * ---------------- - */ -static HashPath * -_readHashPath(void) -{ - HashPath *local_node; - char *token; - int length; - - local_node = makeNode(HashPath); - - token = pg_strtok(&length); /* get :pathtype */ - token = pg_strtok(&length); /* now read it */ - local_node->jpath.path.pathtype = atoi(token); - - token = pg_strtok(&length); /* get :startup_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->jpath.path.startup_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :total_cost */ - token = pg_strtok(&length); /* now read it */ - local_node->jpath.path.total_cost = (Cost) atof(token); - - token = pg_strtok(&length); /* get :pathkeys */ - local_node->jpath.path.pathkeys = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :jointype */ - token = pg_strtok(&length); /* now read it */ - local_node->jpath.jointype = (JoinType) atoi(token); - - token = pg_strtok(&length); /* get :outerjoinpath */ - local_node->jpath.outerjoinpath = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :innerjoinpath */ - local_node->jpath.innerjoinpath = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :joinrestrictinfo */ - local_node->jpath.joinrestrictinfo = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :path_hashclauses */ - local_node->path_hashclauses = nodeRead(true); /* now read it */ - - return local_node; -} - -/* ---------------- - * _readPathKeyItem - * - * PathKeyItem is a subclass of Node. - * ---------------- - */ -static PathKeyItem * -_readPathKeyItem(void) -{ - PathKeyItem *local_node; - char *token; - int length; - - local_node = makeNode(PathKeyItem); - - token = pg_strtok(&length); /* get :sortop */ - token = pg_strtok(&length); /* now read it */ - local_node->sortop = atooid(token); - - token = pg_strtok(&length); /* get :key */ - local_node->key = nodeRead(true); /* now read it */ - - return local_node; + READ_DONE(); } -/* ---------------- - * _readRestrictInfo - * - * RestrictInfo is a subclass of Node. - * ---------------- - */ -static RestrictInfo * -_readRestrictInfo(void) -{ - RestrictInfo *local_node; - char *token; - int length; - - local_node = makeNode(RestrictInfo); - - token = pg_strtok(&length); /* get :clause */ - local_node->clause = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :ispusheddown */ - token = pg_strtok(&length); /* now read it */ - local_node->ispusheddown = strtobool(token); - - token = pg_strtok(&length); /* get :subclauseindices */ - local_node->subclauseindices = nodeRead(true); /* now read it */ - - token = pg_strtok(&length); /* get :mergejoinoperator */ - token = pg_strtok(&length); /* now read it */ - local_node->mergejoinoperator = atooid(token); - - token = pg_strtok(&length); /* get :left_sortop */ - token = pg_strtok(&length); /* now read it */ - local_node->left_sortop = atooid(token); - - token = pg_strtok(&length); /* get :right_sortop */ - token = pg_strtok(&length); /* now read it */ - local_node->right_sortop = atooid(token); - token = pg_strtok(&length); /* get :hashjoinoperator */ - token = pg_strtok(&length); /* now read it */ - local_node->hashjoinoperator = atooid(token); - - /* eval_cost is not part of saved representation; compute on first use */ - local_node->eval_cost = -1; - /* ditto for this_selec */ - local_node->this_selec = -1; - /* ditto for cached pathkeys, selectivity, bucketsize */ - local_node->left_pathkey = NIL; - local_node->right_pathkey = NIL; - local_node->left_mergescansel = -1; - local_node->right_mergescansel = -1; - local_node->left_bucketsize = -1; - local_node->right_bucketsize = -1; - - return local_node; -} - -/* ---------------- - * _readJoinInfo() - * - * JoinInfo is a subclass of Node. - * ---------------- - */ -static JoinInfo * -_readJoinInfo(void) -{ - JoinInfo *local_node; - char *token; - int length; - - local_node = makeNode(JoinInfo); - - token = pg_strtok(&length); /* get :unjoined_relids */ - local_node->unjoined_relids = toIntList(nodeRead(true)); /* now read it */ - - token = pg_strtok(&length); /* get :jinfo_restrictinfo */ - local_node->jinfo_restrictinfo = nodeRead(true); /* now read it */ - - return local_node; -} - - -/* ---------------- - * parsePlanString +/* + * parseNodeString * - * Given a character string containing a plan, parsePlanString sets up the - * plan structure representing that plan. + * Given a character string representing a node tree, parseNodeString creates + * the internal node structure. * * The string to be read must already have been loaded into pg_strtok(). - * ---------------- */ Node * -parsePlanString(void) +parseNodeString(void) { - char *token; - int length; - void *return_value = NULL; + void *return_value; + READ_TEMP_LOCALS(); token = pg_strtok(&length); - if (length == 4 && strncmp(token, "PLAN", length) == 0) - return_value = _readPlan(); - else if (length == 6 && strncmp(token, "RESULT", length) == 0) - return_value = _readResult(); - else if (length == 6 && strncmp(token, "APPEND", length) == 0) - return_value = _readAppend(); - else if (length == 4 && strncmp(token, "JOIN", length) == 0) - return_value = _readJoin(); - else if (length == 8 && strncmp(token, "NESTLOOP", length) == 0) - return_value = _readNestLoop(); - else if (length == 9 && strncmp(token, "MERGEJOIN", length) == 0) - return_value = _readMergeJoin(); - else if (length == 8 && strncmp(token, "HASHJOIN", length) == 0) - return_value = _readHashJoin(); - else if (length == 4 && strncmp(token, "SCAN", length) == 0) - return_value = _readScan(); - else if (length == 7 && strncmp(token, "SEQSCAN", length) == 0) - return_value = _readSeqScan(); - else if (length == 9 && strncmp(token, "INDEXSCAN", length) == 0) - return_value = _readIndexScan(); - else if (length == 7 && strncmp(token, "TIDSCAN", length) == 0) - return_value = _readTidScan(); - else if (length == 12 && strncmp(token, "SUBQUERYSCAN", length) == 0) - return_value = _readSubqueryScan(); - else if (length == 12 && strncmp(token, "FUNCTIONSCAN", length) == 0) - return_value = _readFunctionScan(); - else if (length == 4 && strncmp(token, "SORT", length) == 0) - return_value = _readSort(); - else if (length == 6 && strncmp(token, "AGGREG", length) == 0) +#define MATCH(tokname, namelen) \ + (length == namelen && strncmp(token, tokname, namelen) == 0) + + if (MATCH("AGGREF", 6)) return_value = _readAggref(); - else if (length == 7 && strncmp(token, "SUBLINK", length) == 0) + else if (MATCH("SUBLINK", 7)) return_value = _readSubLink(); - else if (length == 11 && strncmp(token, "FIELDSELECT", length) == 0) + else if (MATCH("FIELDSELECT", 11)) return_value = _readFieldSelect(); - else if (length == 11 && strncmp(token, "RELABELTYPE", length) == 0) + else if (MATCH("RELABELTYPE", 11)) return_value = _readRelabelType(); - else if (length == 11 && strncmp(token, "RANGETBLREF", length) == 0) + else if (MATCH("RANGETBLREF", 11)) return_value = _readRangeTblRef(); - else if (length == 8 && strncmp(token, "FROMEXPR", length) == 0) + else if (MATCH("FROMEXPR", 8)) return_value = _readFromExpr(); - else if (length == 8 && strncmp(token, "JOINEXPR", length) == 0) + else if (MATCH("JOINEXPR", 8)) return_value = _readJoinExpr(); - else if (length == 4 && strncmp(token, "HASH", length) == 0) - return_value = _readHash(); - else if (length == 6 && strncmp(token, "RESDOM", length) == 0) + else if (MATCH("RESDOM", 6)) return_value = _readResdom(); - else if (length == 4 && strncmp(token, "EXPR", length) == 0) + else if (MATCH("EXPR", 4)) return_value = _readExpr(); - else if (length == 8 && strncmp(token, "ARRAYREF", length) == 0) + else if (MATCH("ARRAYREF", 8)) return_value = _readArrayRef(); - else if (length == 3 && strncmp(token, "VAR", length) == 0) + else if (MATCH("VAR", 3)) return_value = _readVar(); - else if (length == 5 && strncmp(token, "CONST", length) == 0) + else if (MATCH("CONST", 5)) return_value = _readConst(); - else if (length == 4 && strncmp(token, "FUNC", length) == 0) + else if (MATCH("FUNC", 4)) return_value = _readFunc(); - else if (length == 4 && strncmp(token, "OPER", length) == 0) + else if (MATCH("OPER", 4)) return_value = _readOper(); - else if (length == 5 && strncmp(token, "PARAM", length) == 0) + else if (MATCH("PARAM", 5)) return_value = _readParam(); - else if (length == 11 && strncmp(token, "TARGETENTRY", length) == 0) + else if (MATCH("TARGETENTRY", 11)) return_value = _readTargetEntry(); - else if (length == 8 && strncmp(token, "RANGEVAR", length) == 0) + else if (MATCH("RANGEVAR", 8)) return_value = _readRangeVar(); - else if (length == 9 && strncmp(token, "COLUMNREF", length) == 0) + else if (MATCH("COLUMNREF", 9)) return_value = _readColumnRef(); - else if (length == 9 && strncmp(token, "COLUMNDEF", length) == 0) + else if (MATCH("COLUMNDEF", 9)) return_value = _readColumnDef(); - else if (length == 8 && strncmp(token, "TYPENAME", length) == 0) + else if (MATCH("TYPENAME", 8)) return_value = _readTypeName(); - else if (length == 15 && strncmp(token, "EXPRFIELDSELECT", length) == 0) + else if (MATCH("EXPRFIELDSELECT", 15)) return_value = _readExprFieldSelect(); - else if (length == 5 && strncmp(token, "ALIAS", length) == 0) + else if (MATCH("ALIAS", 5)) return_value = _readAlias(); - else if (length == 3 && strncmp(token, "RTE", length) == 0) + else if (MATCH("RTE", 3)) return_value = _readRangeTblEntry(); - else if (length == 4 && strncmp(token, "PATH", length) == 0) - return_value = _readPath(); - else if (length == 9 && strncmp(token, "INDEXPATH", length) == 0) - return_value = _readIndexPath(); - else if (length == 7 && strncmp(token, "TIDPATH", length) == 0) - return_value = _readTidPath(); - else if (length == 10 && strncmp(token, "APPENDPATH", length) == 0) - return_value = _readAppendPath(); - else if (length == 10 && strncmp(token, "RESULTPATH", length) == 0) - return_value = _readResultPath(); - else if (length == 8 && strncmp(token, "NESTPATH", length) == 0) - return_value = _readNestPath(); - else if (length == 9 && strncmp(token, "MERGEPATH", length) == 0) - return_value = _readMergePath(); - else if (length == 8 && strncmp(token, "HASHPATH", length) == 0) - return_value = _readHashPath(); - else if (length == 11 && strncmp(token, "PATHKEYITEM", length) == 0) - return_value = _readPathKeyItem(); - else if (length == 12 && strncmp(token, "RESTRICTINFO", length) == 0) - return_value = _readRestrictInfo(); - else if (length == 8 && strncmp(token, "JOININFO", length) == 0) - return_value = _readJoinInfo(); - else if (length == 5 && strncmp(token, "QUERY", length) == 0) + else if (MATCH("QUERY", 5)) return_value = _readQuery(); - else if (length == 6 && strncmp(token, "NOTIFY", length) == 0) + else if (MATCH("NOTIFY", 6)) return_value = _readNotifyStmt(); - else if (length == 10 && strncmp(token, "SORTCLAUSE", length) == 0) + else if (MATCH("SORTCLAUSE", 10)) return_value = _readSortClause(); - else if (length == 11 && strncmp(token, "GROUPCLAUSE", length) == 0) + else if (MATCH("GROUPCLAUSE", 11)) return_value = _readGroupClause(); - else if (length == 16 && strncmp(token, "SETOPERATIONSTMT", length) == 0) + else if (MATCH("SETOPERATIONSTMT", 16)) return_value = _readSetOperationStmt(); - else if (length == 4 && strncmp(token, "CASE", length) == 0) + else if (MATCH("CASE", 4)) return_value = _readCaseExpr(); - else if (length == 4 && strncmp(token, "WHEN", length) == 0) + else if (MATCH("WHEN", 4)) return_value = _readCaseWhen(); - else if (length == 8 && strncmp(token, "NULLTEST", length) == 0) + else if (MATCH("NULLTEST", 8)) return_value = _readNullTest(); - else if (length == 11 && strncmp(token, "BOOLEANTEST", length) == 0) + else if (MATCH("BOOLEANTEST", 11)) return_value = _readBooleanTest(); - else if (length == 14 && strncmp(token, "CONSTRAINTTEST", length) == 0) + else if (MATCH("CONSTRAINTTEST", 14)) return_value = _readConstraintTest(); - else if (length == 21 && strncmp(token, "DOMAINCONSTRAINTVALUE", length) == 0) + else if (MATCH("DOMAINCONSTRAINTVALUE", 21)) return_value = _readDomainConstraintValue(); - else if (length == 19 && strncmp(token, "CONSTRAINTTESTVALUE", length) == 0) + else if (MATCH("CONSTRAINTTESTVALUE", 19)) return_value = _readConstraintTestValue(); else - elog(ERROR, "badly formatted planstring \"%.10s\"...", token); + { + elog(ERROR, "badly formatted node string \"%.32s\"...", token); + return_value = NULL; /* keep compiler quiet */ + } return (Node *) return_value; } -/*------------------------------------------------------------*/ -/* ---------------- - * readDatum +/* + * readDatum * * Given a string representation of a constant, recreate the appropriate * Datum. The string representation embeds length info, but not byValue, * so we must be told that. - * ---------------- */ static Datum readDatum(bool typbyval) |