开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
outfuncs.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：35k
源码类别：

数据库系统

开发平台：

Unix_Linux

outfuncs.c：源码内容
  1. /*
  2.  *
  3.  * outfuncs.c
  4.  *   routines to convert a node to ascii representation
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  * $Id: outfuncs.c,v 1.86 1999/05/25 22:41:14 momjian Exp $
  9.  *
  10.  * NOTES
  11.  *   Every (plan) node in POSTGRES has an associated "out" routine which
  12.  *   knows how to create its ascii representation. These functions are
  13.  *   useful for debugging as well as for storing plans in the system
  14.  *   catalogs (eg. indexes). This is also the plan string sent out in
  15.  *   Mariposa.
  16.  *
  17.  *   These functions update the in/out argument of type StringInfo
  18.  *   passed to them. This argument contains the string holding the ASCII
  19.  *   representation plus some other information (string length, etc.)
  20.  *
  21.  */
  22. #include <stdio.h>
  23. #include "postgres.h"
  25. #include "access/heapam.h"
  26. #include "access/htup.h"
  27. #include "utils/syscache.h"
  28. #include "utils/lsyscache.h"
  29. #include "fmgr.h"
  30. #include "utils/elog.h"
  31. #include "utils/datum.h"
  32. #include "utils/palloc.h"
  34. #include "nodes/nodes.h"
  35. #include "nodes/execnodes.h"
  36. #include "nodes/pg_list.h"
  37. #include "nodes/plannodes.h"
  38. #include "nodes/parsenodes.h"
  39. #include "nodes/primnodes.h"
  40. #include "nodes/relation.h"
  42. #include "catalog/pg_type.h"
  43. #include "lib/stringinfo.h"
  45. #include "../parse.h"
  47. static void _outDatum(StringInfo str, Datum value, Oid type);
  48. static void _outNode(StringInfo str, void *obj);
  50. /*
  51.  * _outIntList -
  52.  *    converts a List of integers
  53.  */
  54. static void
  55. _outIntList(StringInfo str, List *list)
  56. {
  57. List    *l;
  59. appendStringInfo(str, "(");
  60. foreach(l, list)
  61. appendStringInfo(str, " %d ", lfirsti(l));
  62. appendStringInfo(str, ")");
  63. }
  65. static void
  66. _outCreateStmt(StringInfo str, CreateStmt *node)
  67. {
  68. appendStringInfo(str, " CREATE :relname %s ",
  69.  stringStringInfo(node->relname));
  71. appendStringInfo(str, " :istemp %s ",
  72.  node->istemp ? "true" : "false");
  74. appendStringInfo(str, " :columns ");
  75. _outNode(str, node->tableElts);
  77. appendStringInfo(str, " :inhRelnames ");
  78. _outNode(str, node->inhRelnames);
  80. appendStringInfo(str, " :constraints ");
  81. _outNode(str, node->constraints);
  82. }
  84. static void
  85. _outIndexStmt(StringInfo str, IndexStmt *node)
  86. {
  87. appendStringInfo(str,
  88.  " INDEX :idxname %s :relname %s :accessMethod %s :indexParams ",
  89.  stringStringInfo(node->idxname),
  90.  stringStringInfo(node->relname),
  91.  stringStringInfo(node->accessMethod));
  92. _outNode(str, node->indexParams);
  94. appendStringInfo(str, " :withClause ");
  95. _outNode(str, node->withClause);
  97. appendStringInfo(str, " :whereClause ");
  98. _outNode(str, node->whereClause);
  100. appendStringInfo(str, " :rangetable ");
  101. _outNode(str, node->rangetable);
  103. appendStringInfo(str, " :lossy %s :unique %s ",
  104.  node->lossy ? "true" : "false",
  105.  node->unique ? "true" : "false");
  106. }
  108. static void
  109. _outSelectStmt(StringInfo str, SelectStmt *node)
  110. {
  111. appendStringInfo(str, "SELECT :where ");
  112. _outNode(str, node->whereClause);
  113. }
  115. static void
  116. _outFuncCall(StringInfo str, FuncCall *node)
  117. {
  118. appendStringInfo(str, "FUNCTION %s :args ", stringStringInfo(node->funcname));
  119. _outNode(str, node->args);
  120. }
  122. static void
  123. _outColumnDef(StringInfo str, ColumnDef *node)
  124. {
  125. appendStringInfo(str, " COLUMNDEF :colname %s :typename ",
  126.  stringStringInfo(node->colname));
  127. _outNode(str, node->typename);
  129. appendStringInfo(str, " :is_not_null %s :defval %s :constraints ",
  130.  node->is_not_null ? "true" : "false",
  131.  stringStringInfo(node->defval));
  132. _outNode(str, node->constraints);
  133. }
  135. static void
  136. _outTypeName(StringInfo str, TypeName *node)
  137. {
  138. appendStringInfo(str,
  139.  " TYPENAME :name %s :timezone %s :setof %s typmod %d :arrayBounds ",
  140.  stringStringInfo(node->name),
  141.  node->timezone ? "true" : "false",
  142.  node->setof ? "true" : "false",
  143.  node->typmod);
  145. appendStringInfo(str, " :arrayBounds ");
  146. _outNode(str, node->arrayBounds);
  147. }
  149. static void
  150. _outIndexElem(StringInfo str, IndexElem *node)
  151. {
  152. appendStringInfo(str, " INDEXELEM :name %s :args ",
  153.  stringStringInfo(node->name));
  154. _outNode(str, node->args);
  156. appendStringInfo(str, " :class %s :typename ", stringStringInfo(node->class));
  157. _outNode(str, node->typename);
  158. }
  160. static void
  161. _outQuery(StringInfo str, Query *node)
  162. {
  164. appendStringInfo(str, " QUERY :command %d ", node->commandType);
  166. if (node->utilityStmt)
  167. {
  168. switch (nodeTag(node->utilityStmt))
  169. {
  170. case T_CreateStmt:
  171. appendStringInfo(str, " :create %s ",
  172.  stringStringInfo(((CreateStmt *) (node->utilityStmt))->relname));
  173. _outNode(str, node->utilityStmt);
  174. break;
  176. case T_IndexStmt:
  177. appendStringInfo(str, " :index %s on %s ",
  178.  stringStringInfo(((IndexStmt *) (node->utilityStmt))->idxname),
  179.  stringStringInfo(((IndexStmt *) (node->utilityStmt))->relname));
  180. _outNode(str, node->utilityStmt);
  181. break;
  183. case T_NotifyStmt:
  184. appendStringInfo(str, " :utility %s ",
  185.  stringStringInfo(((NotifyStmt *) (node->utilityStmt))->relname));
  186. break;
  188. default:
  189. appendStringInfo(str, " :utility ? ");
  190. }
  191. }
  192. else
  193. appendStringInfo(str, " :utility <>");
  195. appendStringInfo(str,
  196.  " :resultRelation %u :into %s :isPortal %s :isBinary %s :isTemp %s :unionall %s ",
  197.  node->resultRelation,
  198.  stringStringInfo(node->into),
  199.  node->isPortal ? "true" : "false",
  200.  node->isBinary ? "true" : "false",
  201.  node->isTemp ? "true" : "false",
  202.  node->unionall ? "true" : "false");
  204. appendStringInfo(str, " :unique %s :sortClause ",
  205.  stringStringInfo(node->uniqueFlag));
  206. _outNode(str, node->sortClause);
  208. appendStringInfo(str, " :rtable ");
  209. _outNode(str, node->rtable);
  211. appendStringInfo(str, " :targetlist ");
  212. _outNode(str, node->targetList);
  214. appendStringInfo(str, " :qual ");
  215. _outNode(str, node->qual);
  217. appendStringInfo(str, " :groupClause ");
  218. _outNode(str, node->groupClause);
  220. appendStringInfo(str, " :havingQual ");
  221. _outNode(str, node->havingQual);
  223. appendStringInfo(str, " :hasAggs %s :hasSubLinks %s :unionClause ",
  224.  node->hasAggs ? "true" : "false",
  225.  node->hasSubLinks ? "true" : "false");
  226. _outNode(str, node->unionClause);
  228. appendStringInfo(str, " :intersectClause ");
  229. _outNode(str, node->intersectClause);
  231. appendStringInfo(str, " :limitOffset ");
  232. _outNode(str, node->limitOffset);
  234. appendStringInfo(str, " :limitCount ");
  235. _outNode(str, node->limitCount);
  237. appendStringInfo(str, " :rowMark ");
  238. _outNode(str, node->rowMark);
  240. }
  242. static void
  243. _outSortClause(StringInfo str, SortClause *node)
  244. {
  245. appendStringInfo(str, " SORTCLAUSE :resdom ");
  246. _outNode(str, node->resdom);
  248. appendStringInfo(str, " :opoid %u ", node->opoid);
  249. }
  251. static void
  252. _outGroupClause(StringInfo str, GroupClause *node)
  253. {
  254. appendStringInfo(str, " GROUPCLAUSE :grpOpoid %u :tleGroupref %d",
  255.  node->grpOpoid,
  256.  node->tleGroupref);
  257. }
  259. /*
  260.  * print the basic stuff of all nodes that inherit from Plan
  261.  */
  262. static void
  263. _outPlanInfo(StringInfo str, Plan *node)
  264. {
  265. appendStringInfo(str,
  266.   ":cost %g :size %d :width %d :state %s :qptargetlist ",
  267.  node->cost,
  268.  node->plan_size,
  269.  node->plan_width,
  270.  node->state ? "not-NULL" : "<>");
  271. _outNode(str, node->targetlist);
  273. appendStringInfo(str, " :qpqual ");
  274. _outNode(str, node->qual);
  276. appendStringInfo(str, " :lefttree ");
  277. _outNode(str, node->lefttree);
  279. appendStringInfo(str, " :righttree ");
  280. _outNode(str, node->righttree);
  282. appendStringInfo(str, " :extprm ");
  283. _outIntList(str, node->extParam);
  285. appendStringInfo(str, " :locprm ");
  286. _outIntList(str, node->locParam);
  288. appendStringInfo(str, " :initplan ");
  289. _outNode(str, node->initPlan);
  291. appendStringInfo(str, " :nprm %d ", node->nParamExec);
  292. }
  294. /*
  295.  * Stuff from plannodes.h
  296.  */
  297. static void
  298. _outPlan(StringInfo str, Plan *node)
  299. {
  300. appendStringInfo(str, " PLAN ");
  301. _outPlanInfo(str, (Plan *) node);
  302. }
  304. static void
  305. _outResult(StringInfo str, Result *node)
  306. {
  307. appendStringInfo(str, " RESULT ");
  308. _outPlanInfo(str, (Plan *) node);
  310. appendStringInfo(str, " :resconstantqual ");
  311. _outNode(str, node->resconstantqual);
  313. }
  315. /*
  316.  * Append is a subclass of Plan.
  317.  */
  318. static void
  319. _outAppend(StringInfo str, Append *node)
  320. {
  321. appendStringInfo(str, " APPEND ");
  322. _outPlanInfo(str, (Plan *) node);
  324. appendStringInfo(str, " :appendplans ");
  325. _outNode(str, node->appendplans);
  327. appendStringInfo(str, " :unionrtables ");
  328. _outNode(str, node->unionrtables);
  330. appendStringInfo(str,
  331.  " :inheritrelid %u :inheritrtable ",
  332.  node->inheritrelid);
  333. _outNode(str, node->inheritrtable);
  335. }
  337. /*
  338.  * Join is a subclass of Plan
  339.  */
  340. static void
  341. _outJoin(StringInfo str, Join *node)
  342. {
  343. appendStringInfo(str, " JOIN ");
  344. _outPlanInfo(str, (Plan *) node);
  346. }
  348. /*
  349.  * NestLoop is a subclass of Join
  350.  */
  351. static void
  352. _outNestLoop(StringInfo str, NestLoop *node)
  353. {
  354. appendStringInfo(str, " NESTLOOP ");
  355. _outPlanInfo(str, (Plan *) node);
  356. }
  358. /*
  359.  * MergeJoin is a subclass of Join
  360.  */
  361. static void
  362. _outMergeJoin(StringInfo str, MergeJoin *node)
  363. {
  364. appendStringInfo(str, " MERGEJOIN ");
  365. _outPlanInfo(str, (Plan *) node);
  367. appendStringInfo(str, " :mergeclauses ");
  368. _outNode(str, node->mergeclauses);
  369. }
  371. /*
  372.  * HashJoin is a subclass of Join.
  373.  */
  374. static void
  375. _outHashJoin(StringInfo str, HashJoin *node)
  376. {
  377. appendStringInfo(str, " HASHJOIN ");
  378. _outPlanInfo(str, (Plan *) node);
  380. appendStringInfo(str, " :hashclauses ");
  381. _outNode(str, node->hashclauses);
  383. appendStringInfo(str,
  384.  " :hashjoinop %u ",
  385.  node->hashjoinop);
  387. appendStringInfo(str,
  388.  " :hashdone %d ",
  389.  node->hashdone);
  390. }
  392. static void
  393. _outSubPlan(StringInfo str, SubPlan *node)
  394. {
  395. appendStringInfo(str, " SUBPLAN :plan ");
  396. _outNode(str, node->plan);
  398. appendStringInfo(str, " :planid %u :rtable ", node->plan_id);
  399. _outNode(str, node->rtable);
  401. appendStringInfo(str, " :setprm ");
  402. _outIntList(str, node->setParam);
  404. appendStringInfo(str, " :parprm ");
  405. _outIntList(str, node->parParam);
  407. appendStringInfo(str, " :slink ");
  408. _outNode(str, node->sublink);
  409. }
  411. /*
  412.  * Scan is a subclass of Node
  413.  */
  414. static void
  415. _outScan(StringInfo str, Scan *node)
  416. {
  417. appendStringInfo(str, " SCAN ");
  418. _outPlanInfo(str, (Plan *) node);
  420. appendStringInfo(str, " :scanrelid %u ", node->scanrelid);
  421. }
  423. /*
  424.  * SeqScan is a subclass of Scan
  425.  */
  426. static void
  427. _outSeqScan(StringInfo str, SeqScan *node)
  428. {
  429. appendStringInfo(str, " SEQSCAN ");
  430. _outPlanInfo(str, (Plan *) node);
  432. appendStringInfo(str, " :scanrelid %u ", node->scanrelid);
  433. }
  435. /*
  436.  * IndexScan is a subclass of Scan
  437.  */
  438. static void
  439. _outIndexScan(StringInfo str, IndexScan *node)
  440. {
  441. appendStringInfo(str, " INDEXSCAN ");
  442. _outPlanInfo(str, (Plan *) node);
  444. appendStringInfo(str, " :scanrelid %u :indxid ", node->scan.scanrelid);
  445. _outIntList(str, node->indxid);
  447. appendStringInfo(str, " :indxqual ");
  448. _outNode(str, node->indxqual);
  450. appendStringInfo(str, " :indxqualorig ");
  451. _outNode(str, node->indxqualorig);
  453. }
  455. /*
  456.  * Noname is a subclass of Plan
  457.  */
  458. static void
  459. _outNoname(StringInfo str, Noname *node)
  460. {
  461. appendStringInfo(str, " NONAME ");
  462. _outPlanInfo(str, (Plan *) node);
  464. appendStringInfo(str, " :nonameid %u :keycount %d ",
  465.  node->nonameid,
  466.  node->keycount);
  467. }
  469. /*
  470.  * Sort is a subclass of Noname
  471.  */
  472. static void
  473. _outSort(StringInfo str, Sort *node)
  474. {
  475. appendStringInfo(str, " SORT ");
  476. _outPlanInfo(str, (Plan *) node);
  478. appendStringInfo(str, " :nonameid %u :keycount %d ",
  479.  node->nonameid,
  480.  node->keycount);
  481. }
  483. static void
  484. _outAgg(StringInfo str, Agg *node)
  485. {
  487. appendStringInfo(str, " AGG ");
  488. _outPlanInfo(str, (Plan *) node);
  490. appendStringInfo(str, " :aggs ");
  491. _outNode(str, node->aggs);
  492. }
  494. static void
  495. _outGroup(StringInfo str, Group *node)
  496. {
  497. appendStringInfo(str, " GRP ");
  498. _outPlanInfo(str, (Plan *) node);
  500. /* the actual Group fields */
  501. appendStringInfo(str, " :numCols %d :tuplePerGroup %s ",
  502.  node->numCols,
  503.  node->tuplePerGroup ? "true" : "false");
  504. }
  506. /*
  507.  * For some reason, unique is a subclass of Noname.
  508.  */
  509. static void
  510. _outUnique(StringInfo str, Unique *node)
  511. {
  512. appendStringInfo(str, " UNIQUE ");
  513. _outPlanInfo(str, (Plan *) node);
  515. appendStringInfo(str, " :nonameid %u :keycount %d ",
  516.  node->nonameid,
  517.  node->keycount);
  518. }
  521. /*
  522.  * Hash is a subclass of Noname
  523.  */
  524. static void
  525. _outHash(StringInfo str, Hash *node)
  526. {
  527. appendStringInfo(str, " HASH ");
  528. _outPlanInfo(str, (Plan *) node);
  530. appendStringInfo(str, " :hashkey ");
  531. _outNode(str, node->hashkey);
  532. }
  534. /*****************************************************************************
  535.  *
  536.  * Stuff from primnodes.h.
  537.  *
  538.  *****************************************************************************/
  540. /*
  541.  * Resdom is a subclass of Node
  542.  */
  543. static void
  544. _outResdom(StringInfo str, Resdom *node)
  545. {
  546. appendStringInfo(str, " RESDOM :resno %d :restype %u :restypmod %d",
  547.  node->resno,
  548.  node->restype,
  549.  node->restypmod);
  551. appendStringInfo(str, " :resname "%s" :reskey %d :reskeyop %u",
  552.  stringStringInfo(node->resname),
  553.  node->reskey,
  554.  node->reskeyop);
  556. appendStringInfo(str, " :resgroupref %d :resjunk %s ",
  557.  node->resgroupref,
  558.  node->resjunk ? "true" : "false");
  559. }
  561. static void
  562. _outFjoin(StringInfo str, Fjoin *node)
  563. {
  564. int i;
  566. appendStringInfo(str, " FJOIN :initialized %s :nNodes %d ",
  567.  node->fj_initialized ? "true" : "false",
  568.  node->fj_nNodes);
  570. appendStringInfo(str, " :innerNode ");
  571. _outNode(str, node->fj_innerNode);
  573. appendStringInfo(str, " :results @ 0x%x :alwaysdone",
  574.  (int) node->fj_results);
  576. for (i = 0; i < node->fj_nNodes; i++)
  577. appendStringInfo(str, (node->fj_alwaysDone[i]) ? "true" : "false");
  578. }
  580. /*
  581.  * Expr is a subclass of Node
  582.  */
  583. static void
  584. _outExpr(StringInfo str, Expr *node)
  585. {
  586. char    *opstr = NULL;
  588. appendStringInfo(str, " EXPR :typeOid %u ",
  589.  node->typeOid);
  591. switch (node->opType)
  592. {
  593. case OP_EXPR:
  594. opstr = "op";
  595. break;
  596. case FUNC_EXPR:
  597. opstr = "func";
  598. break;
  599. case OR_EXPR:
  600. opstr = "or";
  601. break;
  602. case AND_EXPR:
  603. opstr = "and";
  604. break;
  605. case NOT_EXPR:
  606. opstr = "not";
  607. break;
  608. case SUBPLAN_EXPR:
  609. opstr = "subp";
  610. break;
  611. }
  612. appendStringInfo(str, " :opType %s :oper ", stringStringInfo(opstr));
  613. _outNode(str, node->oper);
  615. appendStringInfo(str, " :args ");
  616. _outNode(str, node->args);
  617. }
  619. /*
  620.  * Var is a subclass of Expr
  621.  */
  622. static void
  623. _outVar(StringInfo str, Var *node)
  624. {
  625. appendStringInfo(str,
  626. " VAR :varno %d :varattno %d :vartype %u :vartypmod %d ",
  627.  node->varno,
  628.  node->varattno,
  629.  node->vartype,
  630.  node->vartypmod);
  632. appendStringInfo(str, " :varlevelsup %u :varnoold %d :varoattno %d",
  633.  node->varlevelsup,
  634.  node->varnoold,
  635.  node->varoattno);
  636. }
  638. /*
  639.  * Const is a subclass of Expr
  640.  */
  641. static void
  642. _outConst(StringInfo str, Const *node)
  643. {
  644. appendStringInfo(str,
  645. " CONST :consttype %u :constlen %d :constisnull %s :constvalue ",
  646.  node->consttype,
  647.  node->constlen,
  648.  node->constisnull ? "true" : "false");
  650. if (node->constisnull)
  651. appendStringInfo(str, "<>");
  652. else
  653. _outDatum(str, node->constvalue, node->consttype);
  655. appendStringInfo(str, " :constbyval %s ",
  656.  node->constbyval ? "true" : "false");
  657. }
  659. /*
  660.  * Aggref
  661.  */
  662. static void
  663. _outAggref(StringInfo str, Aggref *node)
  664. {
  665. appendStringInfo(str,
  666.  " AGGREG :aggname %s :basetype %u :aggtype %u :target ",
  667.  stringStringInfo(node->aggname),
  668.  node->basetype,
  669.  node->aggtype);
  670. _outNode(str, node->target);
  672. appendStringInfo(str, ":aggno %d :usenulls %s",
  673.  node->aggno,
  674.  node->usenulls ? "true" : "false");
  675. }
  677. /*
  678.  * SubLink
  679.  */
  680. static void
  681. _outSubLink(StringInfo str, SubLink *node)
  682. {
  683. appendStringInfo(str,
  684.  " SUBLINK :subLinkType %d :useor %s :lefthand ",
  685.  node->subLinkType,
  686.  node->useor ? "true" : "false");
  687. _outNode(str, node->lefthand);
  689. appendStringInfo(str, " :oper ");
  690. _outNode(str, node->oper);
  692. appendStringInfo(str, " :subselect ");
  693. _outNode(str, node->subselect);
  694. }
  696. /*
  697.  * Array is a subclass of Expr
  698.  */
  699. static void
  700. _outArray(StringInfo str, Array *node)
  701. {
  702. int i;
  704. appendStringInfo(str,
  705.   " ARRAY :arrayelemtype %u :arrayelemlength %d :arrayelembyval %c ",
  706.  node->arrayelemtype,
  707.  node->arrayelemlength,
  708.  node->arrayelembyval ? 't' : 'f');
  710. appendStringInfo(str, " :arrayndim %d :arraylow ", node->arrayndim);
  711. for (i = 0; i < node->arrayndim; i++)
  712. appendStringInfo(str, " %d ", node->arraylow.indx[i]);
  713. appendStringInfo(str, " :arrayhigh ");
  714. for (i = 0; i < node->arrayndim; i++)
  715. appendStringInfo(str, " %d ", node->arrayhigh.indx[i]);
  716. appendStringInfo(str, " :arraylen %d ", node->arraylen);
  717. }
  719. /*
  720.  * ArrayRef is a subclass of Expr
  721.  */
  722. static void
  723. _outArrayRef(StringInfo str, ArrayRef *node)
  724. {
  725. appendStringInfo(str,
  726. " ARRAYREF :refelemtype %u :refattrlength $d :refelemlength %d ",
  727.  node->refelemtype,
  728.  node->refattrlength,
  729.  node->refelemlength);
  731. appendStringInfo(str, " :refelembyval %c :refupperindex ",
  732.  node->refelembyval ? 't' : 'f');
  733. _outNode(str, node->refupperindexpr);
  735. appendStringInfo(str, " :reflowerindex ");
  736. _outNode(str, node->reflowerindexpr);
  738. appendStringInfo(str, " :refexpr ");
  739. _outNode(str, node->refexpr);
  741. appendStringInfo(str, " :refassgnexpr ");
  742. _outNode(str, node->refassgnexpr);
  743. }
  745. /*
  746.  * Func is a subclass of Expr
  747.  */
  748. static void
  749. _outFunc(StringInfo str, Func *node)
  750. {
  751. appendStringInfo(str,
  752.    " FUNC :funcid %u :functype %u :funcisindex %s :funcsize %d ",
  753.  node->funcid,
  754.  node->functype,
  755.  node->funcisindex ? "true" : "false",
  756.  node->funcsize);
  758. appendStringInfo(str, " :func_fcache @ 0x%x :func_tlist ",
  759.  (int) node->func_fcache);
  760. _outNode(str, node->func_tlist);
  762. appendStringInfo(str, " :func_planlist ");
  763. _outNode(str, node->func_planlist);
  764. }
  766. /*
  767.  * Oper is a subclass of Expr
  768.  */
  769. static void
  770. _outOper(StringInfo str, Oper *node)
  771. {
  772. appendStringInfo(str,
  773.  " OPER :opno %u :opid %u :opresulttype %u ",
  774.  node->opno,
  775.  node->opid,
  776.  node->opresulttype);
  777. }
  779. /*
  780.  * Param is a subclass of Expr
  781.  */
  782. static void
  783. _outParam(StringInfo str, Param *node)
  784. {
  785. appendStringInfo(str,
  786.  " PARAM :paramkind %d :paramid %d :paramname %s :paramtype %u ",
  787.  node->paramkind,
  788.  node->paramid,
  789.  stringStringInfo(node->paramname),
  790.  node->paramtype);
  792. appendStringInfo(str, " :param_tlist ");
  793. _outNode(str, node->param_tlist);
  794. }
  796. /*
  797.  * Stuff from execnodes.h
  798.  */
  800. /*
  801.  * EState is a subclass of Node.
  802.  */
  803. static void
  804. _outEState(StringInfo str, EState *node)
  805. {
  806. appendStringInfo(str,
  807.  " ESTATE :direction %d :range_table ",
  808.  node->es_direction);
  809. _outNode(str, node->es_range_table);
  811. appendStringInfo(str, " :result_relation_info @ 0x%x ",
  812.  (int) (node->es_result_relation_info));
  813. }
  815. /*
  816.  * Stuff from relation.h
  817.  */
  818. static void
  819. _outRelOptInfo(StringInfo str, RelOptInfo *node)
  820. {
  821. appendStringInfo(str, " RELOPTINFO :relids ");
  822. _outIntList(str, node->relids);
  824. appendStringInfo(str,
  825.  " :indexed %s :pages %u :tuples %u :size %u :width %u :targetlist ",
  826.  node->indexed ? "true" : "false",
  827.  node->pages,
  828.  node->tuples,
  829.  node->size,
  830.  node->width);
  831. _outNode(str, node->targetlist);
  833. appendStringInfo(str, " :pathlist ");
  834. _outNode(str, node->pathlist);
  836. /*
  837.  * Not sure if these are nodes or not. They're declared as struct
  838.  * Path *. Since i don't know, i'll just print the addresses for now.
  839.  * This can be changed later, if necessary.
  840.  */
  842. appendStringInfo(str,
  843.  " :cheapestpath @ 0x%x :pruneable %s :restrictinfo ",
  844.  (int) node->cheapestpath,
  845.  node->pruneable ? "true" : "false");
  846. _outNode(str, node->restrictinfo);
  848. appendStringInfo(str, " :joininfo ");
  849. _outNode(str, node->joininfo);
  851. appendStringInfo(str, " :innerjoin ");
  852. _outNode(str, node->innerjoin);
  853. }
  855. /*
  856.  * TargetEntry is a subclass of Node.
  857.  */
  858. static void
  859. _outTargetEntry(StringInfo str, TargetEntry *node)
  860. {
  861. appendStringInfo(str, " TARGETENTRY :resdom ");
  862. _outNode(str, node->resdom);
  864. appendStringInfo(str, " :expr ");
  865. _outNode(str, node->expr);
  866. }
  868. static void
  869. _outRangeTblEntry(StringInfo str, RangeTblEntry *node)
  870. {
  871. appendStringInfo(str,
  872.  " RTE :relname %s :refname %s :relid %u :inh %s :inFromCl %s :skipAcl %s",
  873.  stringStringInfo(node->relname),
  874.  stringStringInfo(node->refname),
  875.  node->relid,
  876.  node->inh ? "true" : "false",
  877.  node->inFromCl ? "true" : "false",
  878.  node->skipAcl ? "true" : "false");
  879. }
  881. static void
  882. _outRowMark(StringInfo str, RowMark *node)
  883. {
  884. appendStringInfo(str, " ROWMARK :rti %u :info %u", node->rti, node->info);
  885. }
  887. /*
  888.  * Path is a subclass of Node.
  889.  */
  890. static void
  891. _outPathOrder(StringInfo str, PathOrder *node)
  892. {
  893. appendStringInfo(str, " PATHORDER :ordtype %d ",
  894.  node->ordtype);
  895. if (node->ordtype == SORTOP_ORDER)
  896. {
  897. int i;
  899. appendStringInfo(str, " :sortop ");
  900. if (node->ord.sortop == NULL)
  901. appendStringInfo(str, "<>");
  902. else
  903. {
  904. for (i = 0; node->ord.sortop[i] != 0; i++)
  905. appendStringInfo(str, " %d ", node->ord.sortop[i]);
  906. appendStringInfo(str, " %d ", 0);
  907. }
  908. }
  909. else
  910. {
  911. appendStringInfo(str, " :merge ");
  912. _outNode(str, node->ord.merge);
  913. }
  914. }
  916. /*
  917.  * Path is a subclass of Node.
  918.  */
  919. static void
  920. _outPath(StringInfo str, Path *node)
  921. {
  922. appendStringInfo(str, " PATH :pathtype %d :cost %f :pathkeys ",
  923.  node->pathtype,
  924.  node->path_cost);
  925. _outNode(str, node->pathkeys);
  927. appendStringInfo(str, " :pathorder ");
  928. _outNode(str, node->pathorder);
  929. }
  931. /*
  932.  * IndexPath is a subclass of Path.
  933.  */
  934. static void
  935. _outIndexPath(StringInfo str, IndexPath *node)
  936. {
  937. appendStringInfo(str,
  938.  " INDEXPATH :pathtype %d :cost %f :pathkeys ",
  939.  node->path.pathtype,
  940.  node->path.path_cost);
  941. _outNode(str, node->path.pathkeys);
  943. appendStringInfo(str, " :pathorder ");
  944. _outNode(str, node->path.pathorder);
  946. appendStringInfo(str, " :indexid ");
  947. _outIntList(str, node->indexid);
  949. appendStringInfo(str, " :indexqual ");
  950. _outNode(str, node->indexqual);
  951. }
  953. /*
  954.  * NestPath is a subclass of Path
  955.  */
  956. static void
  957. _outNestPath(StringInfo str, NestPath *node)
  958. {
  959. appendStringInfo(str,
  960.  " NESTPATH :pathtype %d :cost %f :pathkeys ",
  961.  node->path.pathtype,
  962.  node->path.path_cost);
  963. _outNode(str, node->path.pathkeys);
  965. appendStringInfo(str, " :pathorder ");
  966. _outNode(str, node->path.pathorder);
  968. appendStringInfo(str, " :pathinfo ");
  969. _outNode(str, node->pathinfo);
  971. /*
  972.  * Not sure if these are nodes; they're declared as "struct path *".
  973.  * For now, i'll just print the addresses.
  974.  */
  976. appendStringInfo(str,
  977.  " :outerjoinpath @ 0x%x :innerjoinpath @ 0x%x :outjoincost %f :joinid ",
  978.  (int) node->outerjoinpath,
  979.  (int) node->innerjoinpath,
  980.  node->path.outerjoincost);
  981. _outIntList(str, node->path.joinid);
  982. }
  984. /*
  985.  * MergePath is a subclass of NestPath.
  986.  */
  987. static void
  988. _outMergePath(StringInfo str, MergePath *node)
  989. {
  990. appendStringInfo(str,
  991.  " MERGEPATH :pathtype %d :cost %f :pathkeys ",
  992.  node->jpath.path.pathtype,
  993.  node->jpath.path.path_cost);
  994. _outNode(str, node->jpath.path.pathkeys);
  996. appendStringInfo(str, " :pathorder ");
  997. _outNode(str, node->jpath.path.pathorder);
  999. appendStringInfo(str, " :pathinfo ");
  1000. _outNode(str, node->jpath.pathinfo);
  1002. /*
  1003.  * Not sure if these are nodes; they're declared as "struct path *".
  1004.  * For now, i'll just print the addresses.
  1005.  */
  1007. appendStringInfo(str,
  1008.  " :outerjoinpath @ 0x%x :innerjoinpath @ 0x%x :outerjoincost %f :joinid ",
  1009.  (int) node->jpath.outerjoinpath,
  1010.  (int) node->jpath.innerjoinpath,
  1011.  (int) node->jpath.path.outerjoincost);
  1012. _outIntList(str, node->jpath.path.joinid);
  1014. appendStringInfo(str, " :path_mergeclauses ");
  1015. _outNode(str, node->path_mergeclauses);
  1017. appendStringInfo(str, " :outersortkeys ");
  1018. _outNode(str, node->outersortkeys);
  1020. appendStringInfo(str, " :innersortkeys ");
  1021. _outNode(str, node->innersortkeys);
  1022. }
  1024. /*
  1025.  * HashPath is a subclass of NestPath.
  1026.  */
  1027. static void
  1028. _outHashPath(StringInfo str, HashPath *node)
  1029. {
  1030. appendStringInfo(str,
  1031.  " HASHPATH :pathtype %d :cost %f :pathkeys ",
  1032.  node->jpath.path.pathtype,
  1033.  node->jpath.path.path_cost);
  1034. _outNode(str, node->jpath.path.pathkeys);
  1036. appendStringInfo(str, " :pathorder ");
  1037. _outNode(str, node->jpath.path.pathorder);
  1039. appendStringInfo(str, " :pathinfo ");
  1040. _outNode(str, node->jpath.pathinfo);
  1042. /*
  1043.  * Not sure if these are nodes; they're declared as "struct path *".
  1044.  * For now, i'll just print the addresses.
  1045.  */
  1047. appendStringInfo(str,
  1048.  " :outerjoinpath @ 0x%x :innerjoinpath @ 0x%x :outerjoincost %f :joinid ",
  1049.  (int) node->jpath.outerjoinpath,
  1050.  (int) node->jpath.innerjoinpath,
  1051.  node->jpath.path.outerjoincost);
  1052. _outIntList(str, node->jpath.path.joinid);
  1054. appendStringInfo(str, " :path_hashclauses ");
  1055. _outNode(str, node->path_hashclauses);
  1057. appendStringInfo(str, " :outerhashkeys ");
  1058. _outNode(str, node->outerhashkeys);
  1060. appendStringInfo(str, " :innerhashkeys ");
  1061. _outNode(str, node->innerhashkeys);
  1062. }
  1064. /*
  1065.  * OrderKey is a subclass of Node.
  1066.  */
  1067. static void
  1068. _outOrderKey(StringInfo str, OrderKey *node)
  1069. {
  1070. appendStringInfo(str,
  1071.  " ORDERKEY :attribute_number %d :array_index %d ",
  1072.  node->attribute_number,
  1073.  node->array_index);
  1074. }
  1076. /*
  1077.  * JoinKey is a subclass of Node.
  1078.  */
  1079. static void
  1080. _outJoinKey(StringInfo str, JoinKey *node)
  1081. {
  1082. appendStringInfo(str, " JOINKEY :outer ");
  1083. _outNode(str, node->outer);
  1085. appendStringInfo(str, " :inner ");
  1086. _outNode(str, node->inner);
  1088. }
  1090. /*
  1091.  * MergeOrder is a subclass of Node.
  1092.  */
  1093. static void
  1094. _outMergeOrder(StringInfo str, MergeOrder *node)
  1095. {
  1096. appendStringInfo(str,
  1097. " MERGEORDER :join_operator %u :left_operator %u :right_operator %u ",
  1098.  node->join_operator,
  1099.  node->left_operator,
  1100.  node->right_operator);
  1102. appendStringInfo(str,
  1103.  " :left_type %u :right_type %u ",
  1104.  node->left_type,
  1105.  node->right_type);
  1106. }
  1108. /*
  1109.  * RestrictInfo is a subclass of Node.
  1110.  */
  1111. static void
  1112. _outRestrictInfo(StringInfo str, RestrictInfo *node)
  1113. {
  1114. appendStringInfo(str, " RESTRICTINFO :clause ");
  1115. _outNode(str, node->clause);
  1117. appendStringInfo(str,
  1118.  " :selectivity %f :notclause %s :indexids ",
  1119.  node->selectivity,
  1120.  node->notclause ? "true" : "false");
  1121. _outNode(str, node->indexids);
  1123. appendStringInfo(str, " :mergejoinorder ");
  1124. _outNode(str, node->mergejoinorder);
  1126. appendStringInfo(str, " :hashjoinoperator %u ", node->hashjoinoperator);
  1128. }
  1130. /*
  1131.  * JoinMethod is a subclass of Node.
  1132.  */
  1133. static void
  1134. _outJoinMethod(StringInfo str, JoinMethod *node)
  1135. {
  1136. appendStringInfo(str, " JOINMETHOD :jmkeys ");
  1137. _outNode(str, node->jmkeys);
  1139. appendStringInfo(str, " :clauses ");
  1140. _outNode(str, node->clauses);
  1141. }
  1143. /*
  1144.  * HashInfo is a subclass of JoinMethod.
  1145.  */
  1146. static void
  1147. _outHashInfo(StringInfo str, HashInfo *node)
  1148. {
  1149. appendStringInfo(str, " HASHINFO :hashop %u :jmkeys ", node->hashop);
  1150. _outNode(str, node->jmethod.jmkeys);
  1152. appendStringInfo(str, " :clauses ");
  1153. _outNode(str, node->jmethod.clauses);
  1154. }
  1156. /*
  1157.  * JoinInfo is a subclass of Node.
  1158.  */
  1159. static void
  1160. _outJoinInfo(StringInfo str, JoinInfo *node)
  1161. {
  1162. appendStringInfo(str, " JINFO :unjoined_relids ");
  1163. _outIntList(str, node->unjoined_relids);
  1165. appendStringInfo(str, " :jinfo_restrictinfo ");
  1166. _outNode(str, node->jinfo_restrictinfo);
  1168. appendStringInfo(str, " :mergejoinable %s :hashjoinable %s ",
  1169.  node->mergejoinable ? "true" : "false",
  1170.  node->hashjoinable ? "true" : "false");
  1171. }
  1173. /*
  1174.  * Print the value of a Datum given its type.
  1175.  */
  1176. static void
  1177. _outDatum(StringInfo str, Datum value, Oid type)
  1178. {
  1179. char    *s;
  1180. Size length,
  1181. typeLength;
  1182. bool byValue;
  1183. int i;
  1185. /*
  1186.  * find some information about the type and the "real" length of the
  1187.  * datum.
  1188.  */
  1189. byValue = get_typbyval(type);
  1190. typeLength = get_typlen(type);
  1191. length = datumGetSize(value, type, byValue, typeLength);
  1193. if (byValue)
  1194. {
  1195. s = (char *) (&value);
  1196. appendStringInfo(str, " %d [ ", length);
  1197. for (i = 0; i < sizeof(Datum); i++)
  1198. appendStringInfo(str, " %d ", (int) (s[i]));
  1199. appendStringInfo(str, "] ");
  1200. }
  1201. else
  1202. { /* !byValue */
  1203. s = (char *) DatumGetPointer(value);
  1204. if (!PointerIsValid(s))
  1205. appendStringInfo(str, " 0 [ ] ");
  1206. else
  1207. {
  1209. /*
  1210.  * length is unsigned - very bad to do < comparison to -1
  1211.  * without casting it to int first!! -mer 8 Jan 1991
  1212.  */
  1213. if (((int) length) <= -1)
  1214. length = VARSIZE(s);
  1215. appendStringInfo(str, " %d [ ", length);
  1216. for (i = 0; i < length; i++)
  1217. appendStringInfo(str, " %d ", (int) (s[i]));
  1218. appendStringInfo(str, "] ");
  1219. }
  1220. }
  1221. }
  1223. static void
  1224. _outIter(StringInfo str, Iter *node)
  1225. {
  1226. appendStringInfo(str, " ITER :iterexpr ");
  1227. _outNode(str, node->iterexpr);
  1228. }
  1230. static void
  1231. _outStream(StringInfo str, Stream *node)
  1232. {
  1233. appendStringInfo(str,
  1234.  " STREAM :pathptr @ 0x%x :cinfo @ 0x%x :clausetype %d :upstream @ 0x%x ",
  1235.  (int) node->pathptr,
  1236.  (int) node->cinfo,
  1237.  (int) node->clausetype,
  1238.  (int) node->upstream);
  1240. appendStringInfo(str,
  1241.    " :downstream @ 0x%x :groupup %d :groupcost %f :groupsel %f ",
  1242.  (int) node->downstream,
  1243.  node->groupup,
  1244.  node->groupcost,
  1245.  node->groupsel);
  1246. }
  1248. static void
  1249. _outAExpr(StringInfo str, A_Expr *node)
  1250. {
  1251. appendStringInfo(str, "EXPR ");
  1252. switch (node->oper)
  1253. {
  1254. case AND:
  1255. appendStringInfo(str, "AND");
  1256. break;
  1257. case OR:
  1258. appendStringInfo(str, "OR");
  1259. break;
  1260. case NOT:
  1261. appendStringInfo(str, "NOT");
  1262. break;
  1263. case ISNULL:
  1264. appendStringInfo(str, "ISNULL");
  1265. break;
  1266. case NOTNULL:
  1267. appendStringInfo(str, "NOTNULL");
  1268. break;
  1269. default:
  1270. appendStringInfo(str, stringStringInfo(node->opname));
  1271. break;
  1272. }
  1273. _outNode(str, node->lexpr);
  1274. _outNode(str, node->rexpr);
  1275. return;
  1276. }
  1278. static void
  1279. _outValue(StringInfo str, Value *value)
  1280. {
  1281. switch (value->type)
  1282. {
  1283. case T_String:
  1284. appendStringInfo(str, " "%s" ", stringStringInfo(value->val.str));
  1285. break;
  1286. case T_Integer:
  1287. appendStringInfo(str, " %ld ", value->val.ival);
  1288. break;
  1289. case T_Float:
  1290. appendStringInfo(str, " %f ", value->val.dval);
  1291. break;
  1292. default:
  1293. break;
  1294. }
  1295. return;
  1296. }
  1298. static void
  1299. _outIdent(StringInfo str, Ident *node)
  1300. {
  1301. appendStringInfo(str, " IDENT "%s" ", stringStringInfo(node->name));
  1302. return;
  1303. }
  1305. static void
  1306. _outAttr(StringInfo str, Attr *node)
  1307. {
  1308. List    *l;
  1310. appendStringInfo(str, " ATTR "%s" ", stringStringInfo(node->relname));
  1312. appendStringInfo(str, "(");
  1313. foreach(l, node->attrs)
  1314. {
  1315. _outNode(str, lfirst(l));
  1316. if (lnext(l))
  1317. appendStringInfo(str, ",");
  1318. }
  1319. appendStringInfo(str, ")");
  1320. return;
  1321. }
  1323. static void
  1324. _outAConst(StringInfo str, A_Const *node)
  1325. {
  1326. appendStringInfo(str, "CONST ");
  1327. _outValue(str, &(node->val));
  1328. return;
  1329. }
  1331. static void
  1332. _outConstraint(StringInfo str, Constraint *node)
  1333. {
  1334. appendStringInfo(str, " %s :type", stringStringInfo(node->name));
  1336. switch (node->contype)
  1337. {
  1338. case CONSTR_PRIMARY:
  1339. appendStringInfo(str, " PRIMARY KEY ");
  1340. _outNode(str, node->keys);
  1341. break;
  1343. case CONSTR_CHECK:
  1344. appendStringInfo(str, " CHECK %s", stringStringInfo(node->def));
  1345. break;
  1347. case CONSTR_DEFAULT:
  1348. appendStringInfo(str, " DEFAULT %s", stringStringInfo(node->def));
  1349. break;
  1351. case CONSTR_NOTNULL:
  1352. appendStringInfo(str, " NOT NULL ");
  1353. break;
  1355. case CONSTR_UNIQUE:
  1356. appendStringInfo(str, " UNIQUE ");
  1357. _outNode(str, node->keys);
  1358. break;
  1360. default:
  1361. appendStringInfo(str, "<unrecognized constraint>");
  1362. break;
  1363. }
  1364. return;
  1365. }
  1367. static void
  1368. _outCaseExpr(StringInfo str, CaseExpr *node)
  1369. {
  1370. appendStringInfo(str, "CASE ");
  1371. _outNode(str, node->args);
  1373. appendStringInfo(str, " :default ");
  1374. _outNode(str, node->defresult);
  1376. return;
  1377. }
  1379. static void
  1380. _outCaseWhen(StringInfo str, CaseWhen *node)
  1381. {
  1382. appendStringInfo(str, " WHEN ");
  1383. _outNode(str, node->expr);
  1385. appendStringInfo(str, " :then ");
  1386. _outNode(str, node->result);
  1388. return;
  1389. }
  1391. /*
  1392.  * _outNode -
  1393.  *   converts a Node into ascii string and append it to 'str'
  1394.  */
  1395. static void
  1396. _outNode(StringInfo str, void *obj)
  1397. {
  1398. if (obj == NULL)
  1399. {
  1400. appendStringInfo(str, "<>");
  1401. return;
  1402. }
  1404. if (nodeTag(obj) == T_List)
  1405. {
  1406. List    *l;
  1408. appendStringInfo(str, "(");
  1409. foreach(l, (List *) obj)
  1410. {
  1411. _outNode(str, lfirst(l));
  1412. if (lnext(l))
  1413. appendStringInfo(str, " ");
  1414. }
  1415. appendStringInfo(str, ")");
  1416. }
  1417. else
  1418. {
  1419. appendStringInfo(str, "{");
  1420. switch (nodeTag(obj))
  1421. {
  1422. case T_CreateStmt:
  1423. _outCreateStmt(str, obj);
  1424. break;
  1425. case T_IndexStmt:
  1426. _outIndexStmt(str, obj);
  1427. break;
  1429. case T_ColumnDef:
  1430. _outColumnDef(str, obj);
  1431. break;
  1432. case T_TypeName:
  1433. _outTypeName(str, obj);
  1434. break;
  1435. case T_IndexElem:
  1436. _outIndexElem(str, obj);
  1437. break;
  1438. case T_Query:
  1439. _outQuery(str, obj);
  1440. break;
  1441. case T_SortClause:
  1442. _outSortClause(str, obj);
  1443. break;
  1444. case T_GroupClause:
  1445. _outGroupClause(str, obj);
  1446. break;
  1447. case T_Plan:
  1448. _outPlan(str, obj);
  1449. break;
  1450. case T_Result:
  1451. _outResult(str, obj);
  1452. break;
  1453. case T_Append:
  1454. _outAppend(str, obj);
  1455. break;
  1456. case T_Join:
  1457. _outJoin(str, obj);
  1458. break;
  1459. case T_NestLoop:
  1460. _outNestLoop(str, obj);
  1461. break;
  1462. case T_MergeJoin:
  1463. _outMergeJoin(str, obj);
  1464. break;
  1465. case T_HashJoin:
  1466. _outHashJoin(str, obj);
  1467. break;
  1468. case T_Scan:
  1469. _outScan(str, obj);
  1470. break;
  1471. case T_SeqScan:
  1472. _outSeqScan(str, obj);
  1473. break;
  1474. case T_IndexScan:
  1475. _outIndexScan(str, obj);
  1476. break;
  1477. case T_Noname:
  1478. _outNoname(str, obj);
  1479. break;
  1480. case T_Sort:
  1481. _outSort(str, obj);
  1482. break;
  1483. case T_Agg:
  1484. _outAgg(str, obj);
  1485. break;
  1486. case T_Group:
  1487. _outGroup(str, obj);
  1488. break;
  1489. case T_Unique:
  1490. _outUnique(str, obj);
  1491. break;
  1492. case T_Hash:
  1493. _outHash(str, obj);
  1494. break;
  1495. case T_SubPlan:
  1496. _outSubPlan(str, obj);
  1497. break;
  1498. case T_Resdom:
  1499. _outResdom(str, obj);
  1500. break;
  1501. case T_Fjoin:
  1502. _outFjoin(str, obj);
  1503. break;
  1504. case T_Expr:
  1505. _outExpr(str, obj);
  1506. break;
  1507. case T_Var:
  1508. _outVar(str, obj);
  1509. break;
  1510. case T_Const:
  1511. _outConst(str, obj);
  1512. break;
  1513. case T_Aggref:
  1514. _outAggref(str, obj);
  1515. break;
  1516. case T_SubLink:
  1517. _outSubLink(str, obj);
  1518. break;
  1519. case T_Array:
  1520. _outArray(str, obj);
  1521. break;
  1522. case T_ArrayRef:
  1523. _outArrayRef(str, obj);
  1524. break;
  1525. case T_Func:
  1526. _outFunc(str, obj);
  1527. break;
  1528. case T_Oper:
  1529. _outOper(str, obj);
  1530. break;
  1531. case T_Param:
  1532. _outParam(str, obj);
  1533. break;
  1534. case T_EState:
  1535. _outEState(str, obj);
  1536. break;
  1537. case T_RelOptInfo:
  1538. _outRelOptInfo(str, obj);
  1539. break;
  1540. case T_TargetEntry:
  1541. _outTargetEntry(str, obj);
  1542. break;
  1543. case T_RangeTblEntry:
  1544. _outRangeTblEntry(str, obj);
  1545. break;
  1546. case T_RowMark:
  1547. _outRowMark(str, obj);
  1548. break;
  1549. case T_PathOrder:
  1550. _outPathOrder(str, obj);
  1551. break;
  1552. case T_Path:
  1553. _outPath(str, obj);
  1554. break;
  1555. case T_IndexPath:
  1556. _outIndexPath(str, obj);
  1557. break;
  1558. case T_NestPath:
  1559. _outNestPath(str, obj);
  1560. break;
  1561. case T_MergePath:
  1562. _outMergePath(str, obj);
  1563. break;
  1564. case T_HashPath:
  1565. _outHashPath(str, obj);
  1566. break;
  1567. case T_OrderKey:
  1568. _outOrderKey(str, obj);
  1569. break;
  1570. case T_JoinKey:
  1571. _outJoinKey(str, obj);
  1572. break;
  1573. case T_MergeOrder:
  1574. _outMergeOrder(str, obj);
  1575. break;
  1576. case T_RestrictInfo:
  1577. _outRestrictInfo(str, obj);
  1578. break;
  1579. case T_JoinMethod:
  1580. _outJoinMethod(str, obj);
  1581. break;
  1582. case T_HashInfo:
  1583. _outHashInfo(str, obj);
  1584. break;
  1585. case T_JoinInfo:
  1586. _outJoinInfo(str, obj);
  1587. break;
  1588. case T_Iter:
  1589. _outIter(str, obj);
  1590. break;
  1591. case T_Stream:
  1592. _outStream(str, obj);
  1593. break;
  1594. case T_Integer:
  1595. case T_String:
  1596. case T_Float:
  1597. _outValue(str, obj);
  1598. break;
  1599. case T_A_Expr:
  1600. _outAExpr(str, obj);
  1601. break;
  1602. case T_Ident:
  1603. _outIdent(str, obj);
  1604. break;
  1605. case T_A_Const:
  1606. _outAConst(str, obj);
  1607. break;
  1608. case T_Constraint:
  1609. _outConstraint(str, obj);
  1610. break;
  1611. case T_CaseExpr:
  1612. _outCaseExpr(str, obj);
  1613. break;
  1614. case T_CaseWhen:
  1615. _outCaseWhen(str, obj);
  1616. break;
  1618. case T_VariableSetStmt:
  1619. break;
  1620. case T_SelectStmt:
  1621. _outSelectStmt(str, obj);
  1622. break;
  1623. case T_FuncCall:
  1624. _outFuncCall(str, obj);
  1625. break;
  1626. case T_Attr:
  1627. _outAttr(str, obj);
  1628. break;
  1630. default:
  1631. elog(NOTICE, "_outNode: don't know how to print type %d ",
  1632.  nodeTag(obj));
  1633. break;
  1634. }
  1635. appendStringInfo(str, "}");
  1636. }
  1637. return;
  1638. }
  1640. /*
  1641.  * nodeToString -
  1642.  *    returns the ascii representation of the Node as a palloc'd string
  1643.  */
  1644. char *
  1645. nodeToString(void *obj)
  1646. {
  1647. StringInfoData str;
  1649. /* see stringinfo.h for an explanation of this maneuver */
  1650. initStringInfo(&str);
  1651. _outNode(&str, obj);
  1652. return str.data;
  1653. }