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

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

数据库系统

开发平台：

Unix_Linux

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 'feature' and 'count' arguments that specify whether
  23.  * the plan is to be executed forwards, backwards, and for how many tuples.
  24.  *
  25.  * Copyright (c) 1994, Regents of the University of California
  26.  *
  27.  *
  28.  * IDENTIFICATION
  29.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/executor/execMain.c,v 1.88 1999/06/17 15:15:49 momjian Exp $
  30.  *
  31.  *-------------------------------------------------------------------------
  32.  */
  33. #include <string.h>
  34. #include "postgres.h"
  35. #include "miscadmin.h"
  37. #include "executor/executor.h"
  38. #include "executor/execdefs.h"
  39. #include "executor/execdebug.h"
  40. #include "executor/nodeIndexscan.h"
  41. #include "utils/builtins.h"
  42. #include "utils/palloc.h"
  43. #include "utils/acl.h"
  44. #include "utils/syscache.h"
  45. #include "utils/tqual.h"
  46. #include "parser/parsetree.h" /* rt_fetch() */
  47. #include "storage/bufmgr.h"
  48. #include "storage/lmgr.h"
  49. #include "storage/smgr.h"
  50. #include "commands/async.h"
  51. /* #include "access/localam.h" */
  52. #include "optimizer/var.h"
  53. #include "access/heapam.h"
  54. #include "access/xact.h"
  55. #include "catalog/heap.h"
  56. #include "commands/trigger.h"
  58. void ExecCheckPerms(CmdType operation, int resultRelation, List *rangeTable,
  59.    Query *parseTree);
  62. /* decls for local routines only used within this module */
  63. static TupleDesc InitPlan(CmdType operation,
  64.  Query *parseTree,
  65.  Plan *plan,
  66.  EState *estate);
  67. static void EndPlan(Plan *plan,
  68. EState *estate);
  69. static TupleTableSlot *ExecutePlan(EState *estate, Plan *plan,
  70. CmdType operation,
  71. int offsetTuples,
  72. int numberTuples,
  73. ScanDirection direction,
  74. DestReceiver *destfunc);
  75. static void ExecRetrieve(TupleTableSlot *slot,
  76.  DestReceiver *destfunc,
  77.  EState *estate);
  78. static void ExecAppend(TupleTableSlot *slot, ItemPointer tupleid,
  79.    EState *estate);
  80. static void ExecDelete(TupleTableSlot *slot, ItemPointer tupleid,
  81.    EState *estate);
  82. static void ExecReplace(TupleTableSlot *slot, ItemPointer tupleid,
  83. EState *estate);
  85. TupleTableSlot *EvalPlanQual(EState *estate, Index rti, ItemPointer tid);
  86. static TupleTableSlot *EvalPlanQualNext(EState *estate);
  89. /* end of local decls */
  91. /* ----------------------------------------------------------------
  92.  * ExecutorStart
  93.  *
  94.  * This routine must be called at the beginning of any execution of any
  95.  * query plan
  96.  *
  97.  * returns (AttrInfo*) which describes the attributes of the tuples to
  98.  * be returned by the query.
  99.  *
  100.  * ----------------------------------------------------------------
  101.  */
  102. TupleDesc
  103. ExecutorStart(QueryDesc *queryDesc, EState *estate)
  104. {
  105. TupleDesc result;
  107. /* sanity checks */
  108. Assert(queryDesc != NULL);
  110. if (queryDesc->plantree->nParamExec > 0)
  111. {
  112. estate->es_param_exec_vals = (ParamExecData *)
  113. palloc(queryDesc->plantree->nParamExec * sizeof(ParamExecData));
  114. memset(estate->es_param_exec_vals, 0, queryDesc->plantree->nParamExec * sizeof(ParamExecData));
  115. }
  117. /*
  118.  * Make our own private copy of the current queries snapshot data
  119.  */
  120. if (QuerySnapshot == NULL)
  121. estate->es_snapshot = NULL;
  122. else
  123. {
  124. estate->es_snapshot = (Snapshot) palloc(sizeof(SnapshotData));
  125. memcpy(estate->es_snapshot, QuerySnapshot, sizeof(SnapshotData));
  126. if (estate->es_snapshot->xcnt > 0)
  127. {
  128. estate->es_snapshot->xip = (TransactionId *)
  129. palloc(estate->es_snapshot->xcnt * sizeof(TransactionId));
  130. memcpy(estate->es_snapshot->xip, QuerySnapshot->xip,
  131.    estate->es_snapshot->xcnt * sizeof(TransactionId));
  132. }
  133. }
  135. /*
  136.  * Initialize the plan
  137.  */
  138. result = InitPlan(queryDesc->operation,
  139.   queryDesc->parsetree,
  140.   queryDesc->plantree,
  141.   estate);
  143. /*
  144.  * reset buffer refcount.  the current refcounts are saved and will be
  145.  * restored when ExecutorEnd is called
  146.  *
  147.  * this makes sure that when ExecutorRun's are called recursively as for
  148.  * postquel functions, the buffers pinned by one ExecutorRun will not
  149.  * be unpinned by another ExecutorRun.
  150.  */
  151. BufferRefCountReset(estate->es_refcount);
  153. return result;
  154. }
  156. /* ----------------------------------------------------------------
  157.  * ExecutorRun
  158.  *
  159.  * This is the main routine of the executor module. It accepts
  160.  * the query descriptor from the traffic cop and executes the
  161.  * query plan.
  162.  *
  163.  * ExecutorStart must have been called already.
  164.  *
  165.  * the different features supported are:
  166.  *  EXEC_RUN: retrieve all tuples in the forward direction
  167.  *  EXEC_FOR: retrieve 'count' number of tuples in the forward dir
  168.  *  EXEC_BACK: retrieve 'count' number of tuples in the backward dir
  169.  *  EXEC_RETONE: return one tuple but don't 'retrieve' it
  170.  *    used in postquel function processing
  171.  *
  172.  *
  173.  * ----------------------------------------------------------------
  174.  */
  175. TupleTableSlot *
  176. ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature,
  177. Node *limoffset, Node *limcount)
  178. {
  179. CmdType operation;
  180. Plan    *plan;
  181. TupleTableSlot *result;
  182. CommandDest dest;
  183. DestReceiver *destfunc;
  184. int offset = 0;
  185. int count = 0;
  187. /*
  188.  * sanity checks
  189.  */
  190. Assert(queryDesc != NULL);
  192. /*
  193.  * extract information from the query descriptor and the query
  194.  * feature.
  195.  */
  196. operation = queryDesc->operation;
  197. plan = queryDesc->plantree;
  198. dest = queryDesc->dest;
  199. destfunc = DestToFunction(dest);
  200. estate->es_processed = 0;
  201. estate->es_lastoid = InvalidOid;
  203. /*
  204.  * FIXME: the dest setup function ought to be handed the tuple desc
  205.  * for the tuples to be output, but I'm not quite sure how to get that
  206.  * info at this point. For now, passing NULL is OK because no
  207.  * existing dest setup function actually uses the pointer.
  208.  */
  209. (*destfunc->setup) (destfunc, (TupleDesc) NULL);
  211. /*
  212.  * if given get the offset of the LIMIT clause
  213.  */
  214. if (limoffset != NULL)
  215. {
  216. Const    *coffset;
  217. Param    *poffset;
  218. ParamListInfo paramLI;
  219. int i;
  221. switch (nodeTag(limoffset))
  222. {
  223. case T_Const:
  224. coffset = (Const *) limoffset;
  225. offset = (int) (coffset->constvalue);
  226. break;
  228. case T_Param:
  229. poffset = (Param *) limoffset;
  230. paramLI = estate->es_param_list_info;
  232. if (paramLI == NULL)
  233. elog(ERROR, "parameter for limit offset not in executor state");
  234. for (i = 0; paramLI[i].kind != PARAM_INVALID; i++)
  235. {
  236. if (paramLI[i].kind == PARAM_NUM && paramLI[i].id == poffset->paramid)
  237. break;
  238. }
  239. if (paramLI[i].kind == PARAM_INVALID)
  240. elog(ERROR, "parameter for limit offset not in executor state");
  241. if (paramLI[i].isnull)
  242. elog(ERROR, "limit offset cannot be NULL value");
  243. offset = (int) (paramLI[i].value);
  245. break;
  247. default:
  248. elog(ERROR, "unexpected node type %d as limit offset", nodeTag(limoffset));
  249. }
  251. if (offset < 0)
  252. elog(ERROR, "limit offset cannot be negative");
  253. }
  255. /*
  256.  * if given get the count of the LIMIT clause
  257.  */
  258. if (limcount != NULL)
  259. {
  260. Const    *ccount;
  261. Param    *pcount;
  262. ParamListInfo paramLI;
  263. int i;
  265. switch (nodeTag(limcount))
  266. {
  267. case T_Const:
  268. ccount = (Const *) limcount;
  269. count = (int) (ccount->constvalue);
  270. break;
  272. case T_Param:
  273. pcount = (Param *) limcount;
  274. paramLI = estate->es_param_list_info;
  276. if (paramLI == NULL)
  277. elog(ERROR, "parameter for limit count not in executor state");
  278. for (i = 0; paramLI[i].kind != PARAM_INVALID; i++)
  279. {
  280. if (paramLI[i].kind == PARAM_NUM && paramLI[i].id == pcount->paramid)
  281. break;
  282. }
  283. if (paramLI[i].kind == PARAM_INVALID)
  284. elog(ERROR, "parameter for limit count not in executor state");
  285. if (paramLI[i].isnull)
  286. elog(ERROR, "limit count cannot be NULL value");
  287. count = (int) (paramLI[i].value);
  289. break;
  291. default:
  292. elog(ERROR, "unexpected node type %d as limit count", nodeTag(limcount));
  293. }
  295. if (count < 0)
  296. elog(ERROR, "limit count cannot be negative");
  297. }
  299. switch (feature)
  300. {
  302. case EXEC_RUN:
  303. result = ExecutePlan(estate,
  304.  plan,
  305.  operation,
  306.  offset,
  307.  count,
  308.  ForwardScanDirection,
  309.  destfunc);
  310. break;
  311. case EXEC_FOR:
  312. result = ExecutePlan(estate,
  313.  plan,
  314.  operation,
  315.  offset,
  316.  count,
  317.  ForwardScanDirection,
  318.  destfunc);
  319. break;
  321. /*
  322.  * retrieve next n "backward" tuples
  323.  */
  324. case EXEC_BACK:
  325. result = ExecutePlan(estate,
  326.  plan,
  327.  operation,
  328.  offset,
  329.  count,
  330.  BackwardScanDirection,
  331.  destfunc);
  332. break;
  334. /*
  335.  * return one tuple but don't "retrieve" it. (this is used by
  336.  * the rule manager..) -cim 9/14/89
  337.  */
  338. case EXEC_RETONE:
  339. result = ExecutePlan(estate,
  340.  plan,
  341.  operation,
  342.  0,
  343.  ONE_TUPLE,
  344.  ForwardScanDirection,
  345.  destfunc);
  346. break;
  347. default:
  348. result = NULL;
  349. elog(DEBUG, "ExecutorRun: Unknown feature %d", feature);
  350. break;
  351. }
  353. (*destfunc->cleanup) (destfunc);
  355. return result;
  356. }
  358. /* ----------------------------------------------------------------
  359.  * ExecutorEnd
  360.  *
  361.  * This routine must be called at the end of any execution of any
  362.  * query plan
  363.  *
  364.  * returns (AttrInfo*) which describes the attributes of the tuples to
  365.  * be returned by the query.
  366.  *
  367.  * ----------------------------------------------------------------
  368.  */
  369. void
  370. ExecutorEnd(QueryDesc *queryDesc, EState *estate)
  371. {
  372. /* sanity checks */
  373. Assert(queryDesc != NULL);
  375. EndPlan(queryDesc->plantree, estate);
  377. /* XXX - clean up some more from ExecutorStart() - er1p */
  378. if (NULL == estate->es_snapshot)
  379. {
  380. /* nothing to free */
  381. }
  382. else
  383. {
  384. if (estate->es_snapshot->xcnt > 0)
  385. pfree(estate->es_snapshot->xip);
  386. pfree(estate->es_snapshot);
  387. }
  389. if (NULL == estate->es_param_exec_vals)
  390. {
  391. /* nothing to free */
  392. }
  393. else
  394. {
  395. pfree(estate->es_param_exec_vals);
  396. estate->es_param_exec_vals = NULL;
  397. }
  399. /* restore saved refcounts. */
  400. BufferRefCountRestore(estate->es_refcount);
  402. }
  404. void
  405. ExecCheckPerms(CmdType operation,
  406.    int resultRelation,
  407.    List *rangeTable,
  408.    Query *parseTree)
  409. {
  410. int i = 1;
  411. Oid relid;
  412. HeapTuple htup;
  413. List    *lp;
  414. List    *qvars,
  415.    *tvars;
  416. int32 ok = 1,
  417. aclcheck_result = -1;
  418. char    *opstr;
  419. NameData rname;
  420. char    *userName;
  422. #define CHECK(MODE) pg_aclcheck(rname.data, userName, MODE)
  424. userName = GetPgUserName();
  426. foreach(lp, rangeTable)
  427. {
  428. RangeTblEntry *rte = lfirst(lp);
  430. if (rte->skipAcl)
  431. {
  433. /*
  434.  * This happens if the access to this table is due to a view
  435.  * query rewriting - the rewrite handler checked the
  436.  * permissions against the view owner, so we just skip this
  437.  * entry.
  438.  */
  439. continue;
  440. }
  442. relid = rte->relid;
  443. htup = SearchSysCacheTuple(RELOID,
  444.    ObjectIdGetDatum(relid),
  445.    0, 0, 0);
  446. if (!HeapTupleIsValid(htup))
  447. elog(ERROR, "ExecCheckPerms: bogus RT relid: %u", relid);
  448. StrNCpy(rname.data,
  449. ((Form_pg_class) GETSTRUCT(htup))->relname.data,
  450. NAMEDATALEN);
  451. if (i == resultRelation)
  452. { /* this is the result relation */
  453. qvars = pull_varnos(parseTree->qual);
  454. tvars = pull_varnos((Node *) parseTree->targetList);
  455. if (intMember(resultRelation, qvars) ||
  456. intMember(resultRelation, tvars))
  457. {
  458. /* result relation is scanned */
  459. ok = ((aclcheck_result = CHECK(ACL_RD)) == ACLCHECK_OK);
  460. opstr = "read";
  461. if (!ok)
  462. break;
  463. }
  464. switch (operation)
  465. {
  466. case CMD_INSERT:
  467. ok = ((aclcheck_result = CHECK(ACL_AP)) == ACLCHECK_OK) ||
  468. ((aclcheck_result = CHECK(ACL_WR)) == ACLCHECK_OK);
  469. opstr = "append";
  470. break;
  471. case CMD_DELETE:
  472. case CMD_UPDATE:
  473. ok = ((aclcheck_result = CHECK(ACL_WR)) == ACLCHECK_OK);
  474. opstr = "write";
  475. break;
  476. default:
  477. elog(ERROR, "ExecCheckPerms: bogus operation %d",
  478.  operation);
  479. }
  480. }
  481. else
  482. {
  483. ok = ((aclcheck_result = CHECK(ACL_RD)) == ACLCHECK_OK);
  484. opstr = "read";
  485. }
  486. if (!ok)
  487. break;
  488. ++i;
  489. }
  490. if (!ok)
  491. elog(ERROR, "%s: %s", rname.data, aclcheck_error_strings[aclcheck_result]);
  493. if (parseTree != NULL && parseTree->rowMark != NULL)
  494. {
  495. foreach(lp, parseTree->rowMark)
  496. {
  497. RowMark    *rm = lfirst(lp);
  499. if (!(rm->info & ROW_ACL_FOR_UPDATE))
  500. continue;
  502. relid = ((RangeTblEntry *) nth(rm->rti - 1, rangeTable))->relid;
  503. htup = SearchSysCacheTuple(RELOID,
  504.    ObjectIdGetDatum(relid),
  505.    0, 0, 0);
  506. if (!HeapTupleIsValid(htup))
  507. elog(ERROR, "ExecCheckPerms: bogus RT relid: %u", relid);
  508. StrNCpy(rname.data,
  509. ((Form_pg_class) GETSTRUCT(htup))->relname.data,
  510. NAMEDATALEN);
  511. ok = ((aclcheck_result = CHECK(ACL_WR)) == ACLCHECK_OK);
  512. opstr = "write";
  513. if (!ok)
  514. elog(ERROR, "%s: %s", rname.data, aclcheck_error_strings[aclcheck_result]);
  515. }
  516. }
  517. }
  519. /* ===============================================================
  520.  * ===============================================================
  521.  static routines follow
  522.  * ===============================================================
  523.  * ===============================================================
  524.  */
  526. typedef struct execRowMark
  527. {
  528. Relation relation;
  529. Index rti;
  530. char resname[32];
  531. } execRowMark;
  533. typedef struct evalPlanQual
  534. {
  535. Plan    *plan;
  536. Index rti;
  537. EState estate;
  538. struct evalPlanQual *free;
  539. } evalPlanQual;
  541. /* ----------------------------------------------------------------
  542.  * InitPlan
  543.  *
  544.  * Initializes the query plan: open files, allocate storage
  545.  * and start up the rule manager
  546.  * ----------------------------------------------------------------
  547.  */
  548. static TupleDesc
  549. InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
  550. {
  551. List    *rangeTable;
  552. int resultRelation;
  553. Relation intoRelationDesc;
  554. TupleDesc tupType;
  555. List    *targetList;
  556. int len;
  558. /*
  559.  * get information from query descriptor
  560.  */
  561. rangeTable = parseTree->rtable;
  562. resultRelation = parseTree->resultRelation;
  564. #ifndef NO_SECURITY
  565. ExecCheckPerms(operation, resultRelation, rangeTable, parseTree);
  566. #endif
  568. /*
  569.  * initialize the node's execution state
  570.  */
  571. estate->es_range_table = rangeTable;
  573. /*
  574.  * initialize the BaseId counter so node base_id's are assigned
  575.  * correctly.  Someday baseid's will have to be stored someplace other
  576.  * than estate because they should be unique per query planned.
  577.  */
  578. estate->es_BaseId = 1;
  580. /*
  581.  * initialize result relation stuff
  582.  */
  584. if (resultRelation != 0 && operation != CMD_SELECT)
  585. {
  587. /*
  588.  * if we have a result relation, open it and initialize the result
  589.  * relation info stuff.
  590.  */
  591. RelationInfo *resultRelationInfo;
  592. Index resultRelationIndex;
  593. RangeTblEntry *rtentry;
  594. Oid resultRelationOid;
  595. Relation resultRelationDesc;
  597. resultRelationIndex = resultRelation;
  598. rtentry = rt_fetch(resultRelationIndex, rangeTable);
  599. resultRelationOid = rtentry->relid;
  600. resultRelationDesc = heap_open(resultRelationOid);
  602. if (resultRelationDesc->rd_rel->relkind == RELKIND_SEQUENCE)
  603. elog(ERROR, "You can't change sequence relation %s",
  604.  resultRelationDesc->rd_rel->relname.data);
  606. LockRelation(resultRelationDesc, RowExclusiveLock);
  608. resultRelationInfo = makeNode(RelationInfo);
  609. resultRelationInfo->ri_RangeTableIndex = resultRelationIndex;
  610. resultRelationInfo->ri_RelationDesc = resultRelationDesc;
  611. resultRelationInfo->ri_NumIndices = 0;
  612. resultRelationInfo->ri_IndexRelationDescs = NULL;
  613. resultRelationInfo->ri_IndexRelationInfo = NULL;
  615. /*
  616.  * open indices on result relation and save descriptors in the
  617.  * result relation information..
  618.  */
  619. if (operation != CMD_DELETE)
  620. ExecOpenIndices(resultRelationOid, resultRelationInfo);
  622. estate->es_result_relation_info = resultRelationInfo;
  623. }
  624. else
  625. {
  627. /*
  628.  * if no result relation, then set state appropriately
  629.  */
  630. estate->es_result_relation_info = NULL;
  631. }
  633. /*
  634.  * Have to lock relations selected for update
  635.  */
  636. estate->es_rowMark = NULL;
  637. if (parseTree->rowMark != NULL)
  638. {
  639. Relation relation;
  640. Oid relid;
  641. RowMark    *rm;
  642. List    *l;
  643. execRowMark *erm;
  645. foreach(l, parseTree->rowMark)
  646. {
  647. rm = lfirst(l);
  648. relid = ((RangeTblEntry *) nth(rm->rti - 1, rangeTable))->relid;
  649. relation = heap_open(relid);
  650. LockRelation(relation, RowShareLock);
  651. if (!(rm->info & ROW_MARK_FOR_UPDATE))
  652. continue;
  653. erm = (execRowMark *) palloc(sizeof(execRowMark));
  654. erm->relation = relation;
  655. erm->rti = rm->rti;
  656. sprintf(erm->resname, "ctid%u", rm->rti);
  657. estate->es_rowMark = lappend(estate->es_rowMark, erm);
  658. }
  659. }
  661. /*
  662.  * initialize the executor "tuple" table.
  663.  */
  664. {
  665. int nSlots = ExecCountSlotsNode(plan);
  666. TupleTable tupleTable = ExecCreateTupleTable(nSlots + 10); /* why add ten? - jolly */
  668. estate->es_tupleTable = tupleTable;
  669. }
  671. /*
  672.  * initialize the private state information for all the nodes in the
  673.  * query tree. This opens files, allocates storage and leaves us
  674.  * ready to start processing tuples..
  675.  */
  676. ExecInitNode(plan, estate, NULL);
  678. /*
  679.  * get the tuple descriptor describing the type of tuples to return..
  680.  * (this is especially important if we are creating a relation with
  681.  * "retrieve into")
  682.  */
  683. tupType = ExecGetTupType(plan); /* tuple descriptor */
  684. targetList = plan->targetlist;
  685. len = ExecTargetListLength(targetList); /* number of attributes */
  687. /*
  688.  * now that we have the target list, initialize the junk filter if
  689.  * this is a REPLACE or a DELETE query. We also init the junk filter
  690.  * if this is an append query (there might be some rule lock info
  691.  * there...) NOTE: in the future we might want to initialize the junk
  692.  * filter for all queries. SELECT added by daveh@insightdist.com
  693.  * 5/20/98 to allow ORDER/GROUP BY have an identifier missing from the
  694.  * target.
  695.  */
  696. {
  697. bool junk_filter_needed = false;
  698. List    *tlist;
  700. if (operation == CMD_SELECT)
  701. {
  702. foreach(tlist, targetList)
  703. {
  704. TargetEntry *tle = lfirst(tlist);
  706. if (tle->resdom->resjunk)
  707. {
  708. junk_filter_needed = true;
  709. break;
  710. }
  711. }
  712. }
  714. if (operation == CMD_UPDATE || operation == CMD_DELETE ||
  715. operation == CMD_INSERT ||
  716. (operation == CMD_SELECT && junk_filter_needed))
  717. {
  718. JunkFilter *j = (JunkFilter *) ExecInitJunkFilter(targetList);
  720. estate->es_junkFilter = j;
  722. if (operation == CMD_SELECT)
  723. tupType = j->jf_cleanTupType;
  724. }
  725. else
  726. estate->es_junkFilter = NULL;
  727. }
  729. /*
  730.  * initialize the "into" relation
  731.  */
  732. intoRelationDesc = (Relation) NULL;
  734. if (operation == CMD_SELECT)
  735. {
  736. char    *intoName;
  737. Oid intoRelationId;
  738. TupleDesc tupdesc;
  740. if (!parseTree->isPortal)
  741. {
  743. /*
  744.  * a select into table
  745.  */
  746. if (parseTree->into != NULL)
  747. {
  749. /*
  750.  * create the "into" relation
  751.  */
  752. intoName = parseTree->into;
  754. /*
  755.  * have to copy tupType to get rid of constraints
  756.  */
  757. tupdesc = CreateTupleDescCopy(tupType);
  759. intoRelationId = heap_create_with_catalog(intoName,
  760.    tupdesc, RELKIND_RELATION, parseTree->isTemp);
  762. FreeTupleDesc(tupdesc);
  764. /*
  765.  * XXX rather than having to call setheapoverride(true)
  766.  * and then back to false, we should change the arguments
  767.  * to heap_open() instead..
  768.  */
  769. setheapoverride(true);
  771. intoRelationDesc = heap_open(intoRelationId);
  773. setheapoverride(false);
  774. }
  775. }
  776. }
  778. estate->es_into_relation_descriptor = intoRelationDesc;
  780. estate->es_origPlan = plan;
  781. estate->es_evalPlanQual = NULL;
  782. estate->es_evTuple = NULL;
  783. estate->es_useEvalPlan = false;
  785. return tupType;
  786. }
  788. /* ----------------------------------------------------------------
  789.  * EndPlan
  790.  *
  791.  * Cleans up the query plan -- closes files and free up storages
  792.  * ----------------------------------------------------------------
  793.  */
  794. static void
  795. EndPlan(Plan *plan, EState *estate)
  796. {
  797. RelationInfo *resultRelationInfo;
  798. Relation intoRelationDesc;
  800. /*
  801.  * get information from state
  802.  */
  803. resultRelationInfo = estate->es_result_relation_info;
  804. intoRelationDesc = estate->es_into_relation_descriptor;
  806. /*
  807.  * shut down the query
  808.  */
  809. ExecEndNode(plan, plan);
  811. /*
  812.  * destroy the executor "tuple" table.
  813.  */
  814. {
  815. TupleTable tupleTable = (TupleTable) estate->es_tupleTable;
  817. ExecDestroyTupleTable(tupleTable, true); /* was missing last arg */
  818. estate->es_tupleTable = NULL;
  819. }
  821. /*
  822.  * close the result relations if necessary
  823.  */
  824. if (resultRelationInfo != NULL)
  825. {
  826. Relation resultRelationDesc;
  828. resultRelationDesc = resultRelationInfo->ri_RelationDesc;
  829. heap_close(resultRelationDesc);
  831. /*
  832.  * close indices on the result relation
  833.  */
  834. ExecCloseIndices(resultRelationInfo);
  835. }
  837. /*
  838.  * close the "into" relation if necessary
  839.  */
  840. if (intoRelationDesc != NULL)
  841. heap_close(intoRelationDesc);
  842. }
  844. /* ----------------------------------------------------------------
  845.  * ExecutePlan
  846.  *
  847.  * processes the query plan to retrieve 'tupleCount' tuples in the
  848.  * direction specified.
  849.  * Retrieves all tuples if tupleCount is 0
  850.  *
  851.  * result is either a slot containing a tuple in the case
  852.  * of a RETRIEVE or NULL otherwise.
  853.  *
  854.  * ----------------------------------------------------------------
  855.  */
  857. /* the ctid attribute is a 'junk' attribute that is removed before the
  858.    user can see it*/
  860. static TupleTableSlot *
  861. ExecutePlan(EState *estate,
  862. Plan *plan,
  863. CmdType operation,
  864. int offsetTuples,
  865. int numberTuples,
  866. ScanDirection direction,
  867. DestReceiver *destfunc)
  868. {
  869. JunkFilter *junkfilter;
  870. TupleTableSlot *slot;
  871. ItemPointer tupleid = NULL;
  872. ItemPointerData tuple_ctid;
  873. int current_tuple_count;
  874. TupleTableSlot *result;
  876. /*
  877.  * initialize local variables
  878.  */
  879. slot = NULL;
  880. current_tuple_count = 0;
  881. result = NULL;
  883. /*
  884.  * Set the direction.
  885.  */
  886. estate->es_direction = direction;
  888. /*
  889.  * Loop until we've processed the proper number of tuples from the
  890.  * plan..
  891.  */
  893. for (;;)
  894. {
  896. /*
  897.  * Execute the plan and obtain a tuple
  898.  */
  899. /* at the top level, the parent of a plan (2nd arg) is itself */
  900. lnext: ;
  901. if (estate->es_useEvalPlan)
  902. {
  903. slot = EvalPlanQualNext(estate);
  904. if (TupIsNull(slot))
  905. slot = ExecProcNode(plan, plan);
  906. }
  907. else
  908. slot = ExecProcNode(plan, plan);
  910. /*
  911.  * if the tuple is null, then we assume there is nothing more to
  912.  * process so we just return null...
  913.  */
  914. if (TupIsNull(slot))
  915. {
  916. result = NULL;
  917. break;
  918. }
  920. /*
  921.  * For now we completely execute the plan and skip result tuples
  922.  * if requested by LIMIT offset. Finally we should try to do it in
  923.  * deeper levels if possible (during index scan) - Jan
  924.  */
  925. if (offsetTuples > 0)
  926. {
  927. --offsetTuples;
  928. continue;
  929. }
  931. /*
  932.  * if we have a junk filter, then project a new tuple with the
  933.  * junk removed.
  934.  *
  935.  * Store this new "clean" tuple in the place of the original tuple.
  936.  *
  937.  * Also, extract all the junk information we need.
  938.  */
  939. if ((junkfilter = estate->es_junkFilter) != (JunkFilter *) NULL)
  940. {
  941. Datum datum;
  942. HeapTuple newTuple;
  943. bool isNull;
  945. /*
  946.  * extract the 'ctid' junk attribute.
  947.  */
  948. if (operation == CMD_UPDATE || operation == CMD_DELETE)
  949. {
  950. if (!ExecGetJunkAttribute(junkfilter,
  951.   slot,
  952.   "ctid",
  953.   &datum,
  954.   &isNull))
  955. elog(ERROR, "ExecutePlan: NO (junk) `ctid' was found!");
  957. if (isNull)
  958. elog(ERROR, "ExecutePlan: (junk) `ctid' is NULL!");
  960. tupleid = (ItemPointer) DatumGetPointer(datum);
  961. tuple_ctid = *tupleid; /* make sure we don't free the
  962.  * ctid!! */
  963. tupleid = &tuple_ctid;
  964. }
  965. else if (estate->es_rowMark != NULL)
  966. {
  967. List    *l;
  968. execRowMark *erm;
  969. Buffer buffer;
  970. HeapTupleData tuple;
  971. TupleTableSlot *newSlot;
  972. int test;
  974. lmark: ;
  975. foreach(l, estate->es_rowMark)
  976. {
  977. erm = lfirst(l);
  978. if (!ExecGetJunkAttribute(junkfilter,
  979.   slot,
  980.   erm->resname,
  981.   &datum,
  982.   &isNull))
  983. elog(ERROR, "ExecutePlan: NO (junk) `%s' was found!", erm->resname);
  985. if (isNull)
  986. elog(ERROR, "ExecutePlan: (junk) `%s' is NULL!", erm->resname);
  988. tuple.t_self = *((ItemPointer) DatumGetPointer(datum));
  989. test = heap_mark4update(erm->relation, &tuple, &buffer);
  990. ReleaseBuffer(buffer);
  991. switch (test)
  992. {
  993. case HeapTupleSelfUpdated:
  994. case HeapTupleMayBeUpdated:
  995. break;
  997. case HeapTupleUpdated:
  998. if (XactIsoLevel == XACT_SERIALIZABLE)
  999. {
  1000. elog(ERROR, "Can't serialize access due to concurrent update");
  1001. return (NULL);
  1002. }
  1003. else if (!(ItemPointerEquals(&(tuple.t_self),
  1004.   (ItemPointer) DatumGetPointer(datum))))
  1005. {
  1006. newSlot = EvalPlanQual(estate, erm->rti, &(tuple.t_self));
  1007. if (!(TupIsNull(newSlot)))
  1008. {
  1009. slot = newSlot;
  1010. estate->es_useEvalPlan = true;
  1011. goto lmark;
  1012. }
  1013. }
  1015. /*
  1016.  * if tuple was deleted or PlanQual failed for
  1017.  * updated tuple - we have not return this
  1018.  * tuple!
  1019.  */
  1020. goto lnext;
  1022. default:
  1023. elog(ERROR, "Unknown status %u from heap_mark4update", test);
  1024. return (NULL);
  1025. }
  1026. }
  1027. }
  1029. /*
  1030.  * Finally create a new "clean" tuple with all junk attributes
  1031.  * removed
  1032.  */
  1033. newTuple = ExecRemoveJunk(junkfilter, slot);
  1035. slot = ExecStoreTuple(newTuple, /* tuple to store */
  1036.   slot, /* destination slot */
  1037.   InvalidBuffer, /* this tuple has no
  1038.  * buffer */
  1039.   true); /* tuple should be pfreed */
  1040. } /* if (junkfilter... */
  1042. /*
  1043.  * now that we have a tuple, do the appropriate thing with it..
  1044.  * either return it to the user, add it to a relation someplace,
  1045.  * delete it from a relation, or modify some of it's attributes.
  1046.  */
  1048. switch (operation)
  1049. {
  1050. case CMD_SELECT:
  1051. ExecRetrieve(slot, /* slot containing tuple */
  1052.  destfunc, /* destination's tuple-receiver
  1053.  * obj */
  1054.  estate); /* */
  1055. result = slot;
  1056. break;
  1058. case CMD_INSERT:
  1059. ExecAppend(slot, tupleid, estate);
  1060. result = NULL;
  1061. break;
  1063. case CMD_DELETE:
  1064. ExecDelete(slot, tupleid, estate);
  1065. result = NULL;
  1066. break;
  1068. case CMD_UPDATE:
  1069. ExecReplace(slot, tupleid, estate);
  1070. result = NULL;
  1071. break;
  1073. default:
  1074. elog(DEBUG, "ExecutePlan: unknown operation in queryDesc");
  1075. result = NULL;
  1076. break;
  1077. }
  1079. /*
  1080.  * check our tuple count.. if we've returned the proper number
  1081.  * then return, else loop again and process more tuples..
  1082.  */
  1083. current_tuple_count += 1;
  1084. if (numberTuples == current_tuple_count)
  1085. break;
  1086. }
  1088. /*
  1089.  * here, result is either a slot containing a tuple in the case of a
  1090.  * RETRIEVE or NULL otherwise.
  1091.  */
  1092. return result;
  1093. }
  1095. /* ----------------------------------------------------------------
  1096.  * ExecRetrieve
  1097.  *
  1098.  * RETRIEVEs are easy.. we just pass the tuple to the appropriate
  1099.  * print function.  The only complexity is when we do a
  1100.  * "retrieve into", in which case we insert the tuple into
  1101.  * the appropriate relation (note: this is a newly created relation
  1102.  * so we don't need to worry about indices or locks.)
  1103.  * ----------------------------------------------------------------
  1104.  */
  1105. static void
  1106. ExecRetrieve(TupleTableSlot *slot,
  1107.  DestReceiver *destfunc,
  1108.  EState *estate)
  1109. {
  1110. HeapTuple tuple;
  1111. TupleDesc attrtype;
  1113. /*
  1114.  * get the heap tuple out of the tuple table slot
  1115.  */
  1116. tuple = slot->val;
  1117. attrtype = slot->ttc_tupleDescriptor;
  1119. /*
  1120.  * insert the tuple into the "into relation"
  1121.  */
  1122. if (estate->es_into_relation_descriptor != NULL)
  1123. {
  1124. heap_insert(estate->es_into_relation_descriptor, tuple);
  1125. IncrAppended();
  1126. }
  1128. /*
  1129.  * send the tuple to the front end (or the screen)
  1130.  */
  1131. (*destfunc->receiveTuple) (tuple, attrtype, destfunc);
  1132. IncrRetrieved();
  1133. (estate->es_processed)++;
  1134. }
  1136. /* ----------------------------------------------------------------
  1137.  * ExecAppend
  1138.  *
  1139.  * APPENDs are trickier.. we have to insert the tuple into
  1140.  * the base relation and insert appropriate tuples into the
  1141.  * index relations.
  1142.  * ----------------------------------------------------------------
  1143.  */
  1145. static void
  1146. ExecAppend(TupleTableSlot *slot,
  1147.    ItemPointer tupleid,
  1148.    EState *estate)
  1149. {
  1150. HeapTuple tuple;
  1151. RelationInfo *resultRelationInfo;
  1152. Relation resultRelationDesc;
  1153. int numIndices;
  1154. Oid newId;
  1156. /*
  1157.  * get the heap tuple out of the tuple table slot
  1158.  */
  1159. tuple = slot->val;
  1161. /*
  1162.  * get information on the result relation
  1163.  */
  1164. resultRelationInfo = estate->es_result_relation_info;
  1165. resultRelationDesc = resultRelationInfo->ri_RelationDesc;
  1167. /*
  1168.  * have to add code to preform unique checking here. cim -12/1/89
  1169.  */
  1171. /* BEFORE ROW INSERT Triggers */
  1172. if (resultRelationDesc->trigdesc &&
  1173. resultRelationDesc->trigdesc->n_before_row[TRIGGER_EVENT_INSERT] > 0)
  1174. {
  1175. HeapTuple newtuple;
  1177. newtuple = ExecBRInsertTriggers(resultRelationDesc, tuple);
  1179. if (newtuple == NULL) /* "do nothing" */
  1180. return;
  1182. if (newtuple != tuple) /* modified by Trigger(s) */
  1183. {
  1184. Assert(slot->ttc_shouldFree);
  1185. pfree(tuple);
  1186. slot->val = tuple = newtuple;
  1187. }
  1188. }
  1190. /*
  1191.  * Check the constraints of a tuple
  1192.  */
  1194. if (resultRelationDesc->rd_att->constr)
  1195. ExecConstraints("ExecAppend", resultRelationDesc, tuple, estate);
  1197. /*
  1198.  * insert the tuple
  1199.  */
  1200. newId = heap_insert(resultRelationDesc, /* relation desc */
  1201. tuple); /* heap tuple */
  1202. IncrAppended();
  1204. /*
  1205.  * process indices
  1206.  *
  1207.  * Note: heap_insert adds a new tuple to a relation.  As a side effect,
  1208.  * the tupleid of the new tuple is placed in the new tuple's t_ctid
  1209.  * field.
  1210.  */
  1211. numIndices = resultRelationInfo->ri_NumIndices;
  1212. if (numIndices > 0)
  1213. ExecInsertIndexTuples(slot, &(tuple->t_self), estate, false);
  1214. (estate->es_processed)++;
  1215. estate->es_lastoid = newId;
  1217. /* AFTER ROW INSERT Triggers */
  1218. if (resultRelationDesc->trigdesc &&
  1219.  resultRelationDesc->trigdesc->n_after_row[TRIGGER_EVENT_INSERT] > 0)
  1220. ExecARInsertTriggers(resultRelationDesc, tuple);
  1221. }
  1223. /* ----------------------------------------------------------------
  1224.  * ExecDelete
  1225.  *
  1226.  * DELETE is like append, we delete the tuple and its
  1227.  * index tuples.
  1228.  * ----------------------------------------------------------------
  1229.  */
  1230. static void
  1231. ExecDelete(TupleTableSlot *slot,
  1232.    ItemPointer tupleid,
  1233.    EState *estate)
  1234. {
  1235. RelationInfo *resultRelationInfo;
  1236. Relation resultRelationDesc;
  1237. ItemPointerData ctid;
  1238. int result;
  1240. /*
  1241.  * get the result relation information
  1242.  */
  1243. resultRelationInfo = estate->es_result_relation_info;
  1244. resultRelationDesc = resultRelationInfo->ri_RelationDesc;
  1246. /* BEFORE ROW DELETE Triggers */
  1247. if (resultRelationDesc->trigdesc &&
  1248. resultRelationDesc->trigdesc->n_before_row[TRIGGER_EVENT_DELETE] > 0)
  1249. {
  1250. bool dodelete;
  1252. dodelete = ExecBRDeleteTriggers(estate, tupleid);
  1254. if (!dodelete) /* "do nothing" */
  1255. return;
  1256. }
  1258. /*
  1259.  * delete the tuple
  1260.  */
  1261. ldelete:;
  1262. result = heap_delete(resultRelationDesc, tupleid, &ctid);
  1263. switch (result)
  1264. {
  1265. case HeapTupleSelfUpdated:
  1266. return;
  1268. case HeapTupleMayBeUpdated:
  1269. break;
  1271. case HeapTupleUpdated:
  1272. if (XactIsoLevel == XACT_SERIALIZABLE)
  1273. elog(ERROR, "Can't serialize access due to concurrent update");
  1274. else if (!(ItemPointerEquals(tupleid, &ctid)))
  1275. {
  1276. TupleTableSlot *epqslot = EvalPlanQual(estate,
  1277.   resultRelationInfo->ri_RangeTableIndex, &ctid);
  1279. if (!TupIsNull(epqslot))
  1280. {
  1281. *tupleid = ctid;
  1282. goto ldelete;
  1283. }
  1284. }
  1285. return;
  1287. default:
  1288. elog(ERROR, "Unknown status %u from heap_delete", result);
  1289. return;
  1290. }
  1292. IncrDeleted();
  1293. (estate->es_processed)++;
  1295. /*
  1296.  * Note: Normally one would think that we have to delete index tuples
  1297.  * associated with the heap tuple now..
  1298.  *
  1299.  * ... but in POSTGRES, we have no need to do this because the vacuum
  1300.  * daemon automatically opens an index scan and deletes index tuples
  1301.  * when it finds deleted heap tuples. -cim 9/27/89
  1302.  */
  1304. /* AFTER ROW DELETE Triggers */
  1305. if (resultRelationDesc->trigdesc &&
  1306.  resultRelationDesc->trigdesc->n_after_row[TRIGGER_EVENT_DELETE] > 0)
  1307. ExecARDeleteTriggers(estate, tupleid);
  1309. }
  1311. /* ----------------------------------------------------------------
  1312.  * ExecReplace
  1313.  *
  1314.  * note: we can't run replace queries with transactions
  1315.  * off because replaces are actually appends and our
  1316.  * scan will mistakenly loop forever, replacing the tuple
  1317.  * it just appended.. This should be fixed but until it
  1318.  * is, we don't want to get stuck in an infinite loop
  1319.  * which corrupts your database..
  1320.  * ----------------------------------------------------------------
  1321.  */
  1322. static void
  1323. ExecReplace(TupleTableSlot *slot,
  1324. ItemPointer tupleid,
  1325. EState *estate)
  1326. {
  1327. HeapTuple tuple;
  1328. RelationInfo *resultRelationInfo;
  1329. Relation resultRelationDesc;
  1330. ItemPointerData ctid;
  1331. int result;
  1332. int numIndices;
  1334. /*
  1335.  * abort the operation if not running transactions
  1336.  */
  1337. if (IsBootstrapProcessingMode())
  1338. {
  1339. elog(DEBUG, "ExecReplace: replace can't run without transactions");
  1340. return;
  1341. }
  1343. /*
  1344.  * get the heap tuple out of the tuple table slot
  1345.  */
  1346. tuple = slot->val;
  1348. /*
  1349.  * get the result relation information
  1350.  */
  1351. resultRelationInfo = estate->es_result_relation_info;
  1352. resultRelationDesc = resultRelationInfo->ri_RelationDesc;
  1354. /*
  1355.  * have to add code to preform unique checking here. in the event of
  1356.  * unique tuples, this becomes a deletion of the original tuple
  1357.  * affected by the replace. cim -12/1/89
  1358.  */
  1360. /* BEFORE ROW UPDATE Triggers */
  1361. if (resultRelationDesc->trigdesc &&
  1362. resultRelationDesc->trigdesc->n_before_row[TRIGGER_EVENT_UPDATE] > 0)
  1363. {
  1364. HeapTuple newtuple;
  1366. newtuple = ExecBRUpdateTriggers(estate, tupleid, tuple);
  1368. if (newtuple == NULL) /* "do nothing" */
  1369. return;
  1371. if (newtuple != tuple) /* modified by Trigger(s) */
  1372. {
  1373. Assert(slot->ttc_shouldFree);
  1374. pfree(tuple);
  1375. slot->val = tuple = newtuple;
  1376. }
  1377. }
  1379. /*
  1380.  * Check the constraints of a tuple
  1381.  */
  1383. if (resultRelationDesc->rd_att->constr)
  1384. ExecConstraints("ExecReplace", resultRelationDesc, tuple, estate);
  1386. /*
  1387.  * replace the heap tuple
  1388.  */
  1389. lreplace:;
  1390. result = heap_replace(resultRelationDesc, tupleid, tuple, &ctid);
  1391. switch (result)
  1392. {
  1393. case HeapTupleSelfUpdated:
  1394. return;
  1396. case HeapTupleMayBeUpdated:
  1397. break;
  1399. case HeapTupleUpdated:
  1400. if (XactIsoLevel == XACT_SERIALIZABLE)
  1401. elog(ERROR, "Can't serialize access due to concurrent update");
  1402. else if (!(ItemPointerEquals(tupleid, &ctid)))
  1403. {
  1404. TupleTableSlot *epqslot = EvalPlanQual(estate,
  1405.   resultRelationInfo->ri_RangeTableIndex, &ctid);
  1407. if (!TupIsNull(epqslot))
  1408. {
  1409. *tupleid = ctid;
  1410. tuple = ExecRemoveJunk(estate->es_junkFilter, epqslot);
  1411. slot = ExecStoreTuple(tuple, slot, InvalidBuffer, true);
  1412. goto lreplace;
  1413. }
  1414. }
  1415. return;
  1417. default:
  1418. elog(ERROR, "Unknown status %u from heap_replace", result);
  1419. return;
  1420. }
  1422. IncrReplaced();
  1423. (estate->es_processed)++;
  1425. /*
  1426.  * Note: instead of having to update the old index tuples associated
  1427.  * with the heap tuple, all we do is form and insert new index
  1428.  * tuples..  This is because replaces are actually deletes and inserts
  1429.  * and index tuple deletion is done automagically by the vaccuum
  1430.  * deamon.. All we do is insert new index tuples.  -cim 9/27/89
  1431.  */
  1433. /*
  1434.  * process indices
  1435.  *
  1436.  * heap_replace updates a tuple in the base relation by invalidating it
  1437.  * and then appending a new tuple to the relation. As a side effect,
  1438.  * the tupleid of the new tuple is placed in the new tuple's t_ctid
  1439.  * field.  So we now insert index tuples using the new tupleid stored
  1440.  * there.
  1441.  */
  1443. numIndices = resultRelationInfo->ri_NumIndices;
  1444. if (numIndices > 0)
  1445. ExecInsertIndexTuples(slot, &(tuple->t_self), estate, true);
  1447. /* AFTER ROW UPDATE Triggers */
  1448. if (resultRelationDesc->trigdesc &&
  1449.  resultRelationDesc->trigdesc->n_after_row[TRIGGER_EVENT_UPDATE] > 0)
  1450. ExecARUpdateTriggers(estate, tupleid, tuple);
  1451. }
  1453. #ifdef NOT_USED
  1454. static HeapTuple
  1455. ExecAttrDefault(Relation rel, HeapTuple tuple)
  1456. {
  1457. int ndef = rel->rd_att->constr->num_defval;
  1458. AttrDefault *attrdef = rel->rd_att->constr->defval;
  1459. ExprContext *econtext = makeNode(ExprContext);
  1460. HeapTuple newtuple;
  1461. Node    *expr;
  1462. bool isnull;
  1463. bool isdone;
  1464. Datum val;
  1465. Datum    *replValue = NULL;
  1466. char    *replNull = NULL;
  1467. char    *repl = NULL;
  1468. int i;
  1470. econtext->ecxt_scantuple = NULL; /* scan tuple slot */
  1471. econtext->ecxt_innertuple = NULL; /* inner tuple slot */
  1472. econtext->ecxt_outertuple = NULL; /* outer tuple slot */
  1473. econtext->ecxt_relation = NULL; /* relation */
  1474. econtext->ecxt_relid = 0; /* relid */
  1475. econtext->ecxt_param_list_info = NULL; /* param list info */
  1476. econtext->ecxt_param_exec_vals = NULL; /* exec param values */
  1477. econtext->ecxt_range_table = NULL; /* range table */
  1478. for (i = 0; i < ndef; i++)
  1479. {
  1480. if (!heap_attisnull(tuple, attrdef[i].adnum))
  1481. continue;
  1482. expr = (Node *) stringToNode(attrdef[i].adbin);
  1484. val = ExecEvalExpr(expr, econtext, &isnull, &isdone);
  1486. pfree(expr);
  1488. if (isnull)
  1489. continue;
  1491. if (repl == NULL)
  1492. {
  1493. repl = (char *) palloc(rel->rd_att->natts * sizeof(char));
  1494. replNull = (char *) palloc(rel->rd_att->natts * sizeof(char));
  1495. replValue = (Datum *) palloc(rel->rd_att->natts * sizeof(Datum));
  1496. MemSet(repl, ' ', rel->rd_att->natts * sizeof(char));
  1497. }
  1499. repl[attrdef[i].adnum - 1] = 'r';
  1500. replNull[attrdef[i].adnum - 1] = ' ';
  1501. replValue[attrdef[i].adnum - 1] = val;
  1503. }
  1505. pfree(econtext);
  1507. if (repl == NULL)
  1508. return tuple;
  1510. newtuple = heap_modifytuple(tuple, rel, replValue, replNull, repl);
  1512. pfree(repl);
  1513. pfree(tuple);
  1514. pfree(replNull);
  1515. pfree(replValue);
  1517. return newtuple;
  1519. }
  1521. #endif
  1523. static char *
  1524. ExecRelCheck(Relation rel, HeapTuple tuple, EState *estate)
  1525. {
  1526. int ncheck = rel->rd_att->constr->num_check;
  1527. ConstrCheck *check = rel->rd_att->constr->check;
  1528. ExprContext *econtext = makeNode(ExprContext);
  1529. TupleTableSlot *slot = makeNode(TupleTableSlot);
  1530. RangeTblEntry *rte = makeNode(RangeTblEntry);
  1531. List    *rtlist;
  1532. List    *qual;
  1533. bool res;
  1534. int i;
  1536. slot->val = tuple;
  1537. slot->ttc_shouldFree = false;
  1538. slot->ttc_descIsNew = true;
  1539. slot->ttc_tupleDescriptor = rel->rd_att;
  1540. slot->ttc_buffer = InvalidBuffer;
  1541. slot->ttc_whichplan = -1;
  1542. rte->relname = nameout(&(rel->rd_rel->relname));
  1543. rte->refname = rte->relname;
  1544. rte->relid = RelationGetRelid(rel);
  1545. rte->inh = false;
  1546. rte->inFromCl = true;
  1547. rtlist = lcons(rte, NIL);
  1548. econtext->ecxt_scantuple = slot; /* scan tuple slot */
  1549. econtext->ecxt_innertuple = NULL; /* inner tuple slot */
  1550. econtext->ecxt_outertuple = NULL; /* outer tuple slot */
  1551. econtext->ecxt_relation = rel; /* relation */
  1552. econtext->ecxt_relid = 0; /* relid */
  1553. econtext->ecxt_param_list_info = NULL; /* param list info */
  1554. econtext->ecxt_param_exec_vals = NULL; /* exec param values */
  1555. econtext->ecxt_range_table = rtlist; /* range table */
  1557. if (estate->es_result_relation_constraints == NULL)
  1558. {
  1559. estate->es_result_relation_constraints =
  1560. (List **) palloc(ncheck * sizeof(List *));
  1562. for (i = 0; i < ncheck; i++)
  1563. {
  1564. qual = (List *) stringToNode(check[i].ccbin);
  1565. estate->es_result_relation_constraints[i] = qual;
  1566. }
  1567. }
  1569. for (i = 0; i < ncheck; i++)
  1570. {
  1571. qual = estate->es_result_relation_constraints[i];
  1573. res = ExecQual(qual, econtext);
  1575. if (!res)
  1576. return check[i].ccname;
  1577. }
  1579. pfree(slot);
  1580. pfree(rte->relname);
  1581. pfree(rte);
  1582. pfree(rtlist);
  1583. pfree(econtext);
  1585. return (char *) NULL;
  1587. }
  1589. void
  1590. ExecConstraints(char *caller, Relation rel, HeapTuple tuple, EState *estate)
  1591. {
  1593. Assert(rel->rd_att->constr);
  1595. if (rel->rd_att->constr->has_not_null)
  1596. {
  1597. int attrChk;
  1599. for (attrChk = 1; attrChk <= rel->rd_att->natts; attrChk++)
  1600. {
  1601. if (rel->rd_att->attrs[attrChk - 1]->attnotnull && heap_attisnull(tuple, attrChk))
  1602. elog(ERROR, "%s: Fail to add null value in not null attribute %s",
  1603.   caller, rel->rd_att->attrs[attrChk - 1]->attname.data);
  1604. }
  1605. }
  1607. if (rel->rd_att->constr->num_check > 0)
  1608. {
  1609. char    *failed;
  1611. if ((failed = ExecRelCheck(rel, tuple, estate)) != NULL)
  1612. elog(ERROR, "%s: rejected due to CHECK constraint %s", caller, failed);
  1613. }
  1615. return;
  1616. }
  1618. TupleTableSlot *
  1619. EvalPlanQual(EState *estate, Index rti, ItemPointer tid)
  1620. {
  1621. evalPlanQual *epq = (evalPlanQual *) estate->es_evalPlanQual;
  1622. evalPlanQual *oldepq;
  1623. EState    *epqstate = NULL;
  1624. Relation relation;
  1625. Buffer buffer;
  1626. HeapTupleData tuple;
  1627. bool endNode = true;
  1629. Assert(rti != 0);
  1631. if (epq != NULL && epq->rti == 0)
  1632. {
  1633. Assert(!(estate->es_useEvalPlan) &&
  1634.    epq->estate.es_evalPlanQual == NULL);
  1635. epq->rti = rti;
  1636. endNode = false;
  1637. }
  1639. /*
  1640.  * If this is request for another RTE - Ra, - then we have to check
  1641.  * wasn't PlanQual requested for Ra already and if so then Ra' row was
  1642.  * updated again and we have to re-start old execution for Ra and
  1643.  * forget all what we done after Ra was suspended. Cool? -:))
  1644.  */
  1645. if (epq != NULL && epq->rti != rti &&
  1646. epq->estate.es_evTuple[rti - 1] != NULL)
  1647. {
  1648. do
  1649. {
  1650. /* pop previous PlanQual from the stack */
  1651. epqstate = &(epq->estate);
  1652. oldepq = (evalPlanQual *) epqstate->es_evalPlanQual;
  1653. Assert(oldepq->rti != 0);
  1654. /* stop execution */
  1655. ExecEndNode(epq->plan, epq->plan);
  1656.     epqstate->es_tupleTable->next = 0;
  1657. pfree(epqstate->es_evTuple[epq->rti - 1]);
  1658. epqstate->es_evTuple[epq->rti - 1] = NULL;
  1659. /* push current PQ to freePQ stack */
  1660. oldepq->free = epq;
  1661. epq = oldepq;
  1662. } while (epq->rti != rti);
  1663. estate->es_evalPlanQual = (Pointer) epq;
  1664. }
  1666. /*
  1667.  * If we are requested for another RTE then we have to suspend
  1668.  * execution of current PlanQual and start execution for new one.
  1669.  */
  1670. if (epq == NULL || epq->rti != rti)
  1671. {
  1672. /* try to reuse plan used previously */
  1673. evalPlanQual *newepq = (epq != NULL) ? epq->free : NULL;
  1675. if (newepq == NULL) /* first call or freePQ stack is empty */
  1676. {
  1677. newepq = (evalPlanQual *) palloc(sizeof(evalPlanQual));
  1678. /* Init EState */
  1679. epqstate = &(newepq->estate);
  1680. memset(epqstate, 0, sizeof(EState));
  1681. epqstate->type = T_EState;
  1682. epqstate->es_direction = ForwardScanDirection;
  1683. epqstate->es_snapshot = estate->es_snapshot;
  1684. epqstate->es_range_table = estate->es_range_table;
  1685. epqstate->es_param_list_info = estate->es_param_list_info;
  1686. if (estate->es_origPlan->nParamExec > 0)
  1687. epqstate->es_param_exec_vals = (ParamExecData *)
  1688. palloc(estate->es_origPlan->nParamExec *
  1689.    sizeof(ParamExecData));
  1690. epqstate->es_tupleTable =
  1691. ExecCreateTupleTable(estate->es_tupleTable->size);
  1692. epqstate->es_refcount = estate->es_refcount;
  1693. /* ... rest */
  1694. newepq->plan = copyObject(estate->es_origPlan);
  1695. newepq->free = NULL;
  1696. epqstate->es_evTupleNull = (bool *)
  1697. palloc(length(estate->es_range_table) * sizeof(bool));
  1698. if (epq == NULL) /* first call */
  1699. {
  1700. epqstate->es_evTuple = (HeapTuple *)
  1701. palloc(length(estate->es_range_table) * sizeof(HeapTuple));
  1702. memset(epqstate->es_evTuple, 0,
  1703.  length(estate->es_range_table) * sizeof(HeapTuple));
  1704. }
  1705. else
  1706. epqstate->es_evTuple = epq->estate.es_evTuple;
  1707. }
  1708. else
  1709. epqstate = &(newepq->estate);
  1710. /* push current PQ to the stack */
  1711. epqstate->es_evalPlanQual = (Pointer) epq;
  1712. epq = newepq;
  1713. estate->es_evalPlanQual = (Pointer) epq;
  1714. epq->rti = rti;
  1715. endNode = false;
  1716. }
  1718. epqstate = &(epq->estate);
  1720. /*
  1721.  * Ok - we're requested for the same RTE (-:)). I'm not sure about
  1722.  * ability to use ExecReScan instead of ExecInitNode, so...
  1723.  */
  1724. if (endNode)
  1725. {
  1726. ExecEndNode(epq->plan, epq->plan);
  1727.     epqstate->es_tupleTable->next = 0;
  1728. }
  1730. /* free old RTE' tuple */
  1731. if (epqstate->es_evTuple[epq->rti - 1] != NULL)
  1732. {
  1733. pfree(epqstate->es_evTuple[epq->rti - 1]);
  1734. epqstate->es_evTuple[epq->rti - 1] = NULL;
  1735. }
  1737. /* ** fetch tid tuple ** */
  1738. if (estate->es_result_relation_info != NULL &&
  1739. estate->es_result_relation_info->ri_RangeTableIndex == rti)
  1740. relation = estate->es_result_relation_info->ri_RelationDesc;
  1741. else
  1742. {
  1743. List    *l;
  1745. foreach(l, estate->es_rowMark)
  1746. {
  1747. if (((execRowMark *) lfirst(l))->rti == rti)
  1748. break;
  1749. }
  1750. relation = ((execRowMark *) lfirst(l))->relation;
  1751. }
  1752. tuple.t_self = *tid;
  1753. for (;;)
  1754. {
  1755. heap_fetch(relation, SnapshotDirty, &tuple, &buffer);
  1756. if (tuple.t_data != NULL)
  1757. {
  1758. TransactionId xwait = SnapshotDirty->xmax;
  1760. if (TransactionIdIsValid(SnapshotDirty->xmin))
  1761. {
  1762. elog(NOTICE, "EvalPlanQual: t_xmin is uncommitted ?!");
  1763. Assert(!TransactionIdIsValid(SnapshotDirty->xmin));
  1764. elog(ERROR, "Aborting this transaction");
  1765. }
  1767. /*
  1768.  * If tuple is being updated by other transaction then we have
  1769.  * to wait for its commit/abort.
  1770.  */
  1771. if (TransactionIdIsValid(xwait))
  1772. {
  1773. ReleaseBuffer(buffer);
  1774. XactLockTableWait(xwait);
  1775. continue;
  1776. }
  1778. /*
  1779.  * Nice! We got tuple - now copy it.
  1780.  */
  1781. if (epqstate->es_evTuple[epq->rti - 1] != NULL)
  1782. pfree(epqstate->es_evTuple[epq->rti - 1]);
  1783. epqstate->es_evTuple[epq->rti - 1] = heap_copytuple(&tuple);
  1784. ReleaseBuffer(buffer);
  1785. break;
  1786. }
  1788. /*
  1789.  * Ops! Invalid tuple. Have to check is it updated or deleted.
  1790.  * Note that it's possible to get invalid SnapshotDirty->tid if
  1791.  * tuple updated by this transaction. Have we to check this ?
  1792.  */
  1793. if (ItemPointerIsValid(&(SnapshotDirty->tid)) &&
  1794. !(ItemPointerEquals(&(tuple.t_self), &(SnapshotDirty->tid))))
  1795. {
  1796. tuple.t_self = SnapshotDirty->tid; /* updated ... */
  1797. continue;
  1798. }
  1800. /*
  1801.  * Deleted or updated by this transaction. Do not (re-)start
  1802.  * execution of this PQ. Continue previous PQ.
  1803.  */
  1804. oldepq = (evalPlanQual *) epqstate->es_evalPlanQual;
  1805. if (oldepq != NULL)
  1806. {
  1807. Assert(oldepq->rti != 0);
  1808. /* push current PQ to freePQ stack */
  1809. oldepq->free = epq;
  1810. epq = oldepq;
  1811. epqstate = &(epq->estate);
  1812. estate->es_evalPlanQual = (Pointer) epq;
  1813. }
  1814. else
  1815. {
  1816. epq->rti = 0; /* this is the first (oldest) */
  1817. estate->es_useEvalPlan = false; /* PQ - mark as free and      */
  1818. return (NULL); /* continue Query execution   */
  1819. }
  1820. }
  1822. if (estate->es_origPlan->nParamExec > 0)
  1823. memset(epqstate->es_param_exec_vals, 0,
  1824.    estate->es_origPlan->nParamExec * sizeof(ParamExecData));
  1825. memset(epqstate->es_evTupleNull, false,
  1826.    length(estate->es_range_table) * sizeof(bool));
  1827.     Assert(epqstate->es_tupleTable->next == 0);
  1828. ExecInitNode(epq->plan, epqstate, NULL);
  1830. /*
  1831.  * For UPDATE/DELETE we have to return tid of actual row we're
  1832.  * executing PQ for.
  1833.  */
  1834. *tid = tuple.t_self;
  1836. return (EvalPlanQualNext(estate));
  1837. }
  1839. static TupleTableSlot *
  1840. EvalPlanQualNext(EState *estate)
  1841. {
  1842. evalPlanQual *epq = (evalPlanQual *) estate->es_evalPlanQual;
  1843. EState    *epqstate = &(epq->estate);
  1844. evalPlanQual *oldepq;
  1845. TupleTableSlot *slot;
  1847. Assert(epq->rti != 0);
  1849. lpqnext:;
  1850. slot = ExecProcNode(epq->plan, epq->plan);
  1852. /*
  1853.  * No more tuples for this PQ. Continue previous one.
  1854.  */
  1855. if (TupIsNull(slot))
  1856. {
  1857. ExecEndNode(epq->plan, epq->plan);
  1858.     epqstate->es_tupleTable->next = 0;
  1859. pfree(epqstate->es_evTuple[epq->rti - 1]);
  1860. epqstate->es_evTuple[epq->rti - 1] = NULL;
  1861. /* pop old PQ from the stack */
  1862. oldepq = (evalPlanQual *) epqstate->es_evalPlanQual;
  1863. if (oldepq == (evalPlanQual *) NULL)
  1864. {
  1865. epq->rti = 0; /* this is the first (oldest) */
  1866. estate->es_useEvalPlan = false; /* PQ - mark as free and   */
  1867. return (NULL); /* continue Query execution   */
  1868. }
  1869. Assert(oldepq->rti != 0);
  1870. /* push current PQ to freePQ stack */
  1871. oldepq->free = epq;
  1872. epq = oldepq;
  1873. epqstate = &(epq->estate);
  1874. estate->es_evalPlanQual = (Pointer) epq;
  1875. goto lpqnext;
  1876. }
  1878. return (slot);
  1879. }