granicus.if.org Git - postgresql/blob - src/backend/nodes/freefuncs.c

   1  /*-------------------------------------------------------------------------
   2  *
   3  * freefuncs.c
   4  *        Free functions for Postgres tree nodes.
   5  *
   6  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        $Header: /cvsroot/pgsql/src/backend/nodes/Attic/freefuncs.c,v 1.37 2000/02/20 21:32:05 tgl Exp $
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15
  16 #include "postgres.h"
  17
  18 #include "optimizer/planmain.h"
  19 #include "access/heapam.h"
  20
  21 /* ****************************************************************
  22  *                                       plannodes.h free functions
  23  * ****************************************************************
  24  */
  25 static void freeObject(void *obj);
  26
  27 /* ----------------
  28  *              FreePlanFields
  29  *
  30  *              This function frees the fields of the Plan node.  It is used by
  31  *              all the free functions for classes which inherit node Plan.
  32  * ----------------
  33  */
  34 static void
  35 FreePlanFields(Plan *node)
  36 {
  37         freeObject(node->targetlist);
  38         freeObject(node->qual);
  39         freeObject(node->lefttree);
  40         freeObject(node->righttree);
  41         freeList(node->extParam);
  42         freeList(node->locParam);
  43         freeList(node->chgParam);
  44         freeObject(node->initPlan);
  45         freeList(node->subPlan);
  46 }
  47
  48 /* ----------------
  49  *              _freePlan
  50  * ----------------
  51  */
  52 static void
  53 _freePlan(Plan *node)
  54 {
  55         /* ----------------
  56          *      free the node superclass fields
  57          * ----------------
  58          */
  59         FreePlanFields(node);
  60
  61         /* ----------------
  62          *      free remainder of node
  63          * ----------------
  64          */
  65         pfree(node);
  66 }
  67
  68
  69 /* ----------------
  70  *              _freeResult
  71  * ----------------
  72  */
  73 static void
  74 _freeResult(Result *node)
  75 {
  76         /* ----------------
  77          *      free node superclass fields
  78          * ----------------
  79          */
  80         FreePlanFields((Plan *) node);
  81
  82         /* ----------------
  83          *      free remainder of node
  84          * ----------------
  85          */
  86         freeObject(node->resconstantqual);
  87
  88         pfree(node);
  89 }
  90
  91 /* ----------------
  92  *              _freeAppend
  93  * ----------------
  94  */
  95 static void
  96 _freeAppend(Append *node)
  97 {
  98         /* ----------------
  99          *      free node superclass fields
 100          * ----------------
 101          */
 102         FreePlanFields((Plan *) node);
 103
 104         /* ----------------
 105          *      free remainder of node
 106          * ----------------
 107          */
 108         freeObject(node->appendplans);
 109         freeObject(node->unionrtables);
 110         freeObject(node->inheritrtable);
 111
 112         pfree(node);
 113 }
 114
 115
 116 /* ----------------
 117  *              FreeScanFields
 118  *
 119  *              This function frees the fields of the Scan node.  It is used by
 120  *              all the free functions for classes which inherit node Scan.
 121  * ----------------
 122  */
 123 static void
 124 FreeScanFields(Scan *node)
 125 {
 126 }
 127
 128 /* ----------------
 129  *              _freeScan
 130  * ----------------
 131  */
 132 static void
 133 _freeScan(Scan *node)
 134 {
 135         /* ----------------
 136          *      free node superclass fields
 137          * ----------------
 138          */
 139         FreePlanFields((Plan *) node);
 140         FreeScanFields((Scan *) node);
 141
 142         pfree(node);
 143 }
 144
 145 /* ----------------
 146  *              _freeSeqScan
 147  * ----------------
 148  */
 149 static void
 150 _freeSeqScan(SeqScan *node)
 151 {
 152         /* ----------------
 153          *      free node superclass fields
 154          * ----------------
 155          */
 156         FreePlanFields((Plan *) node);
 157         FreeScanFields((Scan *) node);
 158
 159         pfree(node);
 160 }
 161
 162 /* ----------------
 163  *              _freeIndexScan
 164  * ----------------
 165  */
 166 static void
 167 _freeIndexScan(IndexScan *node)
 168 {
 169         /* ----------------
 170          *      free node superclass fields
 171          * ----------------
 172          */
 173         FreePlanFields((Plan *) node);
 174         FreeScanFields((Scan *) node);
 175
 176         /* ----------------
 177          *      free remainder of node
 178          * ----------------
 179          */
 180         freeList(node->indxid);
 181         freeObject(node->indxqual);
 182         freeObject(node->indxqualorig);
 183
 184         pfree(node);
 185 }
 186
 187 /* ----------------
 188  *              _freeTidScan
 189  * ----------------
 190  */
 191 static void
 192 _freeTidScan(TidScan *node)
 193 {
 194         /* ----------------
 195          *      free node superclass fields
 196          * ----------------
 197          */
 198         FreePlanFields((Plan *) node);
 199         FreeScanFields((Scan *) node);
 200
 201         /* ----------------
 202          *      free remainder of node
 203          * ----------------
 204          */
 205         freeObject(node->tideval);
 206
 207         pfree(node);
 208 }
 209
 210 /* ----------------
 211  *              FreeJoinFields
 212  *
 213  *              This function frees the fields of the Join node.  It is used by
 214  *              all the free functions for classes which inherit node Join.
 215  * ----------------
 216  */
 217 static void
 218 FreeJoinFields(Join *node)
 219 {
 220         /* nothing extra */
 221         return;
 222 }
 223
 224
 225 /* ----------------
 226  *              _freeJoin
 227  * ----------------
 228  */
 229 static void
 230 _freeJoin(Join *node)
 231 {
 232         /* ----------------
 233          *      free node superclass fields
 234          * ----------------
 235          */
 236         FreePlanFields((Plan *) node);
 237         FreeJoinFields(node);
 238
 239         pfree(node);
 240 }
 241
 242
 243 /* ----------------
 244  *              _freeNestLoop
 245  * ----------------
 246  */
 247 static void
 248 _freeNestLoop(NestLoop *node)
 249 {
 250         /* ----------------
 251          *      free node superclass fields
 252          * ----------------
 253          */
 254         FreePlanFields((Plan *) node);
 255         FreeJoinFields((Join *) node);
 256
 257         pfree(node);
 258 }
 259
 260
 261 /* ----------------
 262  *              _freeMergeJoin
 263  * ----------------
 264  */
 265 static void
 266 _freeMergeJoin(MergeJoin *node)
 267 {
 268         /* ----------------
 269          *      free node superclass fields
 270          * ----------------
 271          */
 272         FreePlanFields((Plan *) node);
 273         FreeJoinFields((Join *) node);
 274
 275         /* ----------------
 276          *      free remainder of node
 277          * ----------------
 278          */
 279         freeObject(node->mergeclauses);
 280
 281         pfree(node);
 282 }
 283
 284 /* ----------------
 285  *              _freeHashJoin
 286  * ----------------
 287  */
 288 static void
 289 _freeHashJoin(HashJoin *node)
 290 {
 291         /* ----------------
 292          *      free node superclass fields
 293          * ----------------
 294          */
 295         FreePlanFields((Plan *) node);
 296         FreeJoinFields((Join *) node);
 297
 298         /* ----------------
 299          *      free remainder of node
 300          * ----------------
 301          */
 302         freeObject(node->hashclauses);
 303
 304         pfree(node);
 305 }
 306
 307
 308 /* ----------------
 309  *              FreeNonameFields
 310  *
 311  *              This function frees the fields of the Noname node.      It is used by
 312  *              all the free functions for classes which inherit node Noname.
 313  * ----------------
 314  */
 315 static void
 316 FreeNonameFields(Noname *node)
 317 {
 318         return;
 319 }
 320
 321
 322 /* ----------------
 323  *              _freeNoname
 324  * ----------------
 325  */
 326 static void
 327 _freeNoname(Noname *node)
 328 {
 329         /* ----------------
 330          *      free node superclass fields
 331          * ----------------
 332          */
 333         FreePlanFields((Plan *) node);
 334         FreeNonameFields(node);
 335
 336         pfree(node);
 337 }
 338
 339 /* ----------------
 340  *              _freeMaterial
 341  * ----------------
 342  */
 343 static void
 344 _freeMaterial(Material *node)
 345 {
 346         /* ----------------
 347          *      free node superclass fields
 348          * ----------------
 349          */
 350         FreePlanFields((Plan *) node);
 351         FreeNonameFields((Noname *) node);
 352
 353         pfree(node);
 354 }
 355
 356
 357 /* ----------------
 358  *              _freeSort
 359  * ----------------
 360  */
 361 static void
 362 _freeSort(Sort *node)
 363 {
 364         /* ----------------
 365          *      free node superclass fields
 366          * ----------------
 367          */
 368         FreePlanFields((Plan *) node);
 369         FreeNonameFields((Noname *) node);
 370
 371         pfree(node);
 372 }
 373
 374
 375 /* ----------------
 376  *              _freeGroup
 377  * ----------------
 378  */
 379 static void
 380 _freeGroup(Group *node)
 381 {
 382         FreePlanFields((Plan *) node);
 383
 384         pfree(node->grpColIdx);
 385
 386         pfree(node);
 387 }
 388
 389 /* ---------------
 390  *      _freeAgg
 391  * --------------
 392  */
 393 static void
 394 _freeAgg(Agg *node)
 395 {
 396         FreePlanFields((Plan *) node);
 397
 398         pfree(node);
 399 }
 400
 401 /* ---------------
 402  *      _freeGroupClause
 403  * --------------
 404  */
 405 static void
 406 _freeGroupClause(GroupClause *node)
 407 {
 408         pfree(node);
 409 }
 410
 411
 412 /* ----------------
 413  *              _freeUnique
 414  * ----------------
 415  */
 416 static void
 417 _freeUnique(Unique *node)
 418 {
 419         /* ----------------
 420          *      free node superclass fields
 421          * ----------------
 422          */
 423         FreePlanFields((Plan *) node);
 424         FreeNonameFields((Noname *) node);
 425
 426         /* ----------------
 427          *      free remainder of node
 428          * ----------------
 429          */
 430         pfree(node->uniqColIdx);
 431
 432         pfree(node);
 433 }
 434
 435
 436 /* ----------------
 437  *              _freeHash
 438  * ----------------
 439  */
 440 static void
 441 _freeHash(Hash *node)
 442 {
 443         /* ----------------
 444          *      free node superclass fields
 445          * ----------------
 446          */
 447         FreePlanFields((Plan *) node);
 448
 449         /* ----------------
 450          *      free remainder of node
 451          * ----------------
 452          */
 453         freeObject(node->hashkey);
 454
 455         pfree(node);
 456 }
 457
 458 static void
 459 _freeSubPlan(SubPlan *node)
 460 {
 461         freeObject(node->plan);
 462         freeObject(node->rtable);
 463         freeList(node->setParam);
 464         freeList(node->parParam);
 465         freeObject(node->sublink);
 466
 467         if (node->curTuple)
 468                 heap_freetuple(node->curTuple);
 469
 470         pfree(node);
 471 }
 472
 473 /* ****************************************************************
 474  *                                         primnodes.h free functions
 475  * ****************************************************************
 476  */
 477
 478 /* ----------------
 479  *              _freeResdom
 480  * ----------------
 481  */
 482 static void
 483 _freeResdom(Resdom *node)
 484 {
 485         if (node->resname != NULL)
 486                 pfree(node->resname);
 487
 488         pfree(node);
 489 }
 490
 491 static void
 492 _freeFjoin(Fjoin *node)
 493 {
 494         freeObject(node->fj_innerNode);
 495         pfree(node->fj_results);
 496         pfree(node->fj_alwaysDone);
 497
 498         pfree(node);
 499 }
 500
 501 /* ----------------
 502  *              _freeExpr
 503  * ----------------
 504  */
 505 static void
 506 _freeExpr(Expr *node)
 507 {
 508         freeObject(node->oper);
 509         freeObject(node->args);
 510
 511         pfree(node);
 512 }
 513
 514 /* ----------------
 515  *              _freeVar
 516  * ----------------
 517  */
 518 static void
 519 _freeVar(Var *node)
 520 {
 521         /* ----------------
 522          *      free remainder of node
 523          * ----------------
 524          */
 525         pfree(node);
 526 }
 527
 528 static void
 529 _freeFcache(FunctionCachePtr ptr)
 530 {
 531         if (ptr->argOidVect)
 532                 pfree(ptr->argOidVect);
 533         if (ptr->nullVect)
 534                 pfree(ptr->nullVect);
 535         if (ptr->src)
 536                 pfree(ptr->src);
 537         if (ptr->bin)
 538                 pfree(ptr->bin);
 539         if (ptr->func_state)
 540                 pfree(ptr->func_state);
 541         if (ptr->setArg)
 542                 pfree(ptr->setArg);
 543
 544         pfree(ptr);
 545 }
 546
 547 /* ----------------
 548  *              _freeOper
 549  * ----------------
 550  */
 551 static void
 552 _freeOper(Oper *node)
 553 {
 554         /* ----------------
 555          *      free remainder of node
 556          * ----------------
 557          */
 558         if (node->op_fcache)
 559                 _freeFcache(node->op_fcache);
 560
 561         pfree(node);
 562 }
 563
 564 /* ----------------
 565  *              _freeConst
 566  * ----------------
 567  */
 568 static void
 569 _freeConst(Const *node)
 570 {
 571         /* ----------------
 572          *      free remainder of node
 573          * ----------------
 574          */
 575         if (!node->constbyval)
 576                 pfree((void *) node->constvalue);
 577
 578         pfree(node);
 579 }
 580
 581 /* ----------------
 582  *              _freeParam
 583  * ----------------
 584  */
 585 static void
 586 _freeParam(Param *node)
 587 {
 588         /* ----------------
 589          *      free remainder of node
 590          * ----------------
 591          */
 592         if (node->paramname != NULL)
 593                 pfree(node->paramname);
 594         freeObject(node->param_tlist);
 595
 596         pfree(node);
 597 }
 598
 599 /* ----------------
 600  *              _freeFunc
 601  * ----------------
 602  */
 603 static void
 604 _freeFunc(Func *node)
 605 {
 606         /* ----------------
 607          *      free remainder of node
 608          * ----------------
 609          */
 610         freeObject(node->func_tlist);
 611         freeObject(node->func_planlist);
 612         if (node->func_fcache)
 613                 _freeFcache(node->func_fcache);
 614
 615         pfree(node);
 616 }
 617
 618 /* ----------------
 619  *              _freeAggref
 620  * ----------------
 621  */
 622 static void
 623 _freeAggref(Aggref *node)
 624 {
 625         /* ----------------
 626          *      free remainder of node
 627          * ----------------
 628          */
 629         pfree(node->aggname);
 630         freeObject(node->target);
 631
 632         pfree(node);
 633 }
 634
 635 /* ----------------
 636  *              _freeSubLink
 637  * ----------------
 638  */
 639 static void
 640 _freeSubLink(SubLink *node)
 641 {
 642         /* ----------------
 643          *      free remainder of node
 644          * ----------------
 645          */
 646         freeObject(node->lefthand);
 647         freeObject(node->oper);
 648         freeObject(node->subselect);
 649
 650         pfree(node);
 651 }
 652
 653 /* ----------------
 654  *              _freeRelabelType
 655  * ----------------
 656  */
 657 static void
 658 _freeRelabelType(RelabelType *node)
 659 {
 660         /* ----------------
 661          *      free remainder of node
 662          * ----------------
 663          */
 664         freeObject(node->arg);
 665
 666         pfree(node);
 667 }
 668
 669 /* ----------------
 670  *              _freeCaseExpr
 671  * ----------------
 672  */
 673 static void
 674 _freeCaseExpr(CaseExpr *node)
 675 {
 676         /* ----------------
 677          *      free remainder of node
 678          * ----------------
 679          */
 680         freeObject(node->arg);
 681         freeObject(node->args);
 682         freeObject(node->defresult);
 683
 684         pfree(node);
 685 }
 686
 687 /* ----------------
 688  *              _freeCaseWhen
 689  * ----------------
 690  */
 691 static void
 692 _freeCaseWhen(CaseWhen *node)
 693 {
 694         /* ----------------
 695          *      free remainder of node
 696          * ----------------
 697          */
 698         freeObject(node->expr);
 699         freeObject(node->result);
 700
 701         pfree(node);
 702 }
 703
 704 static void
 705 _freeArray(Array *node)
 706 {
 707         /* ----------------
 708          *      free remainder of node
 709          * ----------------
 710          */
 711         pfree(node);
 712 }
 713
 714 static void
 715 _freeArrayRef(ArrayRef *node)
 716 {
 717         /* ----------------
 718          *      free remainder of node
 719          * ----------------
 720          */
 721         freeObject(node->refupperindexpr);
 722         freeObject(node->reflowerindexpr);
 723         freeObject(node->refexpr);
 724         freeObject(node->refassgnexpr);
 725
 726         pfree(node);
 727 }
 728
 729 /* ****************************************************************
 730  *                                              relation.h free functions
 731  * ****************************************************************
 732  */
 733
 734 /* ----------------
 735  *              _freeRelOptInfo
 736  * ----------------
 737  */
 738 static void
 739 _freeRelOptInfo(RelOptInfo *node)
 740 {
 741         /* ----------------
 742          *      free remainder of node
 743          * ----------------
 744          */
 745         freeList(node->relids);
 746
 747         freeObject(node->targetlist);
 748         freeObject(node->pathlist);
 749         /* XXX is this right? cheapest-path fields will typically be pointers
 750          * into pathlist, not separate structs...
 751          */
 752         freeObject(node->cheapest_startup_path);
 753         freeObject(node->cheapest_total_path);
 754
 755         freeObject(node->baserestrictinfo);
 756         freeObject(node->joininfo);
 757         freeObject(node->innerjoin);
 758
 759         pfree(node);
 760 }
 761
 762 /* ----------------
 763  *              _freeIndexOptInfo
 764  * ----------------
 765  */
 766 static void
 767 _freeIndexOptInfo(IndexOptInfo *node)
 768 {
 769         /* ----------------
 770          *      free remainder of node
 771          * ----------------
 772          */
 773         if (node->classlist)
 774                 pfree(node->classlist);
 775
 776         if (node->indexkeys)
 777                 pfree(node->indexkeys);
 778
 779         if (node->ordering)
 780                 pfree(node->ordering);
 781
 782         freeObject(node->indpred);
 783
 784         pfree(node);
 785 }
 786
 787 /* ----------------
 788  *              FreePathFields
 789  *
 790  *              This function frees the fields of the Path node.  It is used by
 791  *              all the free functions for classes which inherit node Path.
 792  * ----------------
 793  */
 794 static void
 795 FreePathFields(Path *node)
 796 {
 797         /* we do NOT free the parent; it doesn't belong to the Path */
 798
 799         freeObject(node->pathkeys);
 800 }
 801
 802 /* ----------------
 803  *              _freePath
 804  * ----------------
 805  */
 806 static void
 807 _freePath(Path *node)
 808 {
 809         FreePathFields(node);
 810
 811         pfree(node);
 812 }
 813
 814 /* ----------------
 815  *              _freeIndexPath
 816  * ----------------
 817  */
 818 static void
 819 _freeIndexPath(IndexPath *node)
 820 {
 821         /* ----------------
 822          *      free the node superclass fields
 823          * ----------------
 824          */
 825         FreePathFields((Path *) node);
 826
 827         /* ----------------
 828          *      free remainder of node
 829          * ----------------
 830          */
 831         freeList(node->indexid);
 832         freeObject(node->indexqual);
 833         freeList(node->joinrelids);
 834
 835         pfree(node);
 836 }
 837
 838 /* ----------------
 839  *              _freeTidPath
 840  * ----------------
 841  */
 842 static void
 843 _freeTidPath(TidPath *node)
 844 {
 845         /* ----------------
 846          *      free the node superclass fields
 847          * ----------------
 848          */
 849         FreePathFields((Path *) node);
 850
 851         /* ----------------
 852          *      free remainder of node
 853          * ----------------
 854          */
 855         freeObject(node->tideval);
 856         freeList(node->unjoined_relids);
 857
 858         pfree(node);
 859 }
 860
 861 /* ----------------
 862  *              FreeJoinPathFields
 863  *
 864  *              This function frees the fields of the JoinPath node.  It is used by
 865  *              all the free functions for classes which inherit node JoinPath.
 866  * ----------------
 867  */
 868 static void
 869 FreeJoinPathFields(JoinPath *node)
 870 {
 871         freeObject(node->outerjoinpath);
 872         freeObject(node->innerjoinpath);
 873         /* XXX probably wrong, since ordinarily a JoinPath would share its
 874          * restrictinfo list with other paths made for the same join?
 875          */
 876         freeObject(node->joinrestrictinfo);
 877 }
 878
 879 /* ----------------
 880  *              _freeNestPath
 881  * ----------------
 882  */
 883 static void
 884 _freeNestPath(NestPath *node)
 885 {
 886         /* ----------------
 887          *      free the node superclass fields
 888          * ----------------
 889          */
 890         FreePathFields((Path *) node);
 891         FreeJoinPathFields((JoinPath *) node);
 892
 893         pfree(node);
 894 }
 895
 896 /* ----------------
 897  *              _freeMergePath
 898  * ----------------
 899  */
 900 static void
 901 _freeMergePath(MergePath *node)
 902 {
 903         /* ----------------
 904          *      free the node superclass fields
 905          * ----------------
 906          */
 907         FreePathFields((Path *) node);
 908         FreeJoinPathFields((JoinPath *) node);
 909
 910         /* ----------------
 911          *      free the remainder of the node
 912          * ----------------
 913          */
 914         freeObject(node->path_mergeclauses);
 915         freeObject(node->outersortkeys);
 916         freeObject(node->innersortkeys);
 917
 918         pfree(node);
 919 }
 920
 921 /* ----------------
 922  *              _freeHashPath
 923  * ----------------
 924  */
 925 static void
 926 _freeHashPath(HashPath *node)
 927 {
 928         /* ----------------
 929          *      free the node superclass fields
 930          * ----------------
 931          */
 932         FreePathFields((Path *) node);
 933         FreeJoinPathFields((JoinPath *) node);
 934
 935         /* ----------------
 936          *      free remainder of node
 937          * ----------------
 938          */
 939         freeObject(node->path_hashclauses);
 940
 941         pfree(node);
 942 }
 943
 944 /* ----------------
 945  *              _freePathKeyItem
 946  * ----------------
 947  */
 948 static void
 949 _freePathKeyItem(PathKeyItem *node)
 950 {
 951         /* ----------------
 952          *      free remainder of node
 953          * ----------------
 954          */
 955         freeObject(node->key);
 956
 957         pfree(node);
 958 }
 959
 960
 961 /* ----------------
 962  *              _freeRestrictInfo
 963  * ----------------
 964  */
 965 static void
 966 _freeRestrictInfo(RestrictInfo *node)
 967 {
 968         /* ----------------
 969          *      free remainder of node
 970          * ----------------
 971          */
 972         freeObject(node->clause);
 973         /* this is certainly wrong?  IndexOptInfos don't belong to
 974          * RestrictInfo...
 975          */
 976         freeObject(node->subclauseindices);
 977
 978         pfree(node);
 979 }
 980
 981 /* ----------------
 982  *              _freeJoinInfo
 983  * ----------------
 984  */
 985 static void
 986 _freeJoinInfo(JoinInfo *node)
 987 {
 988         /* ----------------
 989          *      free remainder of node
 990          * ----------------
 991          */
 992         freeList(node->unjoined_relids);
 993         freeObject(node->jinfo_restrictinfo);
 994
 995         pfree(node);
 996 }
 997
 998 static void
 999 _freeIter(Iter *node)
