granicus.if.org Git - postgresql/blob - src/backend/executor/execMain.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * execMain.c
   4  *        top level executor interface routines
   5  *
   6  * INTERFACE ROUTINES
   7  *      ExecutorStart()
   8  *      ExecutorRun()
   9  *      ExecutorEnd()
  10  *
  11  *      The old ExecutorMain() has been replaced by ExecutorStart(),
  12  *      ExecutorRun() and ExecutorEnd()
  13  *
  14  *      These three procedures are the external interfaces to the executor.
  15  *      In each case, the query descriptor and the execution state is required
  16  *       as arguments
  17  *
  18  *      ExecutorStart() must be called at the beginning of any execution of any
  19  *      query plan and ExecutorEnd() should always be called at the end of
  20  *      execution of a plan.
  21  *
  22  *      ExecutorRun accepts direction and count arguments that specify whether
  23  *      the plan is to be executed forwards, backwards, and for how many tuples.
  24  *
  25  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  26  * Portions Copyright (c) 1994, Regents of the University of California
  27  *
  28  *
  29  * IDENTIFICATION
  30  *        $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.158 2002/04/15 05:22:04 tgl Exp $
  31  *
  32  *-------------------------------------------------------------------------
  33  */
  34 #include "postgres.h"
  35
  36 #include "access/heapam.h"
  37 #include "catalog/heap.h"
  38 #include "catalog/namespace.h"
  39 #include "commands/tablecmds.h"
  40 #include "commands/trigger.h"
  41 #include "executor/execdebug.h"
  42 #include "executor/execdefs.h"
  43 #include "miscadmin.h"
  44 #include "optimizer/var.h"
  45 #include "parser/parsetree.h"
  46 #include "utils/acl.h"
  47 #include "utils/lsyscache.h"
  48
  49
  50 /* decls for local routines only used within this module */
  51 static TupleDesc InitPlan(CmdType operation,
  52                  Query *parseTree,
  53                  Plan *plan,
  54                  EState *estate);
  55 static void initResultRelInfo(ResultRelInfo *resultRelInfo,
  56                                   Index resultRelationIndex,
  57                                   List *rangeTable,
  58                                   CmdType operation);
  59 static void EndPlan(Plan *plan, EState *estate);
  60 static TupleTableSlot *ExecutePlan(EState *estate, Plan *plan,
  61                         CmdType operation,
  62                         long numberTuples,
  63                         ScanDirection direction,
  64                         DestReceiver *destfunc);
  65 static void ExecRetrieve(TupleTableSlot *slot,
  66                          DestReceiver *destfunc,
  67                          EState *estate);
  68 static void ExecAppend(TupleTableSlot *slot, ItemPointer tupleid,
  69                    EState *estate);
  70 static void ExecDelete(TupleTableSlot *slot, ItemPointer tupleid,
  71                    EState *estate);
  72 static void ExecReplace(TupleTableSlot *slot, ItemPointer tupleid,
  73                         EState *estate);
  74 static TupleTableSlot *EvalPlanQualNext(EState *estate);
  75 static void EndEvalPlanQual(EState *estate);
  76 static void ExecCheckQueryPerms(CmdType operation, Query *parseTree,
  77                                         Plan *plan);
  78 static void ExecCheckPlanPerms(Plan *plan, List *rangeTable,
  79                                    CmdType operation);
  80 static void ExecCheckRTPerms(List *rangeTable, CmdType operation);
  81 static void ExecCheckRTEPerms(RangeTblEntry *rte, CmdType operation);
  82
  83 /* end of local decls */
  84
  85
  86 /* ----------------------------------------------------------------
  87  *              ExecutorStart
  88  *
  89  *              This routine must be called at the beginning of any execution of any
  90  *              query plan
  91  *
  92  *              returns a TupleDesc which describes the attributes of the tuples to
  93  *              be returned by the query.  (Same value is saved in queryDesc)
  94  *
  95  * NB: the CurrentMemoryContext when this is called must be the context
  96  * to be used as the per-query context for the query plan.      ExecutorRun()
  97  * and ExecutorEnd() must be called in this same memory context.
  98  * ----------------------------------------------------------------
  99  */
 100 TupleDesc
 101 ExecutorStart(QueryDesc *queryDesc, EState *estate)
 102 {
 103         TupleDesc       result;
 104
 105         /* sanity checks */
 106         Assert(queryDesc != NULL);
 107
 108         if (queryDesc->plantree->nParamExec > 0)
 109         {
 110                 estate->es_param_exec_vals = (ParamExecData *)
 111                         palloc(queryDesc->plantree->nParamExec * sizeof(ParamExecData));
 112                 MemSet(estate->es_param_exec_vals, 0,
 113                            queryDesc->plantree->nParamExec * sizeof(ParamExecData));
 114         }
 115
 116         /*
 117          * Make our own private copy of the current queries snapshot data
 118          */
 119         if (QuerySnapshot == NULL)
 120                 estate->es_snapshot = NULL;
 121         else
 122         {
 123                 estate->es_snapshot = (Snapshot) palloc(sizeof(SnapshotData));
 124                 memcpy(estate->es_snapshot, QuerySnapshot, sizeof(SnapshotData));
 125                 if (estate->es_snapshot->xcnt > 0)
 126                 {
 127                         estate->es_snapshot->xip = (TransactionId *)
 128                                 palloc(estate->es_snapshot->xcnt * sizeof(TransactionId));
 129                         memcpy(estate->es_snapshot->xip, QuerySnapshot->xip,
 130                                    estate->es_snapshot->xcnt * sizeof(TransactionId));
 131                 }
 132         }
 133
 134         /*
 135          * Initialize the plan
 136          */
 137         result = InitPlan(queryDesc->operation,
 138                                           queryDesc->parsetree,
 139                                           queryDesc->plantree,
 140                                           estate);
 141
 142         queryDesc->tupDesc = result;
 143
 144         return result;
 145 }
 146
 147 /* ----------------------------------------------------------------
 148  *              ExecutorRun
 149  *
 150  *              This is the main routine of the executor module. It accepts
 151  *              the query descriptor from the traffic cop and executes the
 152  *              query plan.
 153  *
 154  *              ExecutorStart must have been called already.
 155  *
 156  *              If direction is NoMovementScanDirection then nothing is done
 157  *              except to start up/shut down the destination.  Otherwise,
 158  *              we retrieve up to 'count' tuples in the specified direction.
 159  *
 160  *              Note: count = 0 is interpreted as no portal limit, e.g. run to
 161  *              completion.
 162  *
 163  * ----------------------------------------------------------------
 164  */
 165 TupleTableSlot *
 166 ExecutorRun(QueryDesc *queryDesc, EState *estate,
 167                         ScanDirection direction, long count)
 168 {
 169         CmdType         operation;
 170         Plan       *plan;
 171         CommandDest dest;
 172         DestReceiver *destfunc;
 173         TupleTableSlot *result;
 174
 175         /*
 176          * sanity checks
 177          */
 178         Assert(queryDesc != NULL);
 179
 180         /*
 181          * extract information from the query descriptor and the query
 182          * feature.
 183          */
 184         operation = queryDesc->operation;
 185         plan = queryDesc->plantree;
 186         dest = queryDesc->dest;
 187
 188         /*
 189          * startup tuple receiver
 190          */
 191         estate->es_processed = 0;
 192         estate->es_lastoid = InvalidOid;
 193
 194         destfunc = DestToFunction(dest);
 195         (*destfunc->setup) (destfunc, (int) operation,
 196                                                 queryDesc->portalName, queryDesc->tupDesc);
 197
 198         /*
 199          * run plan
 200          */
 201         if (direction == NoMovementScanDirection)
 202                 result = NULL;
 203         else
 204                 result = ExecutePlan(estate,
 205                                                          plan,
 206                                                          operation,
 207                                                          count,
 208                                                          direction,
 209                                                          destfunc);
 210
 211         /*
 212          * shutdown receiver
 213          */
 214         (*destfunc->cleanup) (destfunc);
 215
 216         return result;
 217 }
 218
 219 /* ----------------------------------------------------------------
 220  *              ExecutorEnd
 221  *
 222  *              This routine must be called at the end of execution of any
 223  *              query plan
 224  * ----------------------------------------------------------------
 225  */
 226 void
 227 ExecutorEnd(QueryDesc *queryDesc, EState *estate)
 228 {
 229         /* sanity checks */
 230         Assert(queryDesc != NULL);
 231
 232         EndPlan(queryDesc->plantree, estate);
 233
 234         if (estate->es_snapshot != NULL)
 235         {
 236                 if (estate->es_snapshot->xcnt > 0)
 237                         pfree(estate->es_snapshot->xip);
 238                 pfree(estate->es_snapshot);
 239                 estate->es_snapshot = NULL;
 240         }
 241
 242         if (estate->es_param_exec_vals != NULL)
 243         {
 244                 pfree(estate->es_param_exec_vals);
 245                 estate->es_param_exec_vals = NULL;
 246         }
 247 }
 248
 249
 250 /*
 251  * ExecCheckQueryPerms
 252  *              Check access permissions for all relations referenced in a query.
 253  */
 254 static void
 255 ExecCheckQueryPerms(CmdType operation, Query *parseTree, Plan *plan)
 256 {
 257         /*
 258          * Check RTEs in the query's primary rangetable.
 259          */
 260         ExecCheckRTPerms(parseTree->rtable, operation);
 261
 262         /*
 263          * Search for subplans and APPEND nodes to check their rangetables.
 264          */
 265         ExecCheckPlanPerms(plan, parseTree->rtable, operation);
 266 }
 267
 268 /*
 269  * ExecCheckPlanPerms
 270  *              Recursively scan the plan tree to check access permissions in
 271  *              subplans.
 272  */
 273 static void
 274 ExecCheckPlanPerms(Plan *plan, List *rangeTable, CmdType operation)
 275 {
 276         List       *subp;
 277
 278         if (plan == NULL)
 279                 return;
 280
 281         /* Check subplans, which we assume are plain SELECT queries */
 282
 283         foreach(subp, plan->initPlan)
 284         {
 285                 SubPlan    *subplan = (SubPlan *) lfirst(subp);
 286
 287                 ExecCheckRTPerms(subplan->rtable, CMD_SELECT);
 288                 ExecCheckPlanPerms(subplan->plan, subplan->rtable, CMD_SELECT);
 289         }
 290         foreach(subp, plan->subPlan)
 291         {
 292                 SubPlan    *subplan = (SubPlan *) lfirst(subp);
 293
 294                 ExecCheckRTPerms(subplan->rtable, CMD_SELECT);
 295                 ExecCheckPlanPerms(subplan->plan, subplan->rtable, CMD_SELECT);
 296         }
 297
 298         /* Check lower plan nodes */
 299
 300         ExecCheckPlanPerms(plan->lefttree, rangeTable, operation);
 301         ExecCheckPlanPerms(plan->righttree, rangeTable, operation);
 302
 303         /* Do node-type-specific checks */
 304
 305         switch (nodeTag(plan))
 306         {
 307                 case T_SubqueryScan:
 308                         {
 309                                 SubqueryScan *scan = (SubqueryScan *) plan;
 310                                 RangeTblEntry *rte;
 311
 312                                 /* Recursively check the subquery */
 313                                 rte = rt_fetch(scan->scan.scanrelid, rangeTable);
 314                                 Assert(rte->subquery != NULL);
 315                                 ExecCheckQueryPerms(operation, rte->subquery, scan->subplan);
 316                                 break;
 317                         }
 318                 case T_Append:
 319                         {
 320                                 Append     *app = (Append *) plan;
 321                                 List       *appendplans;
 322
 323                                 foreach(appendplans, app->appendplans)
 324                                 {
 325                                         ExecCheckPlanPerms((Plan *) lfirst(appendplans),
 326                                                                            rangeTable,
 327                                                                            operation);
 328                                 }
 329                                 break;
 330                         }
 331
 332                 default:
 333                         break;
 334         }
 335 }
 336
 337 /*
 338  * ExecCheckRTPerms
 339  *              Check access permissions for all relations listed in a range table.
 340  */
 341 static void
 342 ExecCheckRTPerms(List *rangeTable, CmdType operation)
 343 {
 344         List       *lp;
 345
 346         foreach(lp, rangeTable)
 347         {
 348                 RangeTblEntry *rte = lfirst(lp);
 349
 350                 ExecCheckRTEPerms(rte, operation);
 351         }
 352 }
 353
 354 /*
 355  * ExecCheckRTEPerms
 356  *              Check access permissions for a single RTE.
 357  */
 358 static void
 359 ExecCheckRTEPerms(RangeTblEntry *rte, CmdType operation)
 360 {
 361         Oid                     relOid;
 362         Oid                     userid;
 363         int32           aclcheck_result;
 364
 365         /*
 366          * If it's a subquery RTE, ignore it --- it will be checked when
 367          * ExecCheckPlanPerms finds the SubqueryScan node for it.
 368          */
 369         if (rte->rtekind != RTE_RELATION)
 370                 return;
 371
 372         relOid = rte->relid;
 373
 374         /*
 375          * userid to check as: current user unless we have a setuid
 376          * indication.
 377          *
 378          * Note: GetUserId() is presently fast enough that there's no harm in
 379          * calling it separately for each RTE.  If that stops being true, we
 380          * could call it once in ExecCheckQueryPerms and pass the userid down
 381          * from there.  But for now, no need for the extra clutter.
 382          */
 383         userid = rte->checkAsUser ? rte->checkAsUser : GetUserId();
 384
 385 #define CHECK(MODE)             pg_class_aclcheck(relOid, userid, MODE)
 386
 387         if (rte->checkForRead)
 388         {
 389                 aclcheck_result = CHECK(ACL_SELECT);
 390                 if (aclcheck_result != ACLCHECK_OK)
 391                         elog(ERROR, "%s: %s",
 392                                  get_rel_name(relOid),
 393                                  aclcheck_error_strings[aclcheck_result]);
 394         }
 395
 396         if (rte->checkForWrite)
 397         {
 398                 /*
 399                  * Note: write access in a SELECT context means SELECT FOR UPDATE.
 400                  * Right now we don't distinguish that from true update as far as
 401                  * permissions checks are concerned.
 402                  */
 403                 switch (operation)
 404                 {
 405                         case CMD_INSERT:
 406                                 aclcheck_result = CHECK(ACL_INSERT);
 407                                 break;
 408                         case CMD_SELECT:
 409                         case CMD_UPDATE:
 410                                 aclcheck_result = CHECK(ACL_UPDATE);
 411                                 break;
 412                         case CMD_DELETE:
 413                                 aclcheck_result = CHECK(ACL_DELETE);
 414                                 break;
 415                         default:
 416                                 elog(ERROR, "ExecCheckRTEPerms: bogus operation %d",
 417                                          operation);
 418                                 aclcheck_result = ACLCHECK_OK;  /* keep compiler quiet */
 419                                 break;
 420                 }
 421                 if (aclcheck_result != ACLCHECK_OK)
 422                         elog(ERROR, "%s: %s",
 423                                  get_rel_name(relOid),
 424                                  aclcheck_error_strings[aclcheck_result]);
 425         }
 426 }
 427
 428
 429 /* ===============================================================
 430  * ===============================================================
 431                                                  static routines follow
 432  * ===============================================================
 433  * ===============================================================
 434  */
 435
 436 typedef struct execRowMark
 437 {
 438         Relation        relation;
 439         Index           rti;
 440         char            resname[32];
 441 } execRowMark;
 442
 443 typedef struct evalPlanQual
 444 {
 445         Plan       *plan;
 446         Index           rti;
 447         EState          estate;
 448         struct evalPlanQual *free;
 449 } evalPlanQual;
 450
 451 /* ----------------------------------------------------------------
 452  *              InitPlan
 453  *
 454  *              Initializes the query plan: open files, allocate storage
 455  *              and start up the rule manager
 456  * ----------------------------------------------------------------
 457  */
 458 static TupleDesc
 459 InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
 460 {
 461         List       *rangeTable;
 462         Relation        intoRelationDesc;
 463         TupleDesc       tupType;
 464
 465         /*
 466          * Do permissions checks.
 467          */
 468         ExecCheckQueryPerms(operation, parseTree, plan);
 469
 470         /*
 471          * get information from query descriptor
 472          */
 473         rangeTable = parseTree->rtable;
 474
 475         /*
 476          * initialize the node's execution state
 477          */
 478         estate->es_range_table = rangeTable;
 479
 480         /*
 481          * if there is a result relation, initialize result relation stuff
 482          */
 483         if (parseTree->resultRelation != 0 && operation != CMD_SELECT)
 484         {
 485                 List       *resultRelations = parseTree->resultRelations;
 486                 int                     numResultRelations;
 487                 ResultRelInfo *resultRelInfos;
 488
 489                 if (resultRelations != NIL)
 490                 {
 491                         /*
 492                          * Multiple result relations (due to inheritance)
 493                          * parseTree->resultRelations identifies them all
 494                          */
 495                         ResultRelInfo *resultRelInfo;
 496
 497                         numResultRelations = length(resultRelations);
 498                         resultRelInfos = (ResultRelInfo *)
 499                                 palloc(numResultRelations * sizeof(ResultRelInfo));
 500                         resultRelInfo = resultRelInfos;
 501                         while (resultRelations != NIL)
 502                         {
 503                                 initResultRelInfo(resultRelInfo,
 504                                                                   lfirsti(resultRelations),
 505                                                                   rangeTable,
 506                                                                   operation);
 507                                 resultRelInfo++;
 508                                 resultRelations = lnext(resultRelations);
 509                         }
 510                 }
 511                 else
 512                 {
 513                         /*
 514                          * Single result relation identified by
 515                          * parseTree->resultRelation
 516                          */
 517                         numResultRelations = 1;
 518                         resultRelInfos = (ResultRelInfo *) palloc(sizeof(ResultRelInfo));
 519                         initResultRelInfo(resultRelInfos,
 520                                                           parseTree->resultRelation,
 521                                                           rangeTable,
 522                                                           operation);
 523                 }
 524
 525                 estate->es_result_relations = resultRelInfos;
 526                 estate->es_num_result_relations = numResultRelations;
 527                 /* Initialize to first or only result rel */
 528                 estate->es_result_relation_info = resultRelInfos;
 529         }
 530         else
 531         {
 532                 /*
 533                  * if no result relation, then set state appropriately
 534                  */
 535                 estate->es_result_relations = NULL;
 536                 estate->es_num_result_relations = 0;
 537                 estate->es_result_relation_info = NULL;
 538         }
 539
 540         /*
 541          * Have to lock relations selected for update
 542          */
 543         estate->es_rowMark = NIL;
 544         if (parseTree->rowMarks != NIL)
 545         {
 546                 List       *l;
 547
 548                 foreach(l, parseTree->rowMarks)
 549                 {
 550                         Index           rti = lfirsti(l);
 551                         Oid                     relid = getrelid(rti, rangeTable);
 552                         Relation        relation;
 553                         execRowMark *erm;
 554
 555                         relation = heap_open(relid, RowShareLock);
 556                         erm = (execRowMark *) palloc(sizeof(execRowMark));
 557                         erm->relation = relation;
 558                         erm->rti = rti;
 559                         sprintf(erm->resname, "ctid%u", rti);
 560                         estate->es_rowMark = lappend(estate->es_rowMark, erm);
 561                 }
 562         }
 563
 564         /*
 565          * initialize the executor "tuple" table.  We need slots for all the
 566          * plan nodes, plus possibly output slots for the junkfilter(s). At
 567          * this point we aren't sure if we need junkfilters, so just add slots
 568          * for them unconditionally.
 569          */
 570         {
 571                 int                     nSlots = ExecCountSlotsNode(plan);
 572
 573                 if (parseTree->resultRelations != NIL)
 574                         nSlots += length(parseTree->resultRelations);
 575                 else
 576                         nSlots += 1;
 577                 estate->es_tupleTable = ExecCreateTupleTable(nSlots);
 578         }
 579
 580         /* mark EvalPlanQual not active */
 581         estate->es_origPlan = plan;
 582         estate->es_evalPlanQual = NULL;
 583         estate->es_evTuple = NULL;
 584         estate->es_evTupleNull = NULL;
 585         estate->es_useEvalPlan = false;
 586
 587         /*
 588          * initialize the private state information for all the nodes in the
 589          * query tree.  This opens files, allocates storage and leaves us
 590          * ready to start processing tuples.
 591          */
 592         ExecInitNode(plan, estate, NULL);
 593
 594         /*
 595          * Get the tuple descriptor describing the type of tuples to return.
 596          * (this is especially important if we are creating a relation with
 597          * "retrieve into")
 598          */
 599         tupType = ExecGetTupType(plan);         /* tuple descriptor */
 600
 601         /*
 602          * Initialize the junk filter if needed. SELECT and INSERT queries
 603          * need a filter if there are any junk attrs in the tlist.      UPDATE and
 604          * DELETE always need one, since there's always a junk 'ctid'
 605          * attribute present --- no need to look first.
 606          */
 607         {
 608                 bool            junk_filter_needed = false;
 609                 List       *tlist;
 610
 611                 switch (operation)
 612                 {
 613                         case CMD_SELECT:
 614                         case CMD_INSERT:
 615                                 foreach(tlist, plan->targetlist)
 616                                 {
 617                                         TargetEntry *tle = (TargetEntry *) lfirst(tlist);
 618
 619                                         if (tle->resdom->resjunk)
 620                                         {
 621                                                 junk_filter_needed = true;
 622                                                 break;
 623                                         }
 624                                 }
 625                                 break;
 626                         case CMD_UPDATE:
 627                         case CMD_DELETE:
 628                                 junk_filter_needed = true;
 629                                 break;
 630                         default:
 631                                 break;
 632                 }
 633
 634                 if (junk_filter_needed)
 635                 {
 636                         /*
 637                          * If there are multiple result relations, each one needs its
 638                          * own junk filter.  Note this is only possible for
 639                          * UPDATE/DELETE, so we can't be fooled by some needing a
 640                          * filter and some not.
 641                          */
 642                         if (parseTree->resultRelations != NIL)
 643                         {
 644                                 List       *subplans;
 645                                 ResultRelInfo *resultRelInfo;
 646
 647                                 /* Top plan had better be an Append here. */
 648                                 Assert(IsA(plan, Append));
 649                                 Assert(((Append *) plan)->isTarget);
 650                                 subplans = ((Append *) plan)->appendplans;
 651                                 Assert(length(subplans) == estate->es_num_result_relations);
 652                                 resultRelInfo = estate->es_result_relations;
 653                                 while (subplans != NIL)
 654                                 {
 655                                         Plan       *subplan = (Plan *) lfirst(subplans);
 656                                         JunkFilter *j;
 657
 658                                         j = ExecInitJunkFilter(subplan->targetlist,
 659                                                                                    ExecGetTupType(subplan),
 660                                                           ExecAllocTableSlot(estate->es_tupleTable));
 661                                         resultRelInfo->ri_junkFilter = j;
 662                                         resultRelInfo++;
 663                                         subplans = lnext(subplans);
 664                                 }
 665
 666                                 /*
 667                                  * Set active junkfilter too; at this point ExecInitAppend
 668                                  * has already selected an active result relation...
 669                                  */
 670                                 estate->es_junkFilter =
 671                                         estate->es_result_relation_info->ri_junkFilter;
 672                         }
 673                         else
 674                         {
 675                                 /* Normal case with just one JunkFilter */
 676                                 JunkFilter *j;
 677
 678                                 j = ExecInitJunkFilter(plan->targetlist,
 679                                                                            tupType,
 680                                                           ExecAllocTableSlot(estate->es_tupleTable));
 681                                 estate->es_junkFilter = j;
 682                                 if (estate->es_result_relation_info)
 683                                         estate->es_result_relation_info->ri_junkFilter = j;
 684
 685                                 /* For SELECT, want to return the cleaned tuple type */
 686                                 if (operation == CMD_SELECT)
 687                                         tupType = j->jf_cleanTupType;
 688                         }
 689                 }
 690                 else
 691                         estate->es_junkFilter = NULL;
 692         }
 693
 694         /*
 695          * initialize the "into" relation
 696          */
 697         intoRelationDesc = (Relation) NULL;
 698
 699         if (operation == CMD_SELECT)
 700         {
 701                 if (!parseTree->isPortal)
 702                 {
 703                         /*
 704                          * a select into table
 705                          */
 706                         if (parseTree->into != NULL)
 707                         {
 708                                 char       *intoName;
 709                                 Oid                     namespaceId;
 710                                 Oid                     intoRelationId;
 711                                 TupleDesc       tupdesc;
 712
 713                                 /*
 714                                  * create the "into" relation
 715                                  */
 716                                 intoName = parseTree->into->relname;
 717                                 namespaceId = RangeVarGetCreationNamespace(parseTree->into);
 718
 719                                 /*
 720                                  * have to copy tupType to get rid of constraints
 721                                  */
 722                                 tupdesc = CreateTupleDescCopy(tupType);
 723
 724                                 intoRelationId =
 725                                         heap_create_with_catalog(intoName,
 726                                                                                          namespaceId,
 727                                                                                          tupdesc,
 728                                                                                          RELKIND_RELATION,
 729                                                                                          true,
 730                                                                                          allowSystemTableMods);
 731
 732                                 FreeTupleDesc(tupdesc);
 733
 734                                 /*
 735                                  * Advance command counter so that the newly-created
 736                                  * relation's catalog tuples will be visible to heap_open.
 737                                  */
 738                                 CommandCounterIncrement();
 739
 740                                 /*
 741                                  * If necessary, create a TOAST table for the into
 742                                  * relation. Note that AlterTableCreateToastTable ends
 743                                  * with CommandCounterIncrement(), so that the TOAST table
 744                                  * will be visible for insertion.
 745                                  */
 746                                 AlterTableCreateToastTable(intoRelationId, true);
 747
 748                                 intoRelationDesc = heap_open(intoRelationId,
 749                                                                                          AccessExclusiveLock);
 750                         }
 751                 }
 752         }
 753
 754         estate->es_into_relation_descriptor = intoRelationDesc;
 755
 756         return tupType;
 757 }
 758
 759 /*
 760  * Initialize ResultRelInfo data for one result relation
 761  */
 762 static void
 763 initResultRelInfo(ResultRelInfo *resultRelInfo,
 764                                   Index resultRelationIndex,
 765                                   List *rangeTable,
 766                                   CmdType operation)
 767 {
 768         Oid                     resultRelationOid;
 769         Relation        resultRelationDesc;
 770
 771         resultRelationOid = getrelid(resultRelationIndex, rangeTable);
 772         resultRelationDesc = heap_open(resultRelationOid, RowExclusiveLock);
 773
 774         switch (resultRelationDesc->rd_rel->relkind)
 775         {
 776                 case RELKIND_SEQUENCE:
 777                         elog(ERROR, "You can't change sequence relation %s",
 778                                  RelationGetRelationName(resultRelationDesc));
 779                         break;
 780                 case RELKIND_TOASTVALUE:
 781                         elog(ERROR, "You can't change toast relation %s",
 782                                  RelationGetRelationName(resultRelationDesc));
 783                         break;
 784                 case RELKIND_VIEW:
 785                         elog(ERROR, "You can't change view relation %s",
 786                                  RelationGetRelationName(resultRelationDesc));
 787                         break;
 788         }
 789
 790         MemSet(resultRelInfo, 0, sizeof(ResultRelInfo));
 791         resultRelInfo->type = T_ResultRelInfo;
 792         resultRelInfo->ri_RangeTableIndex = resultRelationIndex;
 793         resultRelInfo->ri_RelationDesc = resultRelationDesc;
 794         resultRelInfo->ri_NumIndices = 0;
 795         resultRelInfo->ri_IndexRelationDescs = NULL;
 796         resultRelInfo->ri_IndexRelationInfo = NULL;
 797         resultRelInfo->ri_TrigDesc = resultRelationDesc->trigdesc;
 798         resultRelInfo->ri_TrigFunctions = NULL;
 799         resultRelInfo->ri_ConstraintExprs = NULL;
 800         resultRelInfo->ri_junkFilter = NULL;
 801
 802         /*
 803          * If there are indices on the result relation, open them and save
 804          * descriptors in the result relation info, so that we can add new
 805          * index entries for the tuples we add/update.  We need not do this
 806          * for a DELETE, however, since deletion doesn't affect indexes.
 807          */
 808         if (resultRelationDesc->rd_rel->relhasindex &&
 809                 operation != CMD_DELETE)
 810                 ExecOpenIndices(resultRelInfo);
 811 }
 812
 813 /* ----------------------------------------------------------------
 814  *              EndPlan
 815  *
 816  *              Cleans up the query plan -- closes files and free up storages
 817  * ----------------------------------------------------------------
 818  */
 819 static void
 820 EndPlan(Plan *plan, EState *estate)
 821 {
 822         ResultRelInfo *resultRelInfo;
 823         int                     i;
 824         List       *l;
 825
 826         /*
 827          * shut down any PlanQual processing we were doing
 828          */
 829         if (estate->es_evalPlanQual != NULL)
 830                 EndEvalPlanQual(estate);
 831
 832         /*
 833          * shut down the node-type-specific query processing
 834          */
 835         ExecEndNode(plan, NULL);
 836
 837         /*
 838          * destroy the executor "tuple" table.
 839          */
 840         ExecDropTupleTable(estate->es_tupleTable, true);
 841         estate->es_tupleTable = NULL;
 842
 843         /*
 844          * close the result relation(s) if any, but hold locks until xact
 845          * commit.      Also clean up junkfilters if present.
 846          */
 847         resultRelInfo = estate->es_result_relations;
 848         for (i = estate->es_num_result_relations; i > 0; i--)
 849         {
 850                 /* Close indices and then the relation itself */
 851                 ExecCloseIndices(resultRelInfo);
 852                 heap_close(resultRelInfo->ri_RelationDesc, NoLock);
 853                 /* Delete the junkfilter if any */
 854                 if (resultRelInfo->ri_junkFilter != NULL)
 855                         ExecFreeJunkFilter(resultRelInfo->ri_junkFilter);
 856                 resultRelInfo++;
 857         }
 858
 859         /*
 860          * close the "into" relation if necessary, again keeping lock
 861          */
 862         if (estate->es_into_relation_descriptor != NULL)
 863                 heap_close(estate->es_into_relation_descriptor, NoLock);
 864
 865         /*
 866          * There might be a junkfilter without a result relation.
 867          */
 868         if (estate->es_num_result_relations == 0 &&
 869                 estate->es_junkFilter != NULL)
 870         {
 871                 ExecFreeJunkFilter(estate->es_junkFilter);
 872                 estate->es_junkFilter = NULL;
 873         }
 874
 875         /*
 876          * close any relations selected FOR UPDATE, again keeping locks
 877          */
 878         foreach(l, estate->es_rowMark)
 879         {
 880                 execRowMark *erm = lfirst(l);
 881
 882                 heap_close(erm->relation, NoLock);
 883         }
 884 }
 885
 886 /* ----------------------------------------------------------------
 887  *              ExecutePlan
 888  *
 889  *              processes the query plan to retrieve 'numberTuples' tuples in the
 890  *              direction specified.
 891  *              Retrieves all tuples if numberTuples is 0
 892  *
 893  *              result is either a slot containing the last tuple in the case
 894  *              of a RETRIEVE or NULL otherwise.
 895  *
 896  * Note: the ctid attribute is a 'junk' attribute that is removed before the
 897  * user can see it
 898  * ----------------------------------------------------------------
 899  */
 900 static TupleTableSlot *
 901 ExecutePlan(EState *estate,
 902                         Plan *plan,
 903                         CmdType operation,
 904                         long numberTuples,
 905                         ScanDirection direction,
 906                         DestReceiver *destfunc)
 907 {
 908         JunkFilter *junkfilter;
 909         TupleTableSlot *slot;
 910         ItemPointer tupleid = NULL;
 911         ItemPointerData tuple_ctid;
 912         long            current_tuple_count;
 913         TupleTableSlot *result;
 914
 915         /*
 916          * initialize local variables
 917          */
 918         slot = NULL;
 919         current_tuple_count = 0;
 920         result = NULL;
 921
 922         /*
 923          * Set the direction.
 924          */
 925         estate->es_direction = direction;
 926
 927         /*
 928          * Loop until we've processed the proper number of tuples from the
 929          * plan.
 930          */
 931
 932         for (;;)
 933         {
 934                 /* Reset the per-output-tuple exprcontext */
 935                 ResetPerTupleExprContext(estate);
 936
 937                 /*
 938                  * Execute the plan and obtain a tuple
 939                  */
 940 lnext:  ;
 941                 if (estate->es_useEvalPlan)
 942                 {
 943                         slot = EvalPlanQualNext(estate);
 944                         if (TupIsNull(slot))
 945                                 slot = ExecProcNode(plan, NULL);
 946                 }
 947                 else
 948                         slot = ExecProcNode(plan, NULL);
 949
 950                 /*
 951                  * if the tuple is null, then we assume there is nothing more to
 952                  * process so we just return null...
 953                  */
 954                 if (TupIsNull(slot))
 955                 {
 956                         result = NULL;
 957                         break;
 958                 }
 959
 960                 /*
 961                  * if we have a junk filter, then project a new tuple with the
 962                  * junk removed.
 963                  *
 964                  * Store this new "clean" tuple in the junkfilter's resultSlot.
 965                  * (Formerly, we stored it back over the "dirty" tuple, which is
 966                  * WRONG because that tuple slot has the wrong descriptor.)
 967                  *
 968                  * Also, extract all the junk information we need.
 969                  */
 970                 if ((junkfilter = estate->es_junkFilter) != (JunkFilter *) NULL)
 971                 {
 972                         Datum           datum;
 973                         HeapTuple       newTuple;
 974                         bool            isNull;
 975
 976                         /*
 977                          * extract the 'ctid' junk attribute.
 978                          */
 979                         if (operation == CMD_UPDATE || operation == CMD_DELETE)
 980                         {
 981                                 if (!ExecGetJunkAttribute(junkfilter,
 982                                                                                   slot,
 983                                                                                   "ctid",
 984                                                                                   &datum,
 985                                                                                   &isNull))
 986                                         elog(ERROR, "ExecutePlan: NO (junk) `ctid' was found!");
 987
 988                                 /* shouldn't ever get a null result... */
 989                                 if (isNull)
 990                                         elog(ERROR, "ExecutePlan: (junk) `ctid' is NULL!");
 991
 992                                 tupleid = (ItemPointer) DatumGetPointer(datum);
 993                                 tuple_ctid = *tupleid;  /* make sure we don't free the
 994                                                                                  * ctid!! */
 995                                 tupleid = &tuple_ctid;
 996                         }
 997                         else if (estate->es_rowMark != NIL)
 998                         {
 999                                 List       *l;
1000
1001                 lmark:  ;
1002                                 foreach(l, estate->es_rowMark)
1003                                 {
1004                                         execRowMark *erm = lfirst(l);
1005                                         Buffer          buffer;
1006                                         HeapTupleData tuple;
1007                                         TupleTableSlot *newSlot;
1008                                         int                     test;
1009
1010                                         if (!ExecGetJunkAttribute(junkfilter,
1011                                                                                           slot,
1012                                                                                           erm->resname,
1013                                                                                           &datum,
1014                                                                                           &isNull))
1015                                                 elog(ERROR, "ExecutePlan: NO (junk) `%s' was found!",
1016                                                          erm->resname);
1017
1018                                         /* shouldn't ever get a null result... */
1019                                         if (isNull)
1020                                                 elog(ERROR, "ExecutePlan: (junk) `%s' is NULL!",
1021                                                          erm->resname);
1022
1023                                         tuple.t_self = *((ItemPointer) DatumGetPointer(datum));
1024                                         test = heap_mark4update(erm->relation, &tuple, &buffer);
1025                                         ReleaseBuffer(buffer);
1026                                         switch (test)
1027                                         {
1028                                                 case HeapTupleSelfUpdated:
1029                                                 case HeapTupleMayBeUpdated:
1030                                                         break;
1031
1032                                                 case HeapTupleUpdated:
1033                                                         if (XactIsoLevel == XACT_SERIALIZABLE)
1034                                                                 elog(ERROR, "Can't serialize access due to concurrent update");
1035                                                         if (!(ItemPointerEquals(&(tuple.t_self),
1036                                                                   (ItemPointer) DatumGetPointer(datum))))
1037                                                         {
1038                                                                 newSlot = EvalPlanQual(estate, erm->rti, &(tuple.t_self));
1039                                                                 if (!(TupIsNull(newSlot)))
1040                                                                 {
1041                                                                         slot = newSlot;
1042                                                                         estate->es_useEvalPlan = true;
1043                                                                         goto lmark;
1044                                                                 }
1045                                                         }
1046
1047                                                         /*
1048                                                          * if tuple was deleted or PlanQual failed for
1049                                                          * updated tuple - we must not return this
1050                                                          * tuple!
1051                                                          */
1052                                                         goto lnext;
1053
1054                                                 default:
1055                                                         elog(ERROR, "Unknown status %u from heap_mark4update", test);
1056                                                         return (NULL);
1057                                         }
1058                                 }
1059                         }
1060
1061                         /*
1062                          * Finally create a new "clean" tuple with all junk attributes
1063                          * removed
1064                          */
1065                         newTuple = ExecRemoveJunk(junkfilter, slot);
1066
1067                         slot = ExecStoreTuple(newTuple,         /* tuple to store */
1068                                                                   junkfilter->jf_resultSlot,    /* dest slot */
1069                                                                   InvalidBuffer,                /* this tuple has no
1070                                                                                                                  * buffer */
1071                                                                   true);                /* tuple should be pfreed */
1072                 }                                               /* if (junkfilter... */
1073
1074                 /*
1075                  * now that we have a tuple, do the appropriate thing with it..
1076                  * either return it to the user, add it to a relation someplace,
1077                  * delete it from a relation, or modify some of its attributes.
1078                  */
1079
1080                 switch (operation)
1081                 {
1082                         case CMD_SELECT:
1083                                 ExecRetrieve(slot,              /* slot containing tuple */
1084                                                          destfunc,      /* destination's tuple-receiver
1085                                                                                  * obj */
1086                                                          estate);       /* */
1087                                 result = slot;
1088                                 break;
1089
1090                         case CMD_INSERT:
1091                                 ExecAppend(slot, tupleid, estate);
1092                                 result = NULL;
1093                                 break;
1094
1095                         case CMD_DELETE:
1096                                 ExecDelete(slot, tupleid, estate);
1097                                 result = NULL;
1098                                 break;
1099
1100                         case CMD_UPDATE:
1101                                 ExecReplace(slot, tupleid, estate);
1102                                 result = NULL;
1103                                 break;
1104
1105                         default:
1106                                 elog(LOG, "ExecutePlan: unknown operation in queryDesc");
1107                                 result = NULL;
1108                                 break;
1109                 }
1110
1111                 /*
1112                  * check our tuple count.. if we've processed the proper number
1113                  * then quit, else loop again and process more tuples..
1114                  */
1115                 current_tuple_count++;
1116                 if (numberTuples == current_tuple_count)
1117                         break;
1118         }
1119
1120         /*
1121          * here, result is either a slot containing a tuple in the case of a
1122          * RETRIEVE or NULL otherwise.
1123          */
1124         return result;
1125 }
1126
1127 /* ----------------------------------------------------------------
1128  *              ExecRetrieve
1129  *
1130  *              RETRIEVEs are easy.. we just pass the tuple to the appropriate
1131  *              print function.  The only complexity is when we do a
1132  *              "retrieve into", in which case we insert the tuple into
1133  *              the appropriate relation (note: this is a newly created relation
1134  *              so we don't need to worry about indices or locks.)
1135  * ----------------------------------------------------------------
1136  */
1137 static void
1138 ExecRetrieve(TupleTableSlot *slot,
1139                          DestReceiver *destfunc,
1140                          EState *estate)
1141 {
1142         HeapTuple       tuple;
1143         TupleDesc       attrtype;
1144
1145         /*
1146          * get the heap tuple out of the tuple table slot
1147          */
1148         tuple = slot->val;
1149         attrtype = slot->ttc_tupleDescriptor;
1150
1151         /*
1152          * insert the tuple into the "into relation"
1153          */
1154         if (estate->es_into_relation_descriptor != NULL)
1155         {
1156                 heap_insert(estate->es_into_relation_descriptor, tuple);
1157                 IncrAppended();
1158         }
1159
1160         /*
1161          * send the tuple to the front end (or the screen)
1162          */
1163         (*destfunc->receiveTuple) (tuple, attrtype, destfunc);
1164         IncrRetrieved();
1165         (estate->es_processed)++;
1166 }
1167
1168 /* ----------------------------------------------------------------
1169  *              ExecAppend
1170  *
1171  *              APPENDs are trickier.. we have to insert the tuple into
1172  *              the base relation and insert appropriate tuples into the
1173  *              index relations.
1174  * ----------------------------------------------------------------
1175  */
1176
1177 static void
1178 ExecAppend(TupleTableSlot *slot,
1179                    ItemPointer tupleid,
1180                    EState *estate)
1181 {
1182         HeapTuple       tuple;
1183         ResultRelInfo *resultRelInfo;
1184         Relation        resultRelationDesc;
1185         int                     numIndices;
1186         Oid                     newId;
1187
1188         /*
1189          * get the heap tuple out of the tuple table slot
1190          */
1191         tuple = slot->val;
1192
1193         /*
1194          * get information on the (current) result relation
1195          */
1196         resultRelInfo = estate->es_result_relation_info;
1197         resultRelationDesc = resultRelInfo->ri_RelationDesc;
1198
1199         /* BEFORE ROW INSERT Triggers */
1200         if (resultRelInfo->ri_TrigDesc &&
1201           resultRelInfo->ri_TrigDesc->n_before_row[TRIGGER_EVENT_INSERT] > 0)
1202         {
1203                 HeapTuple       newtuple;
1204
1205                 newtuple = ExecBRInsertTriggers(estate, resultRelInfo, tuple);
1206
1207                 if (newtuple == NULL)   /* "do nothing" */
1208                         return;
1209
1210                 if (newtuple != tuple)  /* modified by Trigger(s) */
1211                 {
1212                         /*
1213                          * Insert modified tuple into tuple table slot, replacing the
1214                          * original.  We assume that it was allocated in per-tuple
1215                          * memory context, and therefore will go away by itself. The
1216                          * tuple table slot should not try to clear it.
1217                          */
1218                         ExecStoreTuple(newtuple, slot, InvalidBuffer, false);
1219                         tuple = newtuple;
1220                 }
1221         }
1222
1223         /*
1224          * Check the constraints of the tuple
1225          */
1226         if (resultRelationDesc->rd_att->constr)
1227                 ExecConstraints("ExecAppend", resultRelInfo, slot, estate);
1228
1229         /*
1230          * insert the tuple
1231          */
1232         newId = heap_insert(resultRelationDesc, tuple);
1233
1234         IncrAppended();
1235         (estate->es_processed)++;
1236         estate->es_lastoid = newId;
1237         setLastTid(&(tuple->t_self));
1238
1239         /*
1240          * process indices
1241          *
1242          * Note: heap_insert adds a new tuple to a relation.  As a side effect,
1243          * the tupleid of the new tuple is placed in the new tuple's t_ctid
1244          * field.
1245          */
1246         numIndices = resultRelInfo->ri_NumIndices;
1247         if (numIndices > 0)
1248                 ExecInsertIndexTuples(slot, &(tuple->t_self), estate, false);
1249
1250         /* AFTER ROW INSERT Triggers */
1251         if (resultRelInfo->ri_TrigDesc)
1252                 ExecARInsertTriggers(estate, resultRelInfo, tuple);
1253 }
1254
1255 /* ----------------------------------------------------------------
1256  *              ExecDelete
1257  *
1258  *              DELETE is like append, we delete the tuple and its
1259  *              index tuples.
1260  * ----------------------------------------------------------------
1261  */
1262 static void
1263 ExecDelete(TupleTableSlot *slot,
1264                    ItemPointer tupleid,
1265                    EState *estate)
1266 {
1267         ResultRelInfo *resultRelInfo;
1268         Relation        resultRelationDesc;
1269         ItemPointerData ctid;
1270         int                     result;
1271
1272         /*
1273          * get information on the (current) result relation
1274          */
1275         resultRelInfo = estate->es_result_relation_info;
1276         resultRelationDesc = resultRelInfo->ri_RelationDesc;
1277
1278         /* BEFORE ROW DELETE Triggers */
1279         if (resultRelInfo->ri_TrigDesc &&
1280           resultRelInfo->ri_TrigDesc->n_before_row[TRIGGER_EVENT_DELETE] > 0)
1281         {
1282                 bool            dodelete;
1283
1284                 dodelete = ExecBRDeleteTriggers(estate, resultRelInfo, tupleid);
1285
1286                 if (!dodelete)                  /* "do nothing" */
1287                         return;
1288         }
1289
1290         /*
1291          * delete the tuple
1292          */
1293 ldelete:;
1294         result = heap_delete(resultRelationDesc, tupleid, &ctid);
1295         switch (result)
1296         {
1297                 case HeapTupleSelfUpdated:
1298                         return;
1299
1300                 case HeapTupleMayBeUpdated:
1301                         break;
1302
1303                 case HeapTupleUpdated:
1304                         if (XactIsoLevel == XACT_SERIALIZABLE)
1305                                 elog(ERROR, "Can't serialize access due to concurrent update");
1306                         else if (!(ItemPointerEquals(tupleid, &ctid)))
1307                         {
1308                                 TupleTableSlot *epqslot = EvalPlanQual(estate,
1309                                                            resultRelInfo->ri_RangeTableIndex, &ctid);
1310
1311                                 if (!TupIsNull(epqslot))
1312                                 {
1313                                         *tupleid = ctid;
1314                                         goto ldelete;
1315                                 }
1316                         }
1317                         /* tuple already deleted; nothing to do */
1318                         return;
1319
1320                 default:
1321                         elog(ERROR, "Unknown status %u from heap_delete", result);
1322                         return;
1323         }
1324
1325         IncrDeleted();
1326         (estate->es_processed)++;
1327
1328         /*
1329          * Note: Normally one would think that we have to delete index tuples
1330          * associated with the heap tuple now..
1331          *
1332          * ... but in POSTGRES, we have no need to do this because the vacuum
1333          * daemon automatically opens an index scan and deletes index tuples
1334          * when it finds deleted heap tuples. -cim 9/27/89
1335          */
1336
1337         /* AFTER ROW DELETE Triggers */
1338         if (resultRelInfo->ri_TrigDesc)
1339                 ExecARDeleteTriggers(estate, resultRelInfo, tupleid);
1340 }
1341
1342 /* ----------------------------------------------------------------
1343  *              ExecReplace
1344  *
1345  *              note: we can't run replace queries with transactions
1346  *              off because replaces are actually appends and our
1347  *              scan will mistakenly loop forever, replacing the tuple
1348  *              it just appended..      This should be fixed but until it
1349  *              is, we don't want to get stuck in an infinite loop
1350  *              which corrupts your database..
1351  * ----------------------------------------------------------------
1352  */
1353 static void
1354 ExecReplace(TupleTableSlot *slot,
1355                         ItemPointer tupleid,
1356                         EState *estate)
1357 {
1358         HeapTuple       tuple;
1359         ResultRelInfo *resultRelInfo;
1360         Relation        resultRelationDesc;
1361         ItemPointerData ctid;
1362         int                     result;
1363         int                     numIndices;
1364
1365         /*
1366          * abort the operation if not running transactions
1367          */
1368         if (IsBootstrapProcessingMode())
1369         {
1370                 elog(WARNING, "ExecReplace: replace can't run without transactions");
1371                 return;
1372         }
1373
1374         /*
1375          * get the heap tuple out of the tuple table slot
1376          */
1377         tuple = slot->val;
1378
1379         /*
1380          * get information on the (current) result relation
1381          */
1382         resultRelInfo = estate->es_result_relation_info;
1383         resultRelationDesc = resultRelInfo->ri_RelationDesc;
1384
1385         /* BEFORE ROW UPDATE Triggers */
1386         if (resultRelInfo->ri_TrigDesc &&
1387           resultRelInfo->ri_TrigDesc->n_before_row[TRIGGER_EVENT_UPDATE] > 0)
1388         {
1389                 HeapTuple       newtuple;
1390
1391                 newtuple = ExecBRUpdateTriggers(estate, resultRelInfo,
1392                                                                                 tupleid, tuple);
1393
1394                 if (newtuple == NULL)   /* "do nothing" */
1395                         return;
1396
1397                 if (newtuple != tuple)  /* modified by Trigger(s) */
1398                 {
1399                         /*
1400                          * Insert modified tuple into tuple table slot, replacing the
1401                          * original.  We assume that it was allocated in per-tuple
1402                          * memory context, and therefore will go away by itself. The
1403                          * tuple table slot should not try to clear it.
1404                          */
1405                         ExecStoreTuple(newtuple, slot, InvalidBuffer, false);
1406                         tuple = newtuple;
1407                 }
1408         }
1409
1410         /*
1411          * Check the constraints of the tuple
1412          *
1413          * If we generate a new candidate tuple after EvalPlanQual testing, we
1414          * must loop back here and recheck constraints.  (We don't need to
1415          * redo triggers, however.      If there are any BEFORE triggers then
1416          * trigger.c will have done mark4update to lock the correct tuple, so
1417          * there's no need to do them again.)
1418          */
1419 lreplace:;
1420         if (resultRelationDesc->rd_att->constr)
1421                 ExecConstraints("ExecReplace", resultRelInfo, slot, estate);
1422
1423         /*
1424          * replace the heap tuple
1425          */
1426         result = heap_update(resultRelationDesc, tupleid, tuple, &ctid);
1427         switch (result)
1428         {
1429                 case HeapTupleSelfUpdated:
1430                         return;
1431
1432                 case HeapTupleMayBeUpdated:
1433                         break;
1434
1435                 case HeapTupleUpdated:
1436                         if (XactIsoLevel == XACT_SERIALIZABLE)
1437                                 elog(ERROR, "Can't serialize access due to concurrent update");
1438                         else if (!(ItemPointerEquals(tupleid, &ctid)))
1439                         {
1440                                 TupleTableSlot *epqslot = EvalPlanQual(estate,
1441                                                            resultRelInfo->ri_RangeTableIndex, &ctid);
1442
1443                                 if (!TupIsNull(epqslot))
1444                                 {
1445                                         *tupleid = ctid;
1446                                         tuple = ExecRemoveJunk(estate->es_junkFilter, epqslot);
1447                                         slot = ExecStoreTuple(tuple,
1448                                                                         estate->es_junkFilter->jf_resultSlot,
1449                                                                                   InvalidBuffer, true);
1450                                         goto lreplace;
1451                                 }
1452                         }
1453                         /* tuple already deleted; nothing to do */
1454                         return;
1455
1456                 default:
1457                         elog(ERROR, "Unknown status %u from heap_update", result);
1458                         return;
1459         }
1460
1461         IncrReplaced();
1462         (estate->es_processed)++;
1463
1464         /*
1465          * Note: instead of having to update the old index tuples associated
1466          * with the heap tuple, all we do is form and insert new index tuples.
1467          * This is because replaces are actually deletes and inserts and index
1468          * tuple deletion is done automagically by the vacuum daemon. All we
1469          * do is insert new index tuples.  -cim 9/27/89
1470          */
1471
1472         /*
1473          * process indices
1474          *
1475          * heap_update updates a tuple in the base relation by invalidating it
1476          * and then appending a new tuple to the relation.      As a side effect,
1477          * the tupleid of the new tuple is placed in the new tuple's t_ctid
1478          * field.  So we now insert index tuples using the new tupleid stored
1479          * there.
1480          */
1481
1482         numIndices = resultRelInfo->ri_NumIndices;
1483         if (numIndices > 0)
1484                 ExecInsertIndexTuples(slot, &(tuple->t_self), estate, true);
1485
1486         /* AFTER ROW UPDATE Triggers */
1487         if (resultRelInfo->ri_TrigDesc)
1488                 ExecARUpdateTriggers(estate, resultRelInfo, tupleid, tuple);
1489 }
1490
1491 static char *
1492 ExecRelCheck(ResultRelInfo *resultRelInfo,
1493                          TupleTableSlot *slot, EState *estate)
1494 {
1495         Relation        rel = resultRelInfo->ri_RelationDesc;
1496         int                     ncheck = rel->rd_att->constr->num_check;
1497         ConstrCheck *check = rel->rd_att->constr->check;
1498         ExprContext *econtext;
1499         MemoryContext oldContext;
1500         List       *qual;
1501         int                     i;
1502
1503         /*
1504          * If first time through for this result relation, build expression
1505          * nodetrees for rel's constraint expressions.  Keep them in the
1506          * per-query memory context so they'll survive throughout the query.
1507          */
1508         if (resultRelInfo->ri_ConstraintExprs == NULL)
1509         {
1510                 oldContext = MemoryContextSwitchTo(estate->es_query_cxt);
1511                 resultRelInfo->ri_ConstraintExprs =
1512                         (List **) palloc(ncheck * sizeof(List *));
1513                 for (i = 0; i < ncheck; i++)
1514                 {
1515                         qual = (List *) stringToNode(check[i].ccbin);
1516                         resultRelInfo->ri_ConstraintExprs[i] = qual;
1517                 }
1518                 MemoryContextSwitchTo(oldContext);
1519         }
1520
1521         /*
1522          * We will use the EState's per-tuple context for evaluating
1523          * constraint expressions (creating it if it's not already there).
1524          */
1525         econtext = GetPerTupleExprContext(estate);
1526
1527         /* Arrange for econtext's scan tuple to be the tuple under test */
1528         econtext->ecxt_scantuple = slot;
1529
1530         /* And evaluate the constraints */
1531         for (i = 0; i < ncheck; i++)
1532         {
1533                 qual = resultRelInfo->ri_ConstraintExprs[i];
1534
1535                 /*
1536                  * NOTE: SQL92 specifies that a NULL result from a constraint
1537                  * expression is not to be treated as a failure.  Therefore, tell
1538                  * ExecQual to return TRUE for NULL.
1539                  */
1540                 if (!ExecQual(qual, econtext, true))
1541                         return check[i].ccname;
1542         }
1543
1544         /* NULL result means no error */
1545         return (char *) NULL;
1546 }
1547
1548 void
1549 ExecConstraints(char *caller, ResultRelInfo *resultRelInfo,
1550                                 TupleTableSlot *slot, EState *estate)
1551 {
1552         Relation        rel = resultRelInfo->ri_RelationDesc;
1553         HeapTuple       tuple = slot->val;
1554         TupleConstr *constr = rel->rd_att->constr;
1555
1556         Assert(constr);
1557
1558         if (constr->has_not_null)
1559         {
1560                 int                     natts = rel->rd_att->natts;
1561                 int                     attrChk;
1562
1563                 for (attrChk = 1; attrChk <= natts; attrChk++)
1564                 {
1565                         if (rel->rd_att->attrs[attrChk - 1]->attnotnull &&
1566                                 heap_attisnull(tuple, attrChk))
1567                                 elog(ERROR, "%s: Fail to add null value in not null attribute %s",
1568                                          caller, NameStr(rel->rd_att->attrs[attrChk - 1]->attname));
1569                 }
1570         }
1571
1572         if (constr->num_check > 0)
1573         {
1574                 char       *failed;
1575
1576                 if ((failed = ExecRelCheck(resultRelInfo, slot, estate)) != NULL)
1577                         elog(ERROR, "%s: rejected due to CHECK constraint %s",
1578                                  caller, failed);
1579         }
1580 }
1581
1582 /*
1583  * Check a modified tuple to see if we want to process its updated version
1584  * under READ COMMITTED rules.
1585  *
1586  * See backend/executor/README for some info about how this works.
1587  */
1588 TupleTableSlot *
1589 EvalPlanQual(EState *estate, Index rti, ItemPointer tid)
1590 {
1591         evalPlanQual *epq;
1592         EState     *epqstate;
1593         Relation        relation;
1594         HeapTupleData tuple;
1595         HeapTuple       copyTuple = NULL;
1596         int                     rtsize;
1597         bool            endNode;
1598
1599         Assert(rti != 0);
1600
1601         /*
1602          * find relation containing target tuple
1603          */
1604         if (estate->es_result_relation_info != NULL &&
1605                 estate->es_result_relation_info->ri_RangeTableIndex == rti)
1606                 relation = estate->es_result_relation_info->ri_RelationDesc;
1607         else
1608         {
1609                 List       *l;
1610
1611                 relation = NULL;
1612                 foreach(l, estate->es_rowMark)
1613                 {
1614                         if (((execRowMark *) lfirst(l))->rti == rti)
1615                         {
1616                                 relation = ((execRowMark *) lfirst(l))->relation;
1617                                 break;
1618                         }
1619                 }
1620                 if (relation == NULL)
1621                         elog(ERROR, "EvalPlanQual: can't find RTE %d", (int) rti);
1622         }
1623
1624         /*
1625          * fetch tid tuple
1626          *
1627          * Loop here to deal with updated or busy tuples
1628          */
1629         tuple.t_self = *tid;
1630         for (;;)
1631         {
1632                 Buffer          buffer;
1633
1634                 heap_fetch(relation, SnapshotDirty, &tuple, &buffer, NULL);
1635                 if (tuple.t_data != NULL)
1636                 {
1637                         TransactionId xwait = SnapshotDirty->xmax;
1638
1639                         if (TransactionIdIsValid(SnapshotDirty->xmin))
1640                                 elog(ERROR, "EvalPlanQual: t_xmin is uncommitted ?!");
1641
1642                         /*
1643                          * If tuple is being updated by other transaction then we have
1644                          * to wait for its commit/abort.
1645                          */
1646                         if (TransactionIdIsValid(xwait))
1647                         {
1648                                 ReleaseBuffer(buffer);
1649                                 XactLockTableWait(xwait);
1650                                 continue;
1651                         }
1652
1653                         /*
1654                          * We got tuple - now copy it for use by recheck query.
1655                          */
1656                         copyTuple = heap_copytuple(&tuple);
1657                         ReleaseBuffer(buffer);
1658                         break;
1659                 }
1660
1661                 /*
1662                  * Oops! Invalid tuple. Have to check is it updated or deleted.
1663                  * Note that it's possible to get invalid SnapshotDirty->tid if
1664                  * tuple updated by this transaction. Have we to check this ?
1665                  */
1666                 if (ItemPointerIsValid(&(SnapshotDirty->tid)) &&
1667                         !(ItemPointerEquals(&(tuple.t_self), &(SnapshotDirty->tid))))
1668                 {
1669                         /* updated, so look at the updated copy */
1670                         tuple.t_self = SnapshotDirty->tid;
1671                         continue;
1672                 }
1673
1674                 /*
1675                  * Deleted or updated by this transaction; forget it.
1676                  */
1677                 return NULL;
1678         }
1679
1680         /*
1681          * For UPDATE/DELETE we have to return tid of actual row we're
1682          * executing PQ for.
1683          */
1684         *tid = tuple.t_self;
1685
1686         /*
1687          * Need to run a recheck subquery.      Find or create a PQ stack entry.
1688          */
1689         epq = (evalPlanQual *) estate->es_evalPlanQual;
1690         rtsize = length(estate->es_range_table);
1691         endNode = true;
1692
1693         if (epq != NULL && epq->rti == 0)
1694         {
1695                 /* Top PQ stack entry is idle, so re-use it */
1696                 Assert(!(estate->es_useEvalPlan) &&
1697                            epq->estate.es_evalPlanQual == NULL);
1698                 epq->rti = rti;
1699                 endNode = false;
1700         }
1701
1702         /*
1703          * If this is request for another RTE - Ra, - then we have to check
1704          * wasn't PlanQual requested for Ra already and if so then Ra' row was
1705          * updated again and we have to re-start old execution for Ra and
1706          * forget all what we done after Ra was suspended. Cool? -:))
1707          */
1708         if (epq != NULL && epq->rti != rti &&
1709                 epq->estate.es_evTuple[rti - 1] != NULL)
1710         {
1711                 do
1712                 {
1713                         evalPlanQual *oldepq;
1714
1715                         /* pop previous PlanQual from the stack */
1716                         epqstate = &(epq->estate);
1717                         oldepq = (evalPlanQual *) epqstate->es_evalPlanQual;
1718                         Assert(oldepq->rti != 0);
1719                         /* stop execution */
1720                         ExecEndNode(epq->plan, NULL);
1721                         ExecDropTupleTable(epqstate->es_tupleTable, true);
1722                         epqstate->es_tupleTable = NULL;
1723                         heap_freetuple(epqstate->es_evTuple[epq->rti - 1]);
1724                         epqstate->es_evTuple[epq->rti - 1] = NULL;
1725                         /* push current PQ to freePQ stack */
1726                         oldepq->free = epq;
1727                         epq = oldepq;
1728                         estate->es_evalPlanQual = (Pointer) epq;
1729                 } while (epq->rti != rti);
1730         }
1731
1732         /*
1733          * If we are requested for another RTE then we have to suspend
1734          * execution of current PlanQual and start execution for new one.
1735          */
1736         if (epq == NULL || epq->rti != rti)
1737         {
1738                 /* try to reuse plan used previously */
1739                 evalPlanQual *newepq = (epq != NULL) ? epq->free : NULL;
1740
1741                 if (newepq == NULL)             /* first call or freePQ stack is empty */
1742                 {
1743                         newepq = (evalPlanQual *) palloc(sizeof(evalPlanQual));
1744                         newepq->free = NULL;
1745
1746                         /*
1747                          * Each stack level has its own copy of the plan tree.  This
1748                          * is wasteful, but necessary as long as plan nodes point to
1749                          * exec state nodes rather than vice versa.  Note that
1750                          * copyfuncs.c doesn't attempt to copy the exec state nodes,
1751                          * which is a good thing in this situation.
1752                          */
1753                         newepq->plan = copyObject(estate->es_origPlan);
1754
1755                         /*
1756                          * Init stack level's EState.  We share top level's copy of
1757                          * es_result_relations array and other non-changing status. We
1758                          * need our own tupletable, es_param_exec_vals, and other
1759                          * changeable state.
1760                          */
1761                         epqstate = &(newepq->estate);
1762                         memcpy(epqstate, estate, sizeof(EState));
1763                         epqstate->es_direction = ForwardScanDirection;
1764                         if (estate->es_origPlan->nParamExec > 0)
1765                                 epqstate->es_param_exec_vals = (ParamExecData *)
1766                                         palloc(estate->es_origPlan->nParamExec *
1767                                                    sizeof(ParamExecData));
1768                         epqstate->es_tupleTable = NULL;
1769                         epqstate->es_per_tuple_exprcontext = NULL;
1770
1771                         /*
1772                          * Each epqstate must have its own es_evTupleNull state, but
1773                          * all the stack entries share es_evTuple state.  This allows
1774                          * sub-rechecks to inherit the value being examined by an
1775                          * outer recheck.
1776                          */
1777                         epqstate->es_evTupleNull = (bool *) palloc(rtsize * sizeof(bool));
1778                         if (epq == NULL)
1779                         {
1780                                 /* first PQ stack entry */
1781                                 epqstate->es_evTuple = (HeapTuple *)
1782                                         palloc(rtsize * sizeof(HeapTuple));
1783                                 memset(epqstate->es_evTuple, 0, rtsize * sizeof(HeapTuple));
1784                         }
1785                         else
1786                         {
1787                                 /* later stack entries share the same storage */
1788                                 epqstate->es_evTuple = epq->estate.es_evTuple;
1789                         }
1790                 }
1791                 else
1792                 {
1793                         /* recycle previously used EState */
1794                         epqstate = &(newepq->estate);
1795                 }
1796                 /* push current PQ to the stack */
1797                 epqstate->es_evalPlanQual = (Pointer) epq;
1798                 epq = newepq;
1799                 estate->es_evalPlanQual = (Pointer) epq;
1800                 epq->rti = rti;
1801                 endNode = false;
1802         }
1803
1804         Assert(epq->rti == rti);
1805         epqstate = &(epq->estate);
1806
1807         /*
1808          * Ok - we're requested for the same RTE.  Unfortunately we still have
1809          * to end and restart execution of the plan, because ExecReScan
1810          * wouldn't ensure that upper plan nodes would reset themselves.  We
1811          * could make that work if insertion of the target tuple were
1812          * integrated with the Param mechanism somehow, so that the upper plan
1813          * nodes know that their children's outputs have changed.
1814          */
1815         if (endNode)
1816         {
1817                 /* stop execution */
1818                 ExecEndNode(epq->plan, NULL);
1819                 ExecDropTupleTable(epqstate->es_tupleTable, true);
1820                 epqstate->es_tupleTable = NULL;
1821         }
1822
1823         /*
1824          * free old RTE' tuple, if any, and store target tuple where
1825          * relation's scan node will see it
1826          */
1827         if (epqstate->es_evTuple[rti - 1] != NULL)
1828                 heap_freetuple(epqstate->es_evTuple[rti - 1]);
1829         epqstate->es_evTuple[rti - 1] = copyTuple;
1830
1831         /*
1832          * Initialize for new recheck query; be careful to copy down state
1833          * that might have changed in top EState.
1834          */
1835         epqstate->es_result_relation_info = estate->es_result_relation_info;
1836         epqstate->es_junkFilter = estate->es_junkFilter;
1837         if (estate->es_origPlan->nParamExec > 0)
1838                 memset(epqstate->es_param_exec_vals, 0,
1839                            estate->es_origPlan->nParamExec * sizeof(ParamExecData));
1840         memset(epqstate->es_evTupleNull, false, rtsize * sizeof(bool));
1841         epqstate->es_useEvalPlan = false;
1842         Assert(epqstate->es_tupleTable == NULL);
1843         epqstate->es_tupleTable =
1844                 ExecCreateTupleTable(estate->es_tupleTable->size);
1845
1846         ExecInitNode(epq->plan, epqstate, NULL);
1847
1848         return EvalPlanQualNext(estate);
1849 }
1850
1851 static TupleTableSlot *
1852 EvalPlanQualNext(EState *estate)
1853 {
1854         evalPlanQual *epq = (evalPlanQual *) estate->es_evalPlanQual;
1855         EState     *epqstate = &(epq->estate);
1856         evalPlanQual *oldepq;
1857         TupleTableSlot *slot;
1858
1859         Assert(epq->rti != 0);
1860
1861 lpqnext:;
1862         slot = ExecProcNode(epq->plan, NULL);
1863
1864         /*
1865          * No more tuples for this PQ. Continue previous one.
1866          */
1867         if (TupIsNull(slot))
1868         {
1869                 /* stop execution */
1870                 ExecEndNode(epq->plan, NULL);
1871                 ExecDropTupleTable(epqstate->es_tupleTable, true);
1872                 epqstate->es_tupleTable = NULL;
1873                 heap_freetuple(epqstate->es_evTuple[epq->rti - 1]);
1874                 epqstate->es_evTuple[epq->rti - 1] = NULL;
1875                 /* pop old PQ from the stack */
1876                 oldepq = (evalPlanQual *) epqstate->es_evalPlanQual;
1877                 if (oldepq == (evalPlanQual *) NULL)
1878                 {
1879                         epq->rti = 0;           /* this is the first (oldest) */
1880                         estate->es_useEvalPlan = false;         /* PQ - mark as free and          */
1881                         return (NULL);          /* continue Query execution   */
1882                 }
1883                 Assert(oldepq->rti != 0);
1884                 /* push current PQ to freePQ stack */
1885                 oldepq->free = epq;
1886                 epq = oldepq;
1887                 epqstate = &(epq->estate);
1888                 estate->es_evalPlanQual = (Pointer) epq;
1889                 goto lpqnext;
1890         }
1891
1892         return (slot);
1893 }
1894
1895 static void
1896 EndEvalPlanQual(EState *estate)
1897 {
1898         evalPlanQual *epq = (evalPlanQual *) estate->es_evalPlanQual;
1899         EState     *epqstate = &(epq->estate);
1900         evalPlanQual *oldepq;
1901
1902         if (epq->rti == 0)                      /* plans already shutdowned */
1903         {
1904                 Assert(epq->estate.es_evalPlanQual == NULL);
1905                 return;
1906         }
1907
1908         for (;;)
1909         {
1910                 /* stop execution */
1911                 ExecEndNode(epq->plan, NULL);
1912                 ExecDropTupleTable(epqstate->es_tupleTable, true);
1913                 epqstate->es_tupleTable = NULL;
1914                 if (epqstate->es_evTuple[epq->rti - 1] != NULL)
1915                 {
1916                         heap_freetuple(epqstate->es_evTuple[epq->rti - 1]);
1917                         epqstate->es_evTuple[epq->rti - 1] = NULL;
1918                 }
1919                 /* pop old PQ from the stack */
1920                 oldepq = (evalPlanQual *) epqstate->es_evalPlanQual;
1921                 if (oldepq == (evalPlanQual *) NULL)
1922                 {
1923                         epq->rti = 0;           /* this is the first (oldest) */
1924                         estate->es_useEvalPlan = false;         /* PQ - mark as free */
1925                         break;
1926                 }
1927                 Assert(oldepq->rti != 0);
1928                 /* push current PQ to freePQ stack */
1929                 oldepq->free = epq;
1930                 epq = oldepq;
1931                 epqstate = &(epq->estate);
1932                 estate->es_evalPlanQual = (Pointer) epq;
1933         }
1934 }