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

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

数据库系统

开发平台：

Unix_Linux

equalfuncs.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * equalfuncs.c
  4.  *   equal functions to compare the nodes
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.39.2.1 1999/07/29 03:34:11 tgl Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. #include <string.h>
  16. #include "postgres.h"
  18. #include "nodes/nodes.h"
  19. #include "nodes/primnodes.h"
  20. #include "nodes/relation.h"
  21. #include "nodes/execnodes.h"
  22. #include "nodes/plannodes.h"
  24. #include "utils/builtins.h" /* for namestrcmp() */
  25. #include "utils/datum.h"
  26. #include "utils/elog.h"
  27. #include "storage/itemptr.h"
  29. static bool equali(List *a, List *b);
  31. /*
  32.  * Stuff from primnodes.h
  33.  */
  35. /*
  36.  * Resdom is a subclass of Node.
  37.  */
  38. static bool
  39. _equalResdom(Resdom *a, Resdom *b)
  40. {
  41. if (a->resno != b->resno)
  42. return false;
  43. if (a->restype != b->restype)
  44. return false;
  45. if (a->restypmod != b->restypmod)
  46. return false;
  47. if (strcmp(a->resname, b->resname) != 0)
  48. return false;
  49. if (a->reskey != b->reskey)
  50. return false;
  51. if (a->resgroupref != b->resgroupref)
  52. return false;
  53. if (a->reskeyop != b->reskeyop)
  54. return false;
  56. return true;
  57. }
  59. static bool
  60. _equalFjoin(Fjoin *a, Fjoin *b)
  61. {
  62. int nNodes;
  64. if (a->fj_initialized != b->fj_initialized)
  65. return false;
  66. if (a->fj_nNodes != b->fj_nNodes)
  67. return false;
  68. if (!equal(a->fj_innerNode, b->fj_innerNode))
  69. return false;
  71. nNodes = a->fj_nNodes;
  72. if (memcmp(a->fj_results, b->fj_results, nNodes * sizeof(Datum)) != 0)
  73. return false;
  74. if (memcmp(a->fj_alwaysDone, b->fj_alwaysDone, nNodes * sizeof(bool)) != 0)
  75. return false;
  77. return true;
  78. }
  80. /*
  81.  * Expr is a subclass of Node.
  82.  */
  83. static bool
  84. _equalExpr(Expr *a, Expr *b)
  85. {
  86. if (a->opType != b->opType)
  87. return false;
  88. if (!equal(a->oper, b->oper))
  89. return false;
  90. if (!equal(a->args, b->args))
  91. return false;
  93. return true;
  94. }
  96. static bool
  97. _equalIter(Iter *a, Iter *b)
  98. {
  99. return equal(a->iterexpr, b->iterexpr);
  100. }
  102. static bool
  103. _equalStream(Stream *a, Stream *b)
  104. {
  105. if (a->clausetype != b->clausetype)
  106. return false;
  107. if (a->groupup != b->groupup)
  108. return false;
  109. if (a->groupcost != b->groupcost)
  110. return false;
  111. if (a->groupsel != b->groupsel)
  112. return false;
  113. if (!equal(a->pathptr, b->pathptr))
  114. return false;
  115. if (!equal(a->cinfo, b->cinfo))
  116. return false;
  117. if (!equal(a->upstream, b->upstream))
  118. return false;
  119. return equal(a->downstream, b->downstream);
  120. }
  122. /*
  123.  * Var is a subclass of Expr.
  124.  */
  125. static bool
  126. _equalVar(Var *a, Var *b)
  127. {
  128. if (a->varno != b->varno)
  129. return false;
  130. if (a->varattno != b->varattno)
  131. return false;
  132. if (a->vartype != b->vartype)
  133. return false;
  134. if (a->vartypmod != b->vartypmod)
  135. return false;
  136. if (a->varlevelsup != b->varlevelsup)
  137. return false;
  138. if (a->varnoold != b->varnoold)
  139. return false;
  140. if (a->varoattno != b->varoattno)
  141. return false;
  143. return true;
  144. }
  146. static bool
  147. _equalArray(Array *a, Array *b)
  148. {
  149. if (a->arrayelemtype != b->arrayelemtype)
  150. return false;
  151. if (a->arrayndim != b->arrayndim)
  152. return false;
  153. if (a->arraylow.indx[0] != b->arraylow.indx[0])
  154. return false;
  155. if (a->arrayhigh.indx[0] != b->arrayhigh.indx[0])
  156. return false;
  157. if (a->arraylen != b->arraylen)
  158. return false;
  159. return TRUE;
  160. }
  162. static bool
  163. _equalArrayRef(ArrayRef *a, ArrayRef *b)
  164. {
  165. if (a->refelemtype != b->refelemtype)
  166. return false;
  167. if (a->refattrlength != b->refattrlength)
  168. return false;
  169. if (a->refelemlength != b->refelemlength)
  170. return false;
  171. if (a->refelembyval != b->refelembyval)
  172. return false;
  173. if (!equal(a->refupperindexpr, b->refupperindexpr))
  174. return false;
  175. if (!equal(a->reflowerindexpr, b->reflowerindexpr))
  176. return false;
  177. if (!equal(a->refexpr, b->refexpr))
  178. return false;
  179. return equal(a->refassgnexpr, b->refassgnexpr);
  180. }
  182. /*
  183.  * Oper is a subclass of Expr.
  184.  */
  185. static bool
  186. _equalOper(Oper *a, Oper *b)
  187. {
  188. if (a->opno != b->opno)
  189. return false;
  190. if (a->opresulttype != b->opresulttype)
  191. return false;
  193. return true;
  194. }
  196. /*
  197.  * Const is a subclass of Expr.
  198.  */
  199. static bool
  200. _equalConst(Const *a, Const *b)
  201. {
  203. /*
  204.  * * this function used to do a pointer compare on a and b.  That's *
  205.  * ridiculous. -- JMH, 7/11/92
  206.  */
  207. if (a->consttype != b->consttype)
  208. return false;
  209. if (a->constlen != b->constlen)
  210. return false;
  211. if (a->constisnull != b->constisnull)
  212. return false;
  213. if (a->constbyval != b->constbyval)
  214. return false;
  215. return (datumIsEqual(a->constvalue, b->constvalue,
  216.  a->consttype, a->constbyval, a->constlen));
  217. }
  219. /*
  220.  * Param is a subclass of Expr.
  221.  */
  222. static bool
  223. _equalParam(Param *a, Param *b)
  224. {
  225. if (a->paramkind != b->paramkind)
  226. return false;
  227. if (a->paramtype != b->paramtype)
  228. return false;
  229. if (!equal(a->param_tlist, b->param_tlist))
  230. return false;
  232. switch (a->paramkind)
  233. {
  234. case PARAM_NAMED:
  235. case PARAM_NEW:
  236. case PARAM_OLD:
  237. if (strcmp(a->paramname, b->paramname) != 0)
  238. return false;
  239. break;
  240. case PARAM_NUM:
  241. case PARAM_EXEC:
  242. if (a->paramid != b->paramid)
  243. return false;
  244. break;
  245. case PARAM_INVALID:
  247. /*
  248.  * XXX: Hmmm... What are we supposed to return in this case ??
  249.  */
  250. return true;
  251. break;
  252. default:
  253. elog(ERROR, "_equalParam: Invalid paramkind value: %d",
  254.  a->paramkind);
  255. }
  257. return true;
  258. }
  260. /*
  261.  * Aggref is a subclass of Expr.
  262.  */
  263. static bool
  264. _equalAggref(Aggref *a, Aggref *b)
  265. {
  266. if (strcmp(a->aggname, b->aggname) != 0)
  267. return false;
  268. if (a->basetype != b->basetype)
  269. return false;
  270. if (a->aggtype != b->aggtype)
  271. return false;
  272. if (!equal(a->target, b->target))
  273. return false;
  274. if (a->aggno != b->aggno)
  275. return false;
  276. if (a->usenulls != b->usenulls)
  277. return false;
  278. return true;
  279. }
  281. /*
  282.  * Func is a subclass of Expr.
  283.  */
  284. static bool
  285. _equalFunc(Func *a, Func *b)
  286. {
  287. if (a->funcid != b->funcid)
  288. return false;
  289. if (a->functype != b->functype)
  290. return false;
  291. if (a->funcisindex != b->funcisindex)
  292. return false;
  293. if (a->funcsize != b->funcsize)
  294. return false;
  295. if (!equal(a->func_tlist, b->func_tlist))
  296. return false;
  297. if (!equal(a->func_planlist, b->func_planlist))
  298. return false;
  300. return true;
  301. }
  303. /*
  304.  * RestrictInfo is a subclass of Node.
  305.  */
  306. static bool
  307. _equalRestrictInfo(RestrictInfo *a, RestrictInfo *b)
  308. {
  309. Assert(IsA(a, RestrictInfo));
  310. Assert(IsA(b, RestrictInfo));
  312. if (!equal(a->clause, b->clause))
  313. return false;
  314. if (a->selectivity != b->selectivity)
  315. return false;
  316. if (a->notclause != b->notclause)
  317. return false;
  318. #ifdef EqualMergeOrderExists
  319. if (!EqualMergeOrder(a->mergejoinorder, b->mergejoinorder))
  320. return false;
  321. #endif
  322. if (a->hashjoinoperator != b->hashjoinoperator)
  323. return false;
  324. return equal(a->indexids, b->indexids);
  325. }
  327. /*
  328.  * RelOptInfo is a subclass of Node.
  329.  */
  330. static bool
  331. _equalRelOptInfo(RelOptInfo *a, RelOptInfo *b)
  332. {
  333. Assert(IsA(a, RelOptInfo));
  334. Assert(IsA(b, RelOptInfo));
  336. return equal(a->relids, b->relids);
  337. }
  339. static bool
  340. _equalJoinMethod(JoinMethod *a, JoinMethod *b)
  341. {
  342. Assert(IsA(a, JoinMethod));
  343. Assert(IsA(b, JoinMethod));
  345. if (!equal(a->jmkeys, b->jmkeys))
  346. return false;
  347. if (!equal(a->clauses, b->clauses))
  348. return false;
  349. return true;
  350. }
  352. static bool
  353. _equalPath(Path *a, Path *b)
  354. {
  355. if (a->pathtype != b->pathtype)
  356. return false;
  357. if (a->parent != b->parent)
  358. return false;
  360. /*
  361.  * if (a->path_cost != b->path_cost) return(false);
  362.  */
  363. if (a->pathorder->ordtype == SORTOP_ORDER)
  364. {
  365. int i = 0;
  367. if (a->pathorder->ord.sortop == NULL ||
  368. b->pathorder->ord.sortop == NULL)
  369. {
  370. if (a->pathorder->ord.sortop != b->pathorder->ord.sortop)
  371. return false;
  372. }
  373. else
  374. {
  375. while (a->pathorder->ord.sortop[i] != 0 &&
  376.    b->pathorder->ord.sortop[i] != 0)
  377. {
  378. if (a->pathorder->ord.sortop[i] != b->pathorder->ord.sortop[i])
  379. return false;
  380. i++;
  381. }
  382. if (a->pathorder->ord.sortop[i] != 0 ||
  383. b->pathorder->ord.sortop[i] != 0)
  384. return false;
  385. }
  386. }
  387. else
  388. {
  389. if (!equal(a->pathorder->ord.merge, b->pathorder->ord.merge))
  390. return false;
  391. }
  392. if (!equal(a->pathkeys, b->pathkeys))
  393. return false;
  395. /*
  396.  * if (a->outerjoincost != b->outerjoincost) return(false);
  397.  */
  398. if (!equali(a->joinid, b->joinid))
  399. return false;
  400. return true;
  401. }
  403. static bool
  404. _equalIndexPath(IndexPath *a, IndexPath *b)
  405. {
  406. if (!_equalPath((Path *) a, (Path *) b))
  407. return false;
  408. if (!equali(a->indexid, b->indexid))
  409. return false;
  410. if (!equal(a->indexqual, b->indexqual))
  411. return false;
  412. return true;
  413. }
  415. static bool
  416. _equalNestPath(NestPath *a, NestPath *b)
  417. {
  418. Assert(IsA_JoinPath(a));
  419. Assert(IsA_JoinPath(b));
  421. if (!_equalPath((Path *) a, (Path *) b))
  422. return false;
  423. if (!equal(a->pathinfo, b->pathinfo))
  424. return false;
  425. if (!equal(a->outerjoinpath, b->outerjoinpath))
  426. return false;
  427. if (!equal(a->innerjoinpath, b->innerjoinpath))
  428. return false;
  429. return true;
  430. }
  432. static bool
  433. _equalMergePath(MergePath *a, MergePath *b)
  434. {
  435. Assert(IsA(a, MergePath));
  436. Assert(IsA(b, MergePath));
  438. if (!_equalNestPath((NestPath *) a, (NestPath *) b))
  439. return false;
  440. if (!equal(a->path_mergeclauses, b->path_mergeclauses))
  441. return false;
  442. if (!equal(a->outersortkeys, b->outersortkeys))
  443. return false;
  444. if (!equal(a->innersortkeys, b->innersortkeys))
  445. return false;
  446. return true;
  447. }
  449. static bool
  450. _equalHashPath(HashPath *a, HashPath *b)
  451. {
  452. Assert(IsA(a, HashPath));
  453. Assert(IsA(b, HashPath));
  455. if (!_equalNestPath((NestPath *) a, (NestPath *) b))
  456. return false;
  457. if (!equal((a->path_hashclauses), (b->path_hashclauses)))
  458. return false;
  459. if (!equal(a->outerhashkeys, b->outerhashkeys))
  460. return false;
  461. if (!equal(a->innerhashkeys, b->innerhashkeys))
  462. return false;
  463. return true;
  464. }
  466. static bool
  467. _equalJoinKey(JoinKey *a, JoinKey *b)
  468. {
  469. Assert(IsA(a, JoinKey));
  470. Assert(IsA(b, JoinKey));
  472. if (!equal(a->outer, b->outer))
  473. return false;
  474. if (!equal(a->inner, b->inner))
  475. return false;
  476. return true;
  477. }
  479. static bool
  480. _equalMergeOrder(MergeOrder *a, MergeOrder *b)
  481. {
  482. if (a == (MergeOrder *) NULL && b == (MergeOrder *) NULL)
  483. return true;
  484. Assert(IsA(a, MergeOrder));
  485. Assert(IsA(b, MergeOrder));
  487. if (a->join_operator != b->join_operator)
  488. return false;
  489. if (a->left_operator != b->left_operator)
  490. return false;
  491. if (a->right_operator != b->right_operator)
  492. return false;
  493. if (a->left_type != b->left_type)
  494. return false;
  495. if (a->right_type != b->right_type)
  496. return false;
  497. return true;
  498. }
  500. static bool
  501. _equalHashInfo(HashInfo *a, HashInfo *b)
  502. {
  503. Assert(IsA(a, HashInfo));
  504. Assert(IsA(b, HashInfo));
  506. if (a->hashop != b->hashop)
  507. return false;
  508. return true;
  509. }
  511. /* XXX This equality function is a quick hack, should be
  512.  * fixed to compare all fields.
  513.  */
  514. static bool
  515. _equalIndexScan(IndexScan *a, IndexScan *b)
  516. {
  517. Assert(IsA(a, IndexScan));
  518. Assert(IsA(b, IndexScan));
  520. /*
  521.  * if(a->scan.plan.cost != b->scan.plan.cost) return(false);
  522.  */
  524. if (!equal(a->indxqual, b->indxqual))
  525. return false;
  527. if (a->scan.scanrelid != b->scan.scanrelid)
  528. return false;
  530. if (!equali(a->indxid, b->indxid))
  531. return false;
  532. return true;
  533. }
  535. static bool
  536. _equalSubPlan(SubPlan *a, SubPlan *b)
  537. {
  538. if (a->plan_id != b->plan_id)
  539. return false;
  541. if (!equal(a->sublink->oper, b->sublink->oper))
  542. return false;
  544. return true;
  545. }
  547. static bool
  548. _equalJoinInfo(JoinInfo *a, JoinInfo *b)
  549. {
  550. Assert(IsA(a, JoinInfo));
  551. Assert(IsA(b, JoinInfo));
  552. if (!equal(a->unjoined_relids, b->unjoined_relids))
  553. return false;
  554. if (!equal(a->jinfo_restrictinfo, b->jinfo_restrictinfo))
  555. return false;
  556. if (a->mergejoinable != b->mergejoinable)
  557. return false;
  558. if (a->hashjoinable != b->hashjoinable)
  559. return false;
  560. return true;
  561. }
  563. /*
  564.  * Stuff from execnodes.h
  565.  */
  567. /*
  568.  * EState is a subclass of Node.
  569.  */
  570. static bool
  571. _equalEState(EState *a, EState *b)
  572. {
  573. if (a->es_direction != b->es_direction)
  574. return false;
  576. if (!equal(a->es_range_table, b->es_range_table))
  577. return false;
  579. if (a->es_result_relation_info != b->es_result_relation_info)
  580. return false;
  582. return true;
  583. }
  585. /*
  586.  * Stuff from parsenodes.h
  587.  */
  589. static bool
  590. _equalQuery(Query *a, Query *b)
  591. {
  592. if (a->commandType != b->commandType)
  593. return false;
  594. if (!equal(a->utilityStmt, b->utilityStmt))
  595. return false;
  596. if (a->resultRelation != b->resultRelation)
  597. return false;
  598. if (a->into && b->into)
  599. {
  600. if (strcmp(a->into, b->into) != 0)
  601. return false;
  602. }
  603. else
  604. {
  605. if (a->into != b->into)
  606. return false;
  607. }
  608. if (a->isPortal != b->isPortal)
  609. return false;
  610. if (a->isBinary != b->isBinary)
  611. return false;
  612. if (a->isTemp != b->isTemp)
  613. return false;
  614. if (a->unionall != b->unionall)
  615. return false;
  616. if (a->hasAggs != b->hasAggs)
  617. return false;
  618. if (a->hasSubLinks != b->hasSubLinks)
  619. return false;
  620. if (a->uniqueFlag && b->uniqueFlag)
  621. {
  622. if (strcmp(a->uniqueFlag, b->uniqueFlag) != 0)
  623. return false;
  624. }
  625. else
  626. {
  627. if (a->uniqueFlag != b->uniqueFlag)
  628. return false;
  629. }
  630. if (!equal(a->sortClause, b->sortClause))
  631. return false;
  632. if (!equal(a->rtable, b->rtable))
  633. return false;
  634. if (!equal(a->targetList, b->targetList))
  635. return false;
  636. if (!equal(a->qual, b->qual))
  637. return false;
  638. if (!equal(a->rowMark, b->rowMark))
  639. return false;
  640. if (!equal(a->groupClause, b->groupClause))
  641. return false;
  642. if (!equal(a->havingQual, b->havingQual))
  643. return false;
  644. if (!equal(a->intersectClause, b->intersectClause))
  645. return false;
  646. if (!equal(a->unionClause, b->unionClause))
  647. return false;
  648. if (!equal(a->limitOffset, b->limitOffset))
  649. return false;
  650. if (!equal(a->limitCount, b->limitCount))
  651. return false;
  653. /*
  654.  * We do not check the internal-to-the-planner fields base_rel_list
  655.  * and join_rel_list.  They might not be set yet, and in any case they
  656.  * should be derivable from the other fields.
  657.  */
  658. return true;
  659. }
  661. static bool
  662. _equalRangeTblEntry(RangeTblEntry *a, RangeTblEntry *b)
  663. {
  664. if (a->relname && b->relname)
  665. {
  666. if (strcmp(a->relname, b->relname) != 0)
  667. return false;
  668. }
  669. else
  670. {
  671. if (a->relname != b->relname)
  672. return false;
  673. }
  674. if (a->refname && b->refname)
  675. {
  676. if (strcmp(a->refname, b->refname) != 0)
  677. return false;
  678. }
  679. else
  680. {
  681. if (a->refname != b->refname)
  682. return false;
  683. }
  684. if (a->relid != b->relid)
  685. return false;
  686. if (a->inh != b->inh)
  687. return false;
  688. if (a->inFromCl != b->inFromCl)
  689. return false;
  690. if (a->skipAcl != b->skipAcl)
  691. return false;
  693. return true;
  694. }
  696. static bool
  697. _equalTargetEntry(TargetEntry *a, TargetEntry *b)
  698. {
  699. if (!equal(a->resdom, b->resdom))
  700. return false;
  701. if (!equal(a->fjoin, b->fjoin))
  702. return false;
  703. if (!equal(a->expr, b->expr))
  704. return false;
  706. return true;
  707. }
  709. static bool
  710. _equalCaseExpr(CaseExpr *a, CaseExpr *b)
  711. {
  712. if (a->casetype != b->casetype)
  713. return false;
  714. if (!equal(a->arg, b->arg))
  715. return false;
  716. if (!equal(a->args, b->args))
  717. return false;
  718. if (!equal(a->defresult, b->defresult))
  719. return false;
  721. return true;
  722. }
  724. static bool
  725. _equalCaseWhen(CaseWhen *a, CaseWhen *b)
  726. {
  727. if (!equal(a->expr, b->expr))
  728. return false;
  729. if (!equal(a->result, b->result))
  730. return false;
  732. return true;
  733. }
  735. /*
  736.  * Stuff from pg_list.h
  737.  */
  739. static bool
  740. _equalValue(Value *a, Value *b)
  741. {
  742. if (a->type != b->type)
  743. return false;
  745. switch (a->type)
  746. {
  747. case T_String:
  748. return strcmp(a->val.str, b->val.str);
  749. case T_Integer:
  750. return a->val.ival == b->val.ival;
  751. case T_Float:
  752. return a->val.dval == b->val.dval;
  753. default:
  754. break;
  755. }
  757. return true;
  758. }
  760. /*
  761.  * equal
  762.  *   returns whether two nodes are equal
  763.  */
  764. bool
  765. equal(void *a, void *b)
  766. {
  767. bool retval = false;
  769. if (a == b)
  770. return true;
  772. /*
  773.  * note that a!=b, so only one of them can be NULL
  774.  */
  775. if (a == NULL || b == NULL)
  776. return false;
  778. /*
  779.  * are they the same type of nodes?
  780.  */
  781. if (nodeTag(a) != nodeTag(b))
  782. return false;
  784. switch (nodeTag(a))
  785. {
  786. case T_Resdom:
  787. retval = _equalResdom(a, b);
  788. break;
  789. case T_Fjoin:
  790. retval = _equalFjoin(a, b);
  791. break;
  792. case T_Expr:
  793. retval = _equalExpr(a, b);
  794. break;
  795. case T_Iter:
  796. retval = _equalIter(a, b);
  797. break;
  798. case T_Stream:
  799. retval = _equalStream(a, b);
  800. break;
  801. case T_Var:
  802. retval = _equalVar(a, b);
  803. break;
  804. case T_Array:
  805. retval = _equalArray(a, b);
  806. break;
  807. case T_ArrayRef:
  808. retval = _equalArrayRef(a, b);
  809. break;
  810. case T_Oper:
  811. retval = _equalOper(a, b);
  812. break;
  813. case T_Const:
  814. retval = _equalConst(a, b);
  815. break;
  816. case T_Param:
  817. retval = _equalParam(a, b);
  818. break;
  819. case T_Aggref:
  820. retval = _equalAggref(a, b);
  821. break;
  822. case T_Func:
  823. retval = _equalFunc(a, b);
  824. break;
  825. case T_RestrictInfo:
  826. retval = _equalRestrictInfo(a, b);
  827. break;
  828. case T_RelOptInfo:
  829. retval = _equalRelOptInfo(a, b);
  830. break;
  831. case T_JoinMethod:
  832. retval = _equalJoinMethod(a, b);
  833. break;
  834. case T_Path:
  835. retval = _equalPath(a, b);
  836. break;
  837. case T_IndexPath:
  838. retval = _equalIndexPath(a, b);
  839. break;
  840. case T_NestPath:
  841. retval = _equalNestPath(a, b);
  842. break;
  843. case T_MergePath:
  844. retval = _equalMergePath(a, b);
  845. break;
  846. case T_HashPath:
  847. retval = _equalHashPath(a, b);
  848. break;
  849. case T_JoinKey:
  850. retval = _equalJoinKey(a, b);
  851. break;
  852. case T_MergeOrder:
  853. retval = _equalMergeOrder(a, b);
  854. break;
  855. case T_HashInfo:
  856. retval = _equalHashInfo(a, b);
  857. break;
  858. case T_IndexScan:
  859. retval = _equalIndexScan(a, b);
  860. break;
  861. case T_SubPlan:
  862. retval = _equalSubPlan(a, b);
  863. break;
  864. case T_JoinInfo:
  865. retval = _equalJoinInfo(a, b);
  866. break;
  867. case T_EState:
  868. retval = _equalEState(a, b);
  869. break;
  870. case T_Integer:
  871. case T_String:
  872. case T_Float:
  873. retval = _equalValue(a, b);
  874. break;
  875. case T_List:
  876. {
  877. List    *la = (List *) a;
  878. List    *lb = (List *) b;
  879. List    *l;
  881. if (a == NULL && b == NULL)
  882. return true;
  883. if (length(a) != length(b))
  884. return false;
  885. foreach(l, la)
  886. {
  887. if (!equal(lfirst(l), lfirst(lb)))
  888. return false;
  889. lb = lnext(lb);
  890. }
  891. retval = true;
  892. }
  893. break;
  894. case T_Query:
  895. retval = _equalQuery(a, b);
  896. break;
  897. case T_RangeTblEntry:
  898. retval = _equalRangeTblEntry(a, b);
  899. break;
  900. case T_TargetEntry:
  901. retval = _equalTargetEntry(a, b);
  902. break;
  903. case T_CaseExpr:
  904. retval = _equalCaseExpr(a, b);
  905. break;
  906. case T_CaseWhen:
  907. retval = _equalCaseWhen(a, b);
  908. break;
  909. default:
  910. elog(NOTICE, "equal: don't know whether nodes of type %d are equal",
  911.  nodeTag(a));
  912. break;
  913. }
  915. return retval;
  916. }
  918. /*
  919.  * equali
  920.  *   compares two lists of integers
  921.  *
  922.  * XXX temp hack. needs something like T_IntList
  923.  */
  924. static bool
  925. equali(List *a, List *b)
  926. {
  927. List    *la = (List *) a;
  928. List    *lb = (List *) b;
  929. List    *l;
  931. if (a == NULL && b == NULL)
  932. return true;
  933. if (length(a) != length(b))
  934. return false;
  935. foreach(l, la)
  936. {
  937. if (lfirsti(l) != lfirsti(lb))
  938. return false;
  939. lb = lnext(lb);
  940. }
  941. return true;
  942. }