1000 {
1001         freeObject(node->iterexpr);
1002
1003         pfree(node);
1004 }
1005
1006 static void
1007 _freeStream(Stream *node)
1008 {
1009         freeObject(node->downstream);
1010
1011         pfree(node);
1012 }
1013
1014 /*
1015  *      parsenodes.h routines have no free functions
1016  */
1017
1018 static void
1019 _freeTargetEntry(TargetEntry *node)
1020 {
1021         freeObject(node->resdom);
1022         freeObject(node->fjoin);
1023         freeObject(node->expr);
1024
1025         pfree(node);
1026 }
1027
1028 static void
1029 _freeRangeTblEntry(RangeTblEntry *node)
1030 {
1031         if (node->relname)
1032                 pfree(node->relname);
1033         freeObject(node->ref);
1034
1035         pfree(node);
1036 }
1037
1038 static void
1039 _freeAttr(Attr *node)
1040 {
1041         if (node->relname)
1042                 pfree(node->relname);
1043         freeObject(node->attrs);
1044
1045         pfree(node);
1046 }
1047
1048 static void
1049 _freeRowMark(RowMark *node)
1050 {
1051         pfree(node);
1052 }
1053
1054 static void
1055 _freeSortClause(SortClause *node)
1056 {
1057         pfree(node);
1058 }
1059
1060 static void
1061 _freeAConst(A_Const *node)
1062 {
1063         freeObject(&(node->val));
1064         freeObject(node->typename);
1065
1066         pfree(node);
1067 }
1068
1069 static void
1070 _freeTypeName(TypeName *node)
1071 {
1072         if (node->name)
1073                 pfree(node->name);
1074         freeObject(node->arrayBounds);
1075
1076         pfree(node);
1077 }
1078
1079 static void
1080 _freeTypeCast(TypeCast *node)
1081 {
1082         freeObject(node->arg);
1083         freeObject(node->typename);
1084
1085         pfree(node);
1086 }
1087
1088 static void
1089 _freeQuery(Query *node)
1090 {
1091         if (node->utilityStmt && nodeTag(node->utilityStmt) == T_NotifyStmt)
1092         {
1093                 NotifyStmt *node_notify = (NotifyStmt *) node->utilityStmt;
1094
1095                 pfree(node_notify->relname);
1096                 pfree(node_notify);
1097         }
1098         if (node->into)
1099                 pfree(node->into);
1100         freeObject(node->rtable);
1101         freeObject(node->targetList);
1102         freeObject(node->qual);
1103         freeObject(node->rowMark);
1104         freeObject(node->distinctClause);
1105         freeObject(node->sortClause);
1106         freeObject(node->groupClause);
1107         freeObject(node->havingQual);
1108         /* why not intersectClause? */
1109         freeObject(node->unionClause);
1110         freeObject(node->limitOffset);
1111         freeObject(node->limitCount);
1112
1113         /* XXX should we be freeing the planner internal fields? */
1114
1115         pfree(node);
1116 }
1117
1118
1119 /*
1120  *      mnodes.h routines have no free functions
1121  */
1122
1123 /* ****************************************************************
1124  *                                      pg_list.h free functions
1125  * ****************************************************************
1126  */
1127
1128 static void
1129 _freeValue(Value *node)
1130 {
1131         switch (node->type)
1132         {
1133                         case T_String:
1134                         pfree(node->val.str);
1135                         break;
1136                 default:
1137                         break;
1138         }
1139
1140         pfree(node);
1141 }
1142
1143 /* ----------------
1144  *              freeObject free's the node or list. If it is a list, it
1145  *              recursively frees its items.
1146  * ----------------
1147  */
1148 static void
1149 freeObject(void *node)
1150 {
1151         if (node == NULL)
1152                 return;
1153
1154         switch (nodeTag(node))
1155         {
1156
1157                         /*
1158                          * PLAN NODES
1159                          */
1160                 case T_Plan:
1161                         _freePlan(node);
1162                         break;
1163                 case T_Result:
1164                         _freeResult(node);
1165                         break;
1166                 case T_Append:
1167                         _freeAppend(node);
1168                         break;
1169                 case T_Scan:
1170                         _freeScan(node);
1171                         break;
1172                 case T_SeqScan:
1173                         _freeSeqScan(node);
1174                         break;
1175                 case T_IndexScan:
1176                         _freeIndexScan(node);
1177                         break;
1178                 case T_TidScan:
1179                         _freeTidScan(node);
1180                         break;
1181                 case T_Join:
1182                         _freeJoin(node);
1183                         break;
1184                 case T_NestLoop:
1185                         _freeNestLoop(node);
1186                         break;
1187                 case T_MergeJoin:
1188                         _freeMergeJoin(node);
1189                         break;
1190                 case T_HashJoin:
1191                         _freeHashJoin(node);
1192                         break;
1193                 case T_Noname:
1194                         _freeNoname(node);
1195                         break;
1196                 case T_Material:
1197                         _freeMaterial(node);
1198                         break;
1199                 case T_Sort:
1200                         _freeSort(node);
1201                         break;
1202                 case T_Group:
1203                         _freeGroup(node);
1204                         break;
1205                 case T_Agg:
1206                         _freeAgg(node);
1207                         break;
1208                 case T_GroupClause:
1209                         _freeGroupClause(node);
1210                         break;
1211                 case T_Unique:
1212                         _freeUnique(node);
1213                         break;
1214                 case T_Hash:
1215                         _freeHash(node);
1216                         break;
1217                 case T_SubPlan:
1218                         _freeSubPlan(node);
1219                         break;
1220
1221                         /*
1222                          * PRIMITIVE NODES
1223                          */
1224                 case T_Resdom:
1225                         _freeResdom(node);
1226                         break;
1227                 case T_Fjoin:
1228                         _freeFjoin(node);
1229                         break;
1230                 case T_Expr:
1231                         _freeExpr(node);
1232                         break;
1233                 case T_Var:
1234                         _freeVar(node);
1235                         break;
1236                 case T_Oper:
1237                         _freeOper(node);
1238                         break;
1239                 case T_Const:
1240                         _freeConst(node);
1241                         break;
1242                 case T_Param:
1243                         _freeParam(node);
1244                         break;
1245                 case T_Func:
1246                         _freeFunc(node);
1247                         break;
1248                 case T_Array:
1249                         _freeArray(node);
1250                         break;
1251                 case T_ArrayRef:
1252                         _freeArrayRef(node);
1253                         break;
1254                 case T_Aggref:
1255                         _freeAggref(node);
1256                         break;
1257                 case T_SubLink:
1258                         _freeSubLink(node);
1259                         break;
1260                 case T_RelabelType:
1261                         _freeRelabelType(node);
1262                         break;
1263                 case T_CaseExpr:
1264                         _freeCaseExpr(node);
1265                         break;
1266                 case T_CaseWhen:
1267                         _freeCaseWhen(node);
1268                         break;
1269
1270                         /*
1271                          * RELATION NODES
1272                          */
1273                 case T_RelOptInfo:
1274                         _freeRelOptInfo(node);
1275                         break;
1276                 case T_Path:
1277                         _freePath(node);
1278                         break;
1279                 case T_IndexPath:
1280                         _freeIndexPath(node);
1281                         break;
1282                 case T_TidPath:
1283                         _freeTidPath(node);
1284                         break;
1285                 case T_NestPath:
1286                         _freeNestPath(node);
1287                         break;
1288                 case T_MergePath:
1289                         _freeMergePath(node);
1290                         break;
1291                 case T_HashPath:
1292                         _freeHashPath(node);
1293                         break;
1294                 case T_PathKeyItem:
1295                         _freePathKeyItem(node);
1296                         break;
1297                 case T_RestrictInfo:
1298                         _freeRestrictInfo(node);
1299                         break;
1300                 case T_JoinInfo:
1301                         _freeJoinInfo(node);
1302                         break;
1303                 case T_Iter:
1304                         _freeIter(node);
1305                         break;
1306                 case T_Stream:
1307                         _freeStream(node);
1308                         break;
1309                 case T_IndexOptInfo:
1310                         _freeIndexOptInfo(node);
1311                         break;
1312
1313                         /*
1314                          * PARSE NODES
1315                          */
1316                 case T_Query:
1317                         _freeQuery(node);
1318                         break;
1319                 case T_TargetEntry:
1320                         _freeTargetEntry(node);
1321                         break;
1322                 case T_RangeTblEntry:
1323                         _freeRangeTblEntry(node);
1324                         break;
1325                 case T_RowMark:
1326                         _freeRowMark(node);
1327                         break;
1328                 case T_SortClause:
1329                         _freeSortClause(node);
1330                         break;
1331                 case T_A_Const:
1332                         _freeAConst(node);
1333                         break;
1334                 case T_TypeName:
1335                         _freeTypeName(node);
1336                         break;
1337                 case T_TypeCast:
1338                         _freeTypeCast(node);
1339                         break;
1340                 case T_Attr:
1341                         _freeAttr(node);
1342                         break;
1343
1344                         /*
1345                          * VALUE NODES
1346                          */
1347                 case T_Integer:
1348                 case T_String:
1349                 case T_Float:
1350                         _freeValue(node);
1351                         break;
1352                 case T_List:
1353                         {
1354                                 List       *list = node,
1355                                                    *l;
1356
1357                                 foreach(l, list)
1358                                         freeObject(lfirst(l));
1359                                 freeList(list);
1360                         }
1361                         break;
1362                 default:
1363                         elog(ERROR, "freeObject: don't know how to free %d", nodeTag(node));
1364                         break;
1365         }
1366 }