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

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

数据库系统

开发平台：

Unix_Linux

spi.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * spi.c
  4.  * Server Programming Interface
  5.  *
  6.  * $Id: spi.c,v 1.39 1999/05/25 22:41:02 momjian Exp $
  7.  *
  8.  *-------------------------------------------------------------------------
  9.  */
  10. #include "executor/spi.h"
  11. #include "executor/spi_priv.h"
  12. #include "catalog/pg_type.h"
  13. #include "access/printtup.h"
  14. #include "fmgr.h"
  16. static Portal _SPI_portal = (Portal) NULL;
  17. static _SPI_connection *_SPI_stack = NULL;
  18. static _SPI_connection *_SPI_current = NULL;
  19. static int _SPI_connected = -1;
  20. static int _SPI_curid = -1;
  22. DLLIMPORT uint32 SPI_processed = 0;
  23. DLLIMPORT SPITupleTable *SPI_tuptable;
  24. DLLIMPORT int SPI_result;
  26. static int _SPI_execute(char *src, int tcount, _SPI_plan *plan);
  27. static int _SPI_pquery(QueryDesc *queryDesc, EState *state, int tcount);
  29. static int _SPI_execute_plan(_SPI_plan *plan,
  30.   Datum *Values, char *Nulls, int tcount);
  32. static _SPI_plan *_SPI_copy_plan(_SPI_plan *plan, int location);
  34. static int _SPI_begin_call(bool execmem);
  35. static int _SPI_end_call(bool procmem);
  36. static MemoryContext _SPI_execmem(void);
  37. static MemoryContext _SPI_procmem(void);
  38. static bool _SPI_checktuples(void);
  40. #ifdef SPI_EXECUTOR_STATS
  41. extern int ShowExecutorStats;
  42. extern void ResetUsage(void);
  43. extern void ShowUsage(void);
  45. #endif
  47. /* =================== interface functions =================== */
  49. int
  50. SPI_connect()
  51. {
  52. char pname[64];
  53. PortalVariableMemory pvmem;
  55. /*
  56.  * It's possible on startup and after commit/abort. In future we'll
  57.  * catch commit/abort in some way...
  58.  */
  59. strcpy(pname, "<SPI manager>");
  60. _SPI_portal = GetPortalByName(pname);
  61. if (!PortalIsValid(_SPI_portal))
  62. {
  63. if (_SPI_stack != NULL) /* there was abort */
  64. free(_SPI_stack);
  65. _SPI_current = _SPI_stack = NULL;
  66. _SPI_connected = _SPI_curid = -1;
  67. SPI_processed = 0;
  68. SPI_tuptable = NULL;
  69. _SPI_portal = CreatePortal(pname);
  70. if (!PortalIsValid(_SPI_portal))
  71. elog(FATAL, "SPI_connect: global initialization failed");
  72. }
  74. /*
  75.  * When procedure called by Executor _SPI_curid expected to be equal
  76.  * to _SPI_connected
  77.  */
  78. if (_SPI_curid != _SPI_connected)
  79. return SPI_ERROR_CONNECT;
  81. if (_SPI_stack == NULL)
  82. {
  83. if (_SPI_connected != -1)
  84. elog(FATAL, "SPI_connect: no connection(s) expected");
  85. _SPI_stack = (_SPI_connection *) malloc(sizeof(_SPI_connection));
  86. }
  87. else
  88. {
  89. if (_SPI_connected <= -1)
  90. elog(FATAL, "SPI_connect: some connection(s) expected");
  91. _SPI_stack = (_SPI_connection *) realloc(_SPI_stack,
  92.  (_SPI_connected + 2) * sizeof(_SPI_connection));
  93. }
  95. /*
  96.  * We' returning to procedure where _SPI_curid == _SPI_connected - 1
  97.  */
  98. _SPI_connected++;
  100. _SPI_current = &(_SPI_stack[_SPI_connected]);
  101. _SPI_current->qtlist = NULL;
  102. _SPI_current->processed = 0;
  103. _SPI_current->tuptable = NULL;
  105. /* Create Portal for this procedure ... */
  106. snprintf(pname, 64, "<SPI %d>", _SPI_connected);
  107. _SPI_current->portal = CreatePortal(pname);
  108. if (!PortalIsValid(_SPI_current->portal))
  109. elog(FATAL, "SPI_connect: initialization failed");
  111. /* ... and switch to Portal' Variable memory - procedure' context */
  112. pvmem = PortalGetVariableMemory(_SPI_current->portal);
  113. _SPI_current->savedcxt = MemoryContextSwitchTo((MemoryContext) pvmem);
  115. _SPI_current->savedId = GetScanCommandId();
  116. SetScanCommandId(GetCurrentCommandId());
  118. return SPI_OK_CONNECT;
  120. }
  122. int
  123. SPI_finish()
  124. {
  125. int res;
  127. res = _SPI_begin_call(false); /* live in procedure memory */
  128. if (res < 0)
  129. return res;
  131. /* Restore memory context as it was before procedure call */
  132. MemoryContextSwitchTo(_SPI_current->savedcxt);
  133. PortalDestroy(&(_SPI_current->portal));
  135. SetScanCommandId(_SPI_current->savedId);
  137. /*
  138.  * After _SPI_begin_call _SPI_connected == _SPI_curid. Now we are
  139.  * closing connection to SPI and returning to upper Executor and so
  140.  * _SPI_connected must be equal to _SPI_curid.
  141.  */
  142. _SPI_connected--;
  143. _SPI_curid--;
  144. if (_SPI_connected == -1)
  145. {
  146. free(_SPI_stack);
  147. _SPI_stack = NULL;
  148. }
  149. else
  150. {
  151. _SPI_stack = (_SPI_connection *) realloc(_SPI_stack,
  152.  (_SPI_connected + 1) * sizeof(_SPI_connection));
  153. _SPI_current = &(_SPI_stack[_SPI_connected]);
  154. }
  156. return SPI_OK_FINISH;
  158. }
  160. void
  161. SPI_push(void)
  162. {
  163. _SPI_curid++;
  164. }
  166. void
  167. SPI_pop(void)
  168. {
  169. _SPI_curid--;
  170. }
  172. int
  173. SPI_exec(char *src, int tcount)
  174. {
  175. int res;
  177. if (src == NULL || tcount < 0)
  178. return SPI_ERROR_ARGUMENT;
  180. res = _SPI_begin_call(true);
  181. if (res < 0)
  182. return res;
  184. res = _SPI_execute(src, tcount, NULL);
  186. _SPI_end_call(true);
  187. return res;
  188. }
  190. int
  191. SPI_execp(void *plan, Datum *Values, char *Nulls, int tcount)
  192. {
  193. int res;
  195. if (plan == NULL || tcount < 0)
  196. return SPI_ERROR_ARGUMENT;
  198. if (((_SPI_plan *) plan)->nargs > 0 && Values == NULL)
  199. return SPI_ERROR_PARAM;
  201. res = _SPI_begin_call(true);
  202. if (res < 0)
  203. return res;
  205. /* copy plan to current (executor) context */
  206. plan = (void *) _SPI_copy_plan(plan, _SPI_CPLAN_CURCXT);
  208. res = _SPI_execute_plan((_SPI_plan *) plan, Values, Nulls, tcount);
  210. _SPI_end_call(true);
  211. return res;
  212. }
  214. void *
  215. SPI_prepare(char *src, int nargs, Oid *argtypes)
  216. {
  217. _SPI_plan  *plan;
  219. if (src == NULL || nargs < 0 || (nargs > 0 && argtypes == NULL))
  220. {
  221. SPI_result = SPI_ERROR_ARGUMENT;
  222. return NULL;
  223. }
  225. SPI_result = _SPI_begin_call(true);
  226. if (SPI_result < 0)
  227. return NULL;
  229. plan = (_SPI_plan *) palloc(sizeof(_SPI_plan)); /* Executor context */
  230. plan->argtypes = argtypes;
  231. plan->nargs = nargs;
  233. SPI_result = _SPI_execute(src, 0, plan);
  235. if (SPI_result >= 0) /* copy plan to procedure context */
  236. plan = _SPI_copy_plan(plan, _SPI_CPLAN_PROCXT);
  237. else
  238. plan = NULL;
  240. _SPI_end_call(true);
  242. return (void *) plan;
  244. }
  246. void *
  247. SPI_saveplan(void *plan)
  248. {
  249. _SPI_plan  *newplan;
  251. if (plan == NULL)
  252. {
  253. SPI_result = SPI_ERROR_ARGUMENT;
  254. return NULL;
  255. }
  257. SPI_result = _SPI_begin_call(false); /* don't change context */
  258. if (SPI_result < 0)
  259. return NULL;
  261. newplan = _SPI_copy_plan((_SPI_plan *) plan, _SPI_CPLAN_TOPCXT);
  263. _SPI_curid--;
  264. SPI_result = 0;
  266. return (void *) newplan;
  268. }
  270. HeapTuple
  271. SPI_copytuple(HeapTuple tuple)
  272. {
  273. MemoryContext oldcxt = NULL;
  274. HeapTuple ctuple;
  276. if (tuple == NULL)
  277. {
  278. SPI_result = SPI_ERROR_ARGUMENT;
  279. return NULL;
  280. }
  282. if (_SPI_curid + 1 == _SPI_connected) /* connected */
  283. {
  284. if (_SPI_current != &(_SPI_stack[_SPI_curid + 1]))
  285. elog(FATAL, "SPI: stack corrupted");
  286. oldcxt = MemoryContextSwitchTo(_SPI_current->savedcxt);
  287. }
  289. ctuple = heap_copytuple(tuple);
  291. if (oldcxt)
  292. MemoryContextSwitchTo(oldcxt);
  294. return ctuple;
  295. }
  297. HeapTuple
  298. SPI_modifytuple(Relation rel, HeapTuple tuple, int natts, int *attnum,
  299. Datum *Values, char *Nulls)
  300. {
  301. MemoryContext oldcxt = NULL;
  302. HeapTuple mtuple;
  303. int numberOfAttributes;
  304. uint8 infomask;
  305. Datum    *v;
  306. char    *n;
  307. bool isnull;
  308. int i;
  310. if (rel == NULL || tuple == NULL || natts <= 0 || attnum == NULL || Values == NULL)
  311. {
  312. SPI_result = SPI_ERROR_ARGUMENT;
  313. return NULL;
  314. }
  316. if (_SPI_curid + 1 == _SPI_connected) /* connected */
  317. {
  318. if (_SPI_current != &(_SPI_stack[_SPI_curid + 1]))
  319. elog(FATAL, "SPI: stack corrupted");
  320. oldcxt = MemoryContextSwitchTo(_SPI_current->savedcxt);
  321. }
  322. SPI_result = 0;
  323. numberOfAttributes = rel->rd_att->natts;
  324. v = (Datum *) palloc(numberOfAttributes * sizeof(Datum));
  325. n = (char *) palloc(numberOfAttributes * sizeof(char));
  327. /* fetch old values and nulls */
  328. for (i = 0; i < numberOfAttributes; i++)
  329. {
  330. v[i] = heap_getattr(tuple, i + 1, rel->rd_att, &isnull);
  331. n[i] = (isnull) ? 'n' : ' ';
  332. }
  334. /* replace values and nulls */
  335. for (i = 0; i < natts; i++)
  336. {
  337. if (attnum[i] <= 0 || attnum[i] > numberOfAttributes)
  338. break;
  339. v[attnum[i] - 1] = Values[i];
  340. n[attnum[i] - 1] = (Nulls && Nulls[i] == 'n') ? 'n' : ' ';
  341. }
  343. if (i == natts) /* no errors in *attnum */
  344. {
  345. mtuple = heap_formtuple(rel->rd_att, v, n);
  346. infomask = mtuple->t_data->t_infomask;
  347. memmove(&(mtuple->t_data->t_oid), &(tuple->t_data->t_oid),
  348. ((char *) &(tuple->t_data->t_hoff) -
  349.  (char *) &(tuple->t_data->t_oid)));
  350. mtuple->t_data->t_infomask = infomask;
  351. mtuple->t_data->t_natts = numberOfAttributes;
  352. }
  353. else
  354. {
  355. mtuple = NULL;
  356. SPI_result = SPI_ERROR_NOATTRIBUTE;
  357. }
  359. pfree(v);
  360. pfree(n);
  362. if (oldcxt)
  363. MemoryContextSwitchTo(oldcxt);
  365. return mtuple;
  366. }
  368. int
  369. SPI_fnumber(TupleDesc tupdesc, char *fname)
  370. {
  371. int res;
  373. for (res = 0; res < tupdesc->natts; res++)
  374. {
  375. if (strcasecmp(tupdesc->attrs[res]->attname.data, fname) == 0)
  376. return res + 1;
  377. }
  379. return SPI_ERROR_NOATTRIBUTE;
  380. }
  382. char *
  383. SPI_fname(TupleDesc tupdesc, int fnumber)
  384. {
  386. SPI_result = 0;
  387. if (tupdesc->natts < fnumber || fnumber <= 0)
  388. {
  389. SPI_result = SPI_ERROR_NOATTRIBUTE;
  390. return NULL;
  391. }
  393. return nameout(&(tupdesc->attrs[fnumber - 1]->attname));
  394. }
  396. char *
  397. SPI_getvalue(HeapTuple tuple, TupleDesc tupdesc, int fnumber)
  398. {
  399. Datum val;
  400. bool isnull;
  401. Oid foutoid,
  402. typelem;
  404. SPI_result = 0;
  405. if (tuple->t_data->t_natts < fnumber || fnumber <= 0)
  406. {
  407. SPI_result = SPI_ERROR_NOATTRIBUTE;
  408. return NULL;
  409. }
  411. val = heap_getattr(tuple, fnumber, tupdesc, &isnull);
  412. if (isnull)
  413. return NULL;
  414. if (!getTypeOutAndElem((Oid) tupdesc->attrs[fnumber - 1]->atttypid,
  415.    &foutoid, &typelem))
  416. {
  417. SPI_result = SPI_ERROR_NOOUTFUNC;
  418. return NULL;
  419. }
  421. return (fmgr(foutoid, val, typelem,
  422.  tupdesc->attrs[fnumber - 1]->atttypmod));
  423. }
  425. Datum
  426. SPI_getbinval(HeapTuple tuple, TupleDesc tupdesc, int fnumber, bool *isnull)
  427. {
  428. Datum val;
  430. *isnull = true;
  431. SPI_result = 0;
  432. if (tuple->t_data->t_natts < fnumber || fnumber <= 0)
  433. {
  434. SPI_result = SPI_ERROR_NOATTRIBUTE;
  435. return (Datum) NULL;
  436. }
  438. val = heap_getattr(tuple, fnumber, tupdesc, isnull);
  440. return val;
  441. }
  443. char *
  444. SPI_gettype(TupleDesc tupdesc, int fnumber)
  445. {
  446. HeapTuple typeTuple;
  448. SPI_result = 0;
  449. if (tupdesc->natts < fnumber || fnumber <= 0)
  450. {
  451. SPI_result = SPI_ERROR_NOATTRIBUTE;
  452. return NULL;
  453. }
  455. typeTuple = SearchSysCacheTuple(TYPOID,
  456.  ObjectIdGetDatum(tupdesc->attrs[fnumber - 1]->atttypid),
  457. 0, 0, 0);
  459. if (!HeapTupleIsValid(typeTuple))
  460. {
  461. SPI_result = SPI_ERROR_TYPUNKNOWN;
  462. return NULL;
  463. }
  465. return pstrdup(((Form_pg_type) GETSTRUCT(typeTuple))->typname.data);
  466. }
  468. Oid
  469. SPI_gettypeid(TupleDesc tupdesc, int fnumber)
  470. {
  472. SPI_result = 0;
  473. if (tupdesc->natts < fnumber || fnumber <= 0)
  474. {
  475. SPI_result = SPI_ERROR_NOATTRIBUTE;
  476. return InvalidOid;
  477. }
  479. return tupdesc->attrs[fnumber - 1]->atttypid;
  480. }
  482. char *
  483. SPI_getrelname(Relation rel)
  484. {
  485. return pstrdup(rel->rd_rel->relname.data);
  486. }
  488. void *
  489. SPI_palloc(Size size)
  490. {
  491. MemoryContext oldcxt = NULL;
  492. void    *pointer;
  494. if (_SPI_curid + 1 == _SPI_connected) /* connected */
  495. {
  496. if (_SPI_current != &(_SPI_stack[_SPI_curid + 1]))
  497. elog(FATAL, "SPI: stack corrupted");
  498. oldcxt = MemoryContextSwitchTo(_SPI_current->savedcxt);
  499. }
  501. pointer = palloc(size);
  503. if (oldcxt)
  504. MemoryContextSwitchTo(oldcxt);
  506. return pointer;
  507. }
  509. void *
  510. SPI_repalloc(void *pointer, Size size)
  511. {
  512. MemoryContext oldcxt = NULL;
  514. if (_SPI_curid + 1 == _SPI_connected) /* connected */
  515. {
  516. if (_SPI_current != &(_SPI_stack[_SPI_curid + 1]))
  517. elog(FATAL, "SPI: stack corrupted");
  518. oldcxt = MemoryContextSwitchTo(_SPI_current->savedcxt);
  519. }
  521. pointer = repalloc(pointer, size);
  523. if (oldcxt)
  524. MemoryContextSwitchTo(oldcxt);
  526. return pointer;
  527. }
  529. void
  530. SPI_pfree(void *pointer)
  531. {
  532. MemoryContext oldcxt = NULL;
  534. if (_SPI_curid + 1 == _SPI_connected) /* connected */
  535. {
  536. if (_SPI_current != &(_SPI_stack[_SPI_curid + 1]))
  537. elog(FATAL, "SPI: stack corrupted");
  538. oldcxt = MemoryContextSwitchTo(_SPI_current->savedcxt);
  539. }
  541. pfree(pointer);
  543. if (oldcxt)
  544. MemoryContextSwitchTo(oldcxt);
  546. return;
  547. }
  549. /* =================== private functions =================== */
  551. /*
  552.  * spi_printtup
  553.  * store tuple retrieved by Executor into SPITupleTable
  554.  * of current SPI procedure
  555.  *
  556.  */
  557. void
  558. spi_printtup(HeapTuple tuple, TupleDesc tupdesc, DestReceiver *self)
  559. {
  560. SPITupleTable *tuptable;
  561. MemoryContext oldcxt;
  563. /*
  564.  * When called by Executor _SPI_curid expected to be equal to
  565.  * _SPI_connected
  566.  */
  567. if (_SPI_curid != _SPI_connected || _SPI_connected < 0)
  568. elog(FATAL, "SPI: improper call to spi_printtup");
  569. if (_SPI_current != &(_SPI_stack[_SPI_curid]))
  570. elog(FATAL, "SPI: stack corrupted in spi_printtup");
  572. oldcxt = _SPI_procmem(); /* switch to procedure memory context */
  574. tuptable = _SPI_current->tuptable;
  575. if (tuptable == NULL)
  576. {
  577. _SPI_current->tuptable = tuptable = (SPITupleTable *)
  578. palloc(sizeof(SPITupleTable));
  579. tuptable->alloced = tuptable->free = 128;
  580. tuptable->vals = (HeapTuple *) palloc(tuptable->alloced * sizeof(HeapTuple));
  581. tuptable->tupdesc = CreateTupleDescCopy(tupdesc);
  582. }
  583. else if (tuptable->free == 0)
  584. {
  585. tuptable->free = 256;
  586. tuptable->alloced += tuptable->free;
  587. tuptable->vals = (HeapTuple *) repalloc(tuptable->vals,
  588.   tuptable->alloced * sizeof(HeapTuple));
  589. }
  591. tuptable->vals[tuptable->alloced - tuptable->free] = heap_copytuple(tuple);
  592. (tuptable->free)--;
  594. MemoryContextSwitchTo(oldcxt);
  595. return;
  596. }
  598. /*
  599.  * Static functions
  600.  */
  602. static int
  603. _SPI_execute(char *src, int tcount, _SPI_plan *plan)
  604. {
  605. List    *queryTree_list;
  606. List    *planTree_list;
  607. List    *queryTree_list_item;
  608. List    *ptlist;
  609. QueryDesc  *qdesc;
  610. Query    *queryTree;
  611. Plan    *planTree;
  612. EState    *state;
  613. int nargs = 0;
  614. Oid    *argtypes = NULL;
  615. int res = 0;
  616. bool islastquery;
  618. /* Increment CommandCounter to see changes made by now */
  619. CommandCounterIncrement();
  621. SPI_processed = 0;
  622. SPI_tuptable = NULL;
  623. _SPI_current->tuptable = NULL;
  624. _SPI_current->qtlist = NULL;
  626. if (plan)
  627. {
  628. nargs = plan->nargs;
  629. argtypes = plan->argtypes;
  630. }
  631. ptlist = planTree_list =
  632. pg_parse_and_plan(src, argtypes, nargs, &queryTree_list, None, FALSE);
  634. _SPI_current->qtlist = queryTree_list;
  636. foreach(queryTree_list_item, queryTree_list)
  637. {
  638. queryTree = (Query *) lfirst(queryTree_list_item);
  639. planTree = lfirst(planTree_list);
  640. planTree_list = lnext(planTree_list);
  641. islastquery = (planTree_list == NIL); /* assume lists are same
  642.  * len */
  644. if (queryTree->commandType == CMD_UTILITY)
  645. {
  646. if (nodeTag(queryTree->utilityStmt) == T_CopyStmt)
  647. {
  648. CopyStmt   *stmt = (CopyStmt *) (queryTree->utilityStmt);
  650. if (stmt->filename == NULL)
  651. return SPI_ERROR_COPY;
  652. }
  653. else if (nodeTag(queryTree->utilityStmt) == T_ClosePortalStmt ||
  654.  nodeTag(queryTree->utilityStmt) == T_FetchStmt)
  655. return SPI_ERROR_CURSOR;
  656. else if (nodeTag(queryTree->utilityStmt) == T_TransactionStmt)
  657. return SPI_ERROR_TRANSACTION;
  658. res = SPI_OK_UTILITY;
  659. if (plan == NULL)
  660. {
  661. ProcessUtility(queryTree->utilityStmt, None);
  662. if (!islastquery)
  663. CommandCounterIncrement();
  664. else
  665. return res;
  666. }
  667. else if (islastquery)
  668. break;
  669. }
  670. else if (plan == NULL)
  671. {
  672. qdesc = CreateQueryDesc(queryTree, planTree,
  673. islastquery ? SPI : None);
  674. state = CreateExecutorState();
  675. res = _SPI_pquery(qdesc, state, islastquery ? tcount : 0);
  676. if (res < 0 || islastquery)
  677. return res;
  678. CommandCounterIncrement();
  679. }
  680. else
  681. {
  682. qdesc = CreateQueryDesc(queryTree, planTree,
  683. islastquery ? SPI : None);
  684. res = _SPI_pquery(qdesc, NULL, islastquery ? tcount : 0);
  685. if (res < 0)
  686. return res;
  687. if (islastquery)
  688. break;
  689. }
  690. }
  692. plan->qtlist = queryTree_list;
  693. plan->ptlist = ptlist;
  695. return res;
  696. }
  698. static int
  699. _SPI_execute_plan(_SPI_plan *plan, Datum *Values, char *Nulls, int tcount)
  700. {
  701. List    *queryTree_list = plan->qtlist;
  702. List    *planTree_list = plan->ptlist;
  703. List    *queryTree_list_item;
  704. QueryDesc  *qdesc;
  705. Query    *queryTree;
  706. Plan    *planTree;
  707. EState    *state;
  708. int nargs = plan->nargs;
  709. int res = 0;
  710. bool islastquery;
  711. int k;
  713. /* Increment CommandCounter to see changes made by now */
  714. CommandCounterIncrement();
  716. SPI_processed = 0;
  717. SPI_tuptable = NULL;
  718. _SPI_current->tuptable = NULL;
  719. _SPI_current->qtlist = NULL;
  721. foreach(queryTree_list_item, queryTree_list)
  722. {
  723. queryTree = (Query *) lfirst(queryTree_list_item);
  724. planTree = lfirst(planTree_list);
  725. planTree_list = lnext(planTree_list);
  726. islastquery = (planTree_list == NIL); /* assume lists are same
  727.  * len */
  729. if (queryTree->commandType == CMD_UTILITY)
  730. {
  731. ProcessUtility(queryTree->utilityStmt, None);
  732. if (!islastquery)
  733. CommandCounterIncrement();
  734. else
  735. return SPI_OK_UTILITY;
  736. }
  737. else
  738. {
  739. qdesc = CreateQueryDesc(queryTree, planTree,
  740. islastquery ? SPI : None);
  741. state = CreateExecutorState();
  742. if (nargs > 0)
  743. {
  744. ParamListInfo paramLI = (ParamListInfo) palloc((nargs + 1) *
  745.   sizeof(ParamListInfoData));
  747. state->es_param_list_info = paramLI;
  748. for (k = 0; k < plan->nargs; paramLI++, k++)
  749. {
  750. paramLI->kind = PARAM_NUM;
  751. paramLI->id = k + 1;
  752. paramLI->isnull = (Nulls && Nulls[k] == 'n');
  753. paramLI->value = Values[k];
  754. }
  755. paramLI->kind = PARAM_INVALID;
  756. }
  757. else
  758. state->es_param_list_info = NULL;
  759. res = _SPI_pquery(qdesc, state, islastquery ? tcount : 0);
  760. if (res < 0 || islastquery)
  761. return res;
  762. CommandCounterIncrement();
  763. }
  764. }
  766. return res;
  767. }
  769. static int
  770. _SPI_pquery(QueryDesc *queryDesc, EState *state, int tcount)
  771. {
  772. Query    *parseTree = queryDesc->parsetree;
  773. Plan    *plan = queryDesc->plantree;
  774. int operation = queryDesc->operation;
  775. CommandDest dest = queryDesc->dest;
  776. TupleDesc tupdesc;
  777. bool isRetrieveIntoPortal = false;
  778. bool isRetrieveIntoRelation = false;
  779. char    *intoName = NULL;
  780. int res;
  781. Const tcount_const;
  782. Node    *count = NULL;
  784. switch (operation)
  785. {
  786. case CMD_SELECT:
  787. res = SPI_OK_SELECT;
  788. if (parseTree->isPortal)
  789. {
  790. isRetrieveIntoPortal = true;
  791. intoName = parseTree->into;
  792. parseTree->isBinary = false; /* */
  794. return SPI_ERROR_CURSOR;
  796. }
  797. else if (parseTree->into != NULL) /* select into table */
  798. {
  799. res = SPI_OK_SELINTO;
  800. isRetrieveIntoRelation = true;
  801. queryDesc->dest = None; /* */
  802. }
  803. break;
  804. case CMD_INSERT:
  805. res = SPI_OK_INSERT;
  806. break;
  807. case CMD_DELETE:
  808. res = SPI_OK_DELETE;
  809. break;
  810. case CMD_UPDATE:
  811. res = SPI_OK_UPDATE;
  812. break;
  813. default:
  814. return SPI_ERROR_OPUNKNOWN;
  815. }
  817. /* ----------------
  818.  * Get the query LIMIT tuple count
  819.  * ----------------
  820.  */
  821. if (parseTree->limitCount != NULL)
  822. {
  823. /* ----------------
  824.  * A limit clause in the parsetree overrides the
  825.  * tcount parameter
  826.  * ----------------
  827.  */
  828. count = parseTree->limitCount;
  829. }
  830. else
  831. {
  832. /* ----------------
  833.  * No LIMIT clause in parsetree. Use a local Const node
  834.  * to put tcount into it
  835.  * ----------------
  836.  */
  837. memset(&tcount_const, 0, sizeof(tcount_const));
  838. tcount_const.type = T_Const;
  839. tcount_const.consttype = INT4OID;
  840. tcount_const.constlen = sizeof(int4);
  841. tcount_const.constvalue = (Datum) tcount;
  842. tcount_const.constisnull = FALSE;
  843. tcount_const.constbyval = TRUE;
  844. tcount_const.constisset = FALSE;
  845. tcount_const.constiscast = FALSE;
  847. count = (Node *) &tcount_const;
  848. }
  850. if (state == NULL) /* plan preparation */
  851. return res;
  852. #ifdef SPI_EXECUTOR_STATS
  853. if (ShowExecutorStats)
  854. ResetUsage();
  855. #endif
  856. tupdesc = ExecutorStart(queryDesc, state);
  858. /* Don't work currently */
  859. if (isRetrieveIntoPortal)
  860. {
  861. ProcessPortal(intoName,
  862.   parseTree,
  863.   plan,
  864.   state,
  865.   tupdesc,
  866.   None);
  867. return SPI_OK_CURSOR;
  868. }
  870. ExecutorRun(queryDesc, state, EXEC_FOR, parseTree->limitOffset, count);
  872. _SPI_current->processed = state->es_processed;
  873. if (operation == CMD_SELECT && queryDesc->dest == SPI)
  874. {
  875. if (_SPI_checktuples())
  876. elog(FATAL, "SPI_select: # of processed tuples check failed");
  877. }
  879. ExecutorEnd(queryDesc, state);
  881. #ifdef SPI_EXECUTOR_STATS
  882. if (ShowExecutorStats)
  883. {
  884. fprintf(stderr, "! Executor Stats:n");
  885. ShowUsage();
  886. }
  887. #endif
  889. if (dest == SPI)
  890. {
  891. SPI_processed = _SPI_current->processed;
  892. SPI_tuptable = _SPI_current->tuptable;
  893. }
  894. queryDesc->dest = dest;
  896. return res;
  898. }
  900. static MemoryContext
  901. _SPI_execmem()
  902. {
  903. MemoryContext oldcxt;
  904. PortalHeapMemory phmem;
  906. phmem = PortalGetHeapMemory(_SPI_current->portal);
  907. oldcxt = MemoryContextSwitchTo((MemoryContext) phmem);
  909. return oldcxt;
  911. }
  913. static MemoryContext
  914. _SPI_procmem()
  915. {
  916. MemoryContext oldcxt;
  917. PortalVariableMemory pvmem;
  919. pvmem = PortalGetVariableMemory(_SPI_current->portal);
  920. oldcxt = MemoryContextSwitchTo((MemoryContext) pvmem);
  922. return oldcxt;
  924. }
  926. /*
  927.  * _SPI_begin_call
  928.  *
  929.  */
  930. static int
  931. _SPI_begin_call(bool execmem)
  932. {
  933. if (_SPI_curid + 1 != _SPI_connected)
  934. return SPI_ERROR_UNCONNECTED;
  935. _SPI_curid++;
  936. if (_SPI_current != &(_SPI_stack[_SPI_curid]))
  937. elog(FATAL, "SPI: stack corrupted");
  939. if (execmem) /* switch to the Executor memory context */
  940. {
  941. _SPI_execmem();
  942. StartPortalAllocMode(DefaultAllocMode, 0);
  943. }
  945. return 0;
  946. }
  948. static int
  949. _SPI_end_call(bool procmem)
  950. {
  952. /*
  953.  * We' returning to procedure where _SPI_curid == _SPI_connected - 1
  954.  */
  955. _SPI_curid--;
  957. _SPI_current->qtlist = NULL;
  959. if (procmem) /* switch to the procedure memory context */
  960. { /* but free Executor memory before */
  961. EndPortalAllocMode();
  962. _SPI_procmem();
  963. }
  965. return 0;
  966. }
  968. static bool
  969. _SPI_checktuples()
  970. {
  971. uint32 processed = _SPI_current->processed;
  972. SPITupleTable *tuptable = _SPI_current->tuptable;
  973. bool failed = false;
  975. if (processed == 0)
  976. {
  977. if (tuptable != NULL)
  978. failed = true;
  979. }
  980. else
  981. /* some tuples were processed */
  982. {
  983. if (tuptable == NULL) /* spi_printtup was not called */
  984. failed = true;
  985. else if (processed != (tuptable->alloced - tuptable->free))
  986. failed = true;
  987. }
  989. return failed;
  990. }
  992. static _SPI_plan *
  993. _SPI_copy_plan(_SPI_plan *plan, int location)
  994. {
  995. _SPI_plan  *newplan;
  996. MemoryContext oldcxt = NULL;
  998. if (location == _SPI_CPLAN_PROCXT)
  999. oldcxt = MemoryContextSwitchTo((MemoryContext)
  1000.   PortalGetVariableMemory(_SPI_current->portal));
  1001. else if (location == _SPI_CPLAN_TOPCXT)
  1002. oldcxt = MemoryContextSwitchTo(TopMemoryContext);
  1004. newplan = (_SPI_plan *) palloc(sizeof(_SPI_plan));
  1005. newplan->qtlist = (List *) copyObject(plan->qtlist);
  1006. newplan->ptlist = (List *) copyObject(plan->ptlist);
  1007. newplan->nargs = plan->nargs;
  1008. if (plan->nargs > 0)
  1009. {
  1010. newplan->argtypes = (Oid *) palloc(plan->nargs * sizeof(Oid));
  1011. memcpy(newplan->argtypes, plan->argtypes, plan->nargs * sizeof(Oid));
  1012. }
  1013. else
  1014. newplan->argtypes = NULL;
  1016. if (location != _SPI_CPLAN_CURCXT)
  1017. MemoryContextSwitchTo(oldcxt);
  1019. return newplan;
  1020. }