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