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

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

数据库系统

开发平台：

Unix_Linux

pl_exec.c：源码内容
  1. /**********************************************************************
  2.  * pl_exec.c - Executor for the PL/pgSQL
  3.  *   procedural language
  4.  *
  5.  * IDENTIFICATION
  6.  *   $Header: /usr/local/cvsroot/pgsql/src/pl/plpgsql/src/pl_exec.c,v 1.12 1999/07/04 01:03:01 tgl Exp $
  7.  *
  8.  *   This software is copyrighted by Jan Wieck - Hamburg.
  9.  *
  10.  *   The author hereby grants permission  to  use,  copy, modify,
  11.  *   distribute,  and license this software and its documentation
  12.  *   for any purpose, provided that existing copyright notices are
  13.  *   retained in all  copies  and  that this notice is included
  14.  *   verbatim in any distributions. No written agreement, license,
  15.  *   or  royalty  fee is required for any of the authorized uses.
  16.  *   Modifications to this software may be  copyrighted  by  their
  17.  *   author  and  need  not  follow  the licensing terms described
  18.  *   here, provided that the new terms are  clearly  indicated  on
  19.  *   the first page of each file where they apply.
  20.  *
  21.  *   IN NO EVENT SHALL THE AUTHOR OR DISTRIBUTORS BE LIABLE TO ANY
  22.  *   PARTY  FOR  DIRECT, INDIRECT, SPECIAL,   INCIDENTAL,  OR
  23.  *   CONSEQUENTIAL   DAMAGES  ARISING OUT  OF  THE  USE  OF  THIS
  24.  *   SOFTWARE, ITS DOCUMENTATION, OR ANY DERIVATIVES THEREOF, EVEN
  25.  *   IF  THE  AUTHOR  HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
  26.  *   DAMAGE.
  27.  *
  28.  *   THE  AUTHOR  AND DISTRIBUTORS  SPECIFICALLY  DISCLAIM ANY
  29.  *   WARRANTIES,  INCLUDING,  BUT NOT  LIMITED  TO,  THE IMPLIED
  30.  *   WARRANTIES  OF  MERCHANTABILITY, FITNESS  FOR  A  PARTICULAR
  31.  *   PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE IS PROVIDED ON
  32.  *   AN "AS IS" BASIS, AND THE AUTHOR AND  DISTRIBUTORS  HAVE  NO
  33.  *   OBLIGATION   TO PROVIDE   MAINTENANCE,  SUPPORT,  UPDATES,
  34.  *   ENHANCEMENTS, OR MODIFICATIONS.
  35.  *
  36.  **********************************************************************/
  38. #include <stdio.h>
  39. #include <stdlib.h>
  40. #include <stdarg.h>
  41. #include <unistd.h>
  42. #include <fcntl.h>
  43. #include <string.h>
  44. #include <ctype.h>
  45. #include <setjmp.h>
  47. #include "plpgsql.h"
  48. #include "pl.tab.h"
  50. #include "executor/spi.h"
  51. #include "executor/spi_priv.h"
  52. #include "commands/trigger.h"
  53. #include "utils/elog.h"
  54. #include "utils/builtins.h"
  55. #include "fmgr.h"
  56. #include "access/heapam.h"
  58. #include "tcop/tcopprot.h"
  59. #include "utils/syscache.h"
  60. #include "catalog/pg_proc.h"
  61. #include "catalog/pg_type.h"
  64. static PLpgSQL_function *error_info_func = NULL;
  65. static PLpgSQL_stmt *error_info_stmt = NULL;
  66. static char *error_info_text = NULL;
  69. /************************************************************
  70.  * Local function forward declarations
  71.  ************************************************************/
  72. static PLpgSQL_var *copy_var(PLpgSQL_var * var);
  73. static PLpgSQL_rec *copy_rec(PLpgSQL_rec * rec);
  75. static int exec_stmt_block(PLpgSQL_execstate * estate,
  76. PLpgSQL_stmt_block * block);
  77. static int exec_stmts(PLpgSQL_execstate * estate,
  78.    PLpgSQL_stmts * stmts);
  79. static int exec_stmt(PLpgSQL_execstate * estate,
  80.   PLpgSQL_stmt * stmt);
  81. static int exec_stmt_assign(PLpgSQL_execstate * estate,
  82.  PLpgSQL_stmt_assign * stmt);
  83. static int exec_stmt_if(PLpgSQL_execstate * estate,
  84.  PLpgSQL_stmt_if * stmt);
  85. static int exec_stmt_loop(PLpgSQL_execstate * estate,
  86.    PLpgSQL_stmt_loop * stmt);
  87. static int exec_stmt_while(PLpgSQL_execstate * estate,
  88. PLpgSQL_stmt_while * stmt);
  89. static int exec_stmt_fori(PLpgSQL_execstate * estate,
  90.    PLpgSQL_stmt_fori * stmt);
  91. static int exec_stmt_fors(PLpgSQL_execstate * estate,
  92.    PLpgSQL_stmt_fors * stmt);
  93. static int exec_stmt_select(PLpgSQL_execstate * estate,
  94.  PLpgSQL_stmt_select * stmt);
  95. static int exec_stmt_exit(PLpgSQL_execstate * estate,
  96.    PLpgSQL_stmt_exit * stmt);
  97. static int exec_stmt_return(PLpgSQL_execstate * estate,
  98.  PLpgSQL_stmt_return * stmt);
  99. static int exec_stmt_raise(PLpgSQL_execstate * estate,
  100. PLpgSQL_stmt_raise * stmt);
  101. static int exec_stmt_execsql(PLpgSQL_execstate * estate,
  102.   PLpgSQL_stmt_execsql * stmt);
  104. static void exec_prepare_plan(PLpgSQL_execstate * estate,
  105.   PLpgSQL_expr * expr);
  106. static bool exec_simple_check_node(Node *node);
  107. static void exec_simple_check_plan(PLpgSQL_expr * expr);
  108. static void exec_eval_clear_fcache(Node *node);
  109. static Datum exec_eval_simple_expr(PLpgSQL_execstate * estate,
  110.   PLpgSQL_expr * expr,
  111.   bool *isNull,
  112.   Oid *rettype);
  114. static void exec_assign_expr(PLpgSQL_execstate * estate,
  115.  PLpgSQL_datum * target,
  116.  PLpgSQL_expr * expr);
  117. static void exec_assign_value(PLpgSQL_execstate * estate,
  118.   PLpgSQL_datum * target,
  119.   Datum value, Oid valtype, bool *isNull);
  120. static Datum exec_eval_expr(PLpgSQL_execstate * estate,
  121.    PLpgSQL_expr * expr,
  122.    bool *isNull,
  123.    Oid *rettype);
  124. static int exec_run_select(PLpgSQL_execstate * estate,
  125. PLpgSQL_expr * expr, int maxtuples);
  126. static void exec_move_row(PLpgSQL_execstate * estate,
  127.   PLpgSQL_rec * rec,
  128.   PLpgSQL_row * row,
  129.   HeapTuple tup, TupleDesc tupdesc);
  130. static Datum exec_cast_value(Datum value, Oid valtype,
  131. Oid reqtype,
  132. FmgrInfo *reqinput,
  133. int16 reqtypmod,
  134. bool *isnull);
  135. static void exec_set_found(PLpgSQL_execstate * estate, bool state);
  138. /* ----------
  139.  * plpgsql_exec_function Called by the call handler for
  140.  * function execution.
  141.  * ----------
  142.  */
  143. Datum
  144. plpgsql_exec_function(PLpgSQL_function * func,
  145.   FmgrValues *args, bool *isNull)
  146. {
  147. PLpgSQL_execstate estate;
  148. int i;
  149. sigjmp_buf save_restart;
  150. PLpgSQL_function *save_efunc;
  151. PLpgSQL_stmt *save_estmt;
  152. char    *save_etext;
  154. /* ----------
  155.  * Setup debug error info and catch elog()
  156.  * ----------
  157.  */
  158. save_efunc = error_info_func;
  159. save_estmt = error_info_stmt;
  160. save_etext = error_info_text;
  162. error_info_func = func;
  163. error_info_stmt = NULL;
  164. error_info_text = "while initialization of execution state";
  166. memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
  167. if (sigsetjmp(Warn_restart, 1) != 0)
  168. {
  169. memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
  171. /* ----------
  172.  * If we are the first of cascaded error catchings,
  173.  * print where this happened
  174.  * ----------
  175.  */
  176. if (error_info_func != NULL)
  177. {
  178. elog(DEBUG, "Last error occured while executing PL/pgSQL function %s",
  179.  error_info_func->fn_name);
  180. if (error_info_stmt != NULL)
  181. {
  182. char    *stmttype;
  184. switch (error_info_stmt->cmd_type)
  185. {
  186. case PLPGSQL_STMT_BLOCK:
  187. stmttype = "blocks variable initialization";
  188. break;
  189. case PLPGSQL_STMT_ASSIGN:
  190. stmttype = "assignment";
  191. break;
  192. case PLPGSQL_STMT_IF:
  193. stmttype = "if";
  194. break;
  195. case PLPGSQL_STMT_LOOP:
  196. stmttype = "loop";
  197. break;
  198. case PLPGSQL_STMT_WHILE:
  199. stmttype = "while";
  200. break;
  201. case PLPGSQL_STMT_FORI:
  202. stmttype = "for with integer loopvar";
  203. break;
  204. case PLPGSQL_STMT_FORS:
  205. stmttype = "for over select rows";
  206. break;
  207. case PLPGSQL_STMT_SELECT:
  208. stmttype = "select into variables";
  209. break;
  210. case PLPGSQL_STMT_EXIT:
  211. stmttype = "exit";
  212. break;
  213. case PLPGSQL_STMT_RETURN:
  214. stmttype = "return";
  215. break;
  216. case PLPGSQL_STMT_RAISE:
  217. stmttype = "raise";
  218. break;
  219. case PLPGSQL_STMT_EXECSQL:
  220. stmttype = "SQL statement";
  221. break;
  222. default:
  223. stmttype = "unknown";
  224. break;
  225. }
  226. elog(DEBUG, "line %d at %s", error_info_stmt->lineno,
  227.  stmttype);
  228. }
  229. else
  230. {
  231. if (error_info_text != NULL)
  232. elog(DEBUG, "%s", error_info_text);
  233. else
  234. elog(DEBUG, "no more error information available");
  235. }
  237. error_info_func = NULL;
  238. error_info_stmt = NULL;
  239. error_info_text = NULL;
  240. }
  242. siglongjmp(Warn_restart, 1);
  243. }
  246. /* ----------
  247.  * Setup the execution state
  248.  * ----------
  249.  */
  250. estate.retval = 0;
  251. estate.retisnull = false;
  252. estate.rettype = InvalidOid;
  253. estate.retistuple = func->fn_retistuple;
  254. estate.retisset = func->fn_retset;
  255. estate.exitlabel = NULL;
  257. estate.found_varno = func->found_varno;
  258. estate.ndatums = func->ndatums;
  259. estate.datums = palloc(sizeof(PLpgSQL_datum *) * estate.ndatums);
  261. /* ----------
  262.  * Make local execution copies of all the datums
  263.  * ----------
  264.  */
  265. for (i = 0; i < func->ndatums; i++)
  266. {
  267. switch (func->datums[i]->dtype)
  268. {
  269. case PLPGSQL_DTYPE_VAR:
  270. estate.datums[i] = (PLpgSQL_datum *)
  271. copy_var((PLpgSQL_var *) (func->datums[i]));
  272. break;
  274. case PLPGSQL_DTYPE_REC:
  275. estate.datums[i] = (PLpgSQL_datum *)
  276. copy_rec((PLpgSQL_rec *) (func->datums[i]));
  277. break;
  279. case PLPGSQL_DTYPE_ROW:
  280. case PLPGSQL_DTYPE_RECFIELD:
  281. estate.datums[i] = func->datums[i];
  282. break;
  284. default:
  285. elog(ERROR, "unknown dtype %d in plpgsql_exec_function()",
  286.  func->datums[i]->dtype);
  287. }
  288. }
  290. /* ----------
  291.  * Put the actual call argument values into the variables
  292.  * ----------
  293.  */
  294. error_info_text = "while putting call arguments to local variables";
  295. for (i = 0; i < func->fn_nargs; i++)
  296. {
  297. int n = func->fn_argvarnos[i];
  299. switch (estate.datums[n]->dtype)
  300. {
  301. case PLPGSQL_DTYPE_VAR:
  302. {
  303. PLpgSQL_var *var = (PLpgSQL_var *) estate.datums[n];
  305. var->value = (Datum) (args->data[i]);
  306. var->isnull = *isNull;
  307. var->shouldfree = false;
  308. }
  309. break;
  311. case PLPGSQL_DTYPE_ROW:
  312. {
  313. HeapTuple tup;
  314. TupleDesc tupdesc;
  315. PLpgSQL_row *row = (PLpgSQL_row *) estate.datums[n];
  317. tup = ((TupleTableSlot *) (args->data[i]))->val;
  318. tupdesc = ((TupleTableSlot *) (args->data[i]))->ttc_tupleDescriptor;
  320. exec_move_row(&estate, NULL, row, tup, tupdesc);
  321. }
  322. break;
  324. default:
  325. elog(ERROR, "unknown dtype %d in plpgsql_exec_function()",
  326.  func->datums[i]->dtype);
  327. }
  328. }
  330. /* ----------
  331.  * Initialize the other variables to NULL values for now.
  332.  * The default values are set when the blocks are entered.
  333.  * ----------
  334.  */
  335. error_info_text = "while initializing local variables to NULL";
  336. for (i = estate.found_varno; i < estate.ndatums; i++)
  337. {
  338. switch (estate.datums[i]->dtype)
  339. {
  340. case PLPGSQL_DTYPE_VAR:
  341. {
  342. PLpgSQL_var *var = (PLpgSQL_var *) estate.datums[i];
  344. var->value = 0;
  345. var->isnull = true;
  346. var->shouldfree = false;
  347. }
  348. break;
  350. case PLPGSQL_DTYPE_ROW:
  351. case PLPGSQL_DTYPE_REC:
  352. case PLPGSQL_DTYPE_RECFIELD:
  353. break;
  355. default:
  356. elog(ERROR, "unknown dtype %d in plpgsql_exec_function()",
  357.  func->datums[i]->dtype);
  358. }
  359. }
  361. /* ----------
  362.  * Set the magic variable FOUND to false
  363.  * ----------
  364.  */
  365. exec_set_found(&estate, false);
  367. /* ----------
  368.  * Now call the toplevel block of statements
  369.  * ----------
  370.  */
  371. error_info_text = NULL;
  372. error_info_stmt = (PLpgSQL_stmt *) (func->action);
  373. if (exec_stmt_block(&estate, func->action) != PLPGSQL_RC_RETURN)
  374. {
  375. error_info_stmt = NULL;
  376. error_info_text = "at END of toplevel PL block";
  377. elog(ERROR, "control reaches end of function without RETURN");
  378. }
  380. /* ----------
  381.  * We got a return value - process it
  382.  * ----------
  383.  */
  384. error_info_stmt = NULL;
  385. error_info_text = "while casting return value to functions return type";
  387. *isNull = estate.retisnull;
  389. if (!estate.retistuple)
  390. {
  391. estate.retval = exec_cast_value(estate.retval, estate.rettype,
  392.   func->fn_rettype, &(func->fn_retinput), -1,
  393. isNull);
  395. /* ----------
  396.  * If the functions return type isn't by value,
  397.  * copy the value into upper executor memory context.
  398.  * ----------
  399.  */
  400. if (!*isNull && !func->fn_retbyval)
  401. {
  402. int len;
  403. Datum tmp;
  405. if (func->fn_rettyplen < 0)
  406. len = VARSIZE(estate.retval);
  407. else
  408. len = func->fn_rettyplen;
  410. tmp = (Datum) SPI_palloc(len);
  411. memcpy((void *) tmp, (void *) estate.retval, len);
  412. estate.retval = tmp;
  413. }
  414. }
  416. /* ----------
  417.  * Restore the previous error info and elog() jump target
  418.  * ----------
  419.  */
  420. error_info_func = save_efunc;
  421. error_info_stmt = save_estmt;
  422. error_info_text = save_etext;
  423. memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
  425. /* ----------
  426.  * Return the functions result
  427.  * ----------
  428.  */
  429. return estate.retval;
  430. }
  433. /* ----------
  434.  * plpgsql_exec_trigger Called by the call handler for
  435.  * trigger execution.
  436.  * ----------
  437.  */
  438. HeapTuple
  439. plpgsql_exec_trigger(PLpgSQL_function * func,
  440.  TriggerData *trigdata)
  441. {
  442. PLpgSQL_execstate estate;
  443. int i;
  444. sigjmp_buf save_restart;
  445. PLpgSQL_function *save_efunc;
  446. PLpgSQL_stmt *save_estmt;
  447. char    *save_etext;
  448. PLpgSQL_rec *rec_new;
  449. PLpgSQL_rec *rec_old;
  450. PLpgSQL_var *var;
  451. HeapTuple rettup;
  453. /* ----------
  454.  * Setup debug error info and catch elog()
  455.  * ----------
  456.  */
  457. save_efunc = error_info_func;
  458. save_estmt = error_info_stmt;
  459. save_etext = error_info_text;
  461. error_info_func = func;
  462. error_info_stmt = NULL;
  463. error_info_text = "while initialization of execution state";
  465. memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
  466. if (sigsetjmp(Warn_restart, 1) != 0)
  467. {
  468. memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
  470. /* ----------
  471.  * If we are the first of cascaded error catchings,
  472.  * print where this happened
  473.  * ----------
  474.  */
  475. if (error_info_func != NULL)
  476. {
  477. elog(DEBUG, "Last error occured while executing PL/pgSQL function %s",
  478.  error_info_func->fn_name);
  479. if (error_info_stmt != NULL)
  480. {
  481. char    *stmttype;
  483. switch (error_info_stmt->cmd_type)
  484. {
  485. case PLPGSQL_STMT_BLOCK:
  486. stmttype = "blocks variable initialization";
  487. break;
  488. case PLPGSQL_STMT_ASSIGN:
  489. stmttype = "assignment";
  490. break;
  491. case PLPGSQL_STMT_IF:
  492. stmttype = "if";
  493. break;
  494. case PLPGSQL_STMT_LOOP:
  495. stmttype = "loop";
  496. break;
  497. case PLPGSQL_STMT_WHILE:
  498. stmttype = "while";
  499. break;
  500. case PLPGSQL_STMT_FORI:
  501. stmttype = "for with integer loopvar";
  502. break;
  503. case PLPGSQL_STMT_FORS:
  504. stmttype = "for over select rows";
  505. break;
  506. case PLPGSQL_STMT_SELECT:
  507. stmttype = "select into variables";
  508. break;
  509. case PLPGSQL_STMT_EXIT:
  510. stmttype = "exit";
  511. break;
  512. case PLPGSQL_STMT_RETURN:
  513. stmttype = "return";
  514. break;
  515. case PLPGSQL_STMT_RAISE:
  516. stmttype = "raise";
  517. break;
  518. case PLPGSQL_STMT_EXECSQL:
  519. stmttype = "SQL statement";
  520. break;
  521. default:
  522. stmttype = "unknown";
  523. break;
  524. }
  525. elog(DEBUG, "line %d at %s", error_info_stmt->lineno,
  526.  stmttype);
  527. }
  528. else
  529. {
  530. if (error_info_text != NULL)
  531. elog(DEBUG, "%s", error_info_text);
  532. else
  533. elog(DEBUG, "no more error information available");
  534. }
  536. error_info_func = NULL;
  537. error_info_stmt = NULL;
  538. error_info_text = NULL;
  539. }
  541. siglongjmp(Warn_restart, 1);
  542. }
  545. /* ----------
  546.  * Setup the execution state
  547.  * ----------
  548.  */
  549. estate.retval = 0;
  550. estate.retisnull = false;
  551. estate.rettype = InvalidOid;
  552. estate.retistuple = func->fn_retistuple;
  553. estate.retisset = func->fn_retset;
  554. estate.exitlabel = NULL;
  556. estate.found_varno = func->found_varno;
  557. estate.ndatums = func->ndatums;
  558. estate.datums = palloc(sizeof(PLpgSQL_datum *) * estate.ndatums);
  560. /* ----------
  561.  * Make local execution copies of all the datums
  562.  * ----------
  563.  */
  564. for (i = 0; i < func->ndatums; i++)
  565. {
  566. switch (func->datums[i]->dtype)
  567. {
  568. case PLPGSQL_DTYPE_VAR:
  569. estate.datums[i] = (PLpgSQL_datum *)
  570. copy_var((PLpgSQL_var *) (func->datums[i]));
  571. break;
  573. case PLPGSQL_DTYPE_REC:
  574. estate.datums[i] = (PLpgSQL_datum *)
  575. copy_rec((PLpgSQL_rec *) (func->datums[i]));
  576. break;
  578. case PLPGSQL_DTYPE_ROW:
  579. case PLPGSQL_DTYPE_RECFIELD:
  580. case PLPGSQL_DTYPE_TRIGARG:
  581. estate.datums[i] = func->datums[i];
  582. break;
  584. default:
  585. elog(ERROR, "unknown dtype %d in plpgsql_exec_function()",
  586.  func->datums[i]->dtype);
  587. }
  588. }
  590. /* ----------
  591.  * Put the trig and new tuples into the records
  592.  * and set the tg_op variable
  593.  * ----------
  594.  */
  595. rec_new = (PLpgSQL_rec *) (estate.datums[func->new_varno]);
  596. rec_old = (PLpgSQL_rec *) (estate.datums[func->old_varno]);
  597. var = (PLpgSQL_var *) (estate.datums[func->tg_op_varno]);
  598. var->isnull = false;
  600. if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
  601. {
  602. rec_new->tup = trigdata->tg_trigtuple;
  603. rec_new->tupdesc = trigdata->tg_relation->rd_att;
  604. rec_old->tup = NULL;
  605. rec_old->tupdesc = NULL;
  606. var->value = (Datum) textin("INSERT");
  607. }
  608. else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
  609. {
  610. rec_new->tup = trigdata->tg_newtuple;
  611. rec_new->tupdesc = trigdata->tg_relation->rd_att;
  612. rec_old->tup = trigdata->tg_trigtuple;
  613. rec_old->tupdesc = trigdata->tg_relation->rd_att;
  614. var->value = (Datum) textin("UPDATE");
  615. }
  616. else if (TRIGGER_FIRED_BY_DELETE(trigdata->tg_event))
  617. {
  618. rec_new->tup = NULL;
  619. rec_new->tupdesc = NULL;
  620. rec_old->tup = trigdata->tg_trigtuple;
  621. rec_old->tupdesc = trigdata->tg_relation->rd_att;
  622. var->value = (Datum) textin("DELETE");
  623. }
  624. else
  625. {
  626. rec_new->tup = NULL;
  627. rec_new->tupdesc = NULL;
  628. var->value = (Datum) textin("UNKNOWN");
  629. }
  631. /* ----------
  632.  * Fill all the other special tg_ variables
  633.  * ----------
  634.  */
  635. var = (PLpgSQL_var *) (estate.datums[func->tg_name_varno]);
  636. var->isnull = false;
  637. var->value = (Datum) namein(trigdata->tg_trigger->tgname);
  639. var = (PLpgSQL_var *) (estate.datums[func->tg_when_varno]);
  640. var->isnull = false;
  641. if (TRIGGER_FIRED_BEFORE(trigdata->tg_event))
  642. var->value = (Datum) textin("BEFORE");
  643. else if (TRIGGER_FIRED_AFTER(trigdata->tg_event))
  644. var->value = (Datum) textin("AFTER");
  645. else
  646. var->value = (Datum) textin("UNKNOWN");
  648. var = (PLpgSQL_var *) (estate.datums[func->tg_level_varno]);
  649. var->isnull = false;
  650. if (TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
  651. var->value = (Datum) textin("ROW");
  652. else if (TRIGGER_FIRED_FOR_STATEMENT(trigdata->tg_event))
  653. var->value = (Datum) textin("STATEMENT");
  654. else
  655. var->value = (Datum) textin("UNKNOWN");
  657. var = (PLpgSQL_var *) (estate.datums[func->tg_relid_varno]);
  658. var->isnull = false;
  659. var->value = (Datum) (trigdata->tg_relation->rd_id);
  661. var = (PLpgSQL_var *) (estate.datums[func->tg_relname_varno]);
  662. var->isnull = false;
  663. var->value = (Datum) namein(nameout(&(trigdata->tg_relation->rd_rel->relname)));
  665. var = (PLpgSQL_var *) (estate.datums[func->tg_nargs_varno]);
  666. var->isnull = false;
  667. var->value = (Datum) (trigdata->tg_trigger->tgnargs);
  669. /* ----------
  670.  * Put the actual call argument values into the special
  671.  * execution state variables
  672.  * ----------
  673.  */
  674. error_info_text = "while putting call arguments to local variables";
  675. estate.trig_nargs = trigdata->tg_trigger->tgnargs;
  676. if (estate.trig_nargs == 0)
  677. estate.trig_argv = NULL;
  678. else
  679. {
  680. estate.trig_argv = palloc(sizeof(Datum) * estate.trig_nargs);
  681. for (i = 0; i < trigdata->tg_trigger->tgnargs; i++)
  682. estate.trig_argv[i] = (Datum) textin(trigdata->tg_trigger->tgargs[i]);
  683. }
  685. /* ----------
  686.  * Initialize the other variables to NULL values for now.
  687.  * The default values are set when the blocks are entered.
  688.  * ----------
  689.  */
  690. error_info_text = "while initializing local variables to NULL";
  691. for (i = estate.found_varno; i < estate.ndatums; i++)
  692. {
  693. switch (estate.datums[i]->dtype)
  694. {
  695. case PLPGSQL_DTYPE_VAR:
  696. {
  697. PLpgSQL_var *var = (PLpgSQL_var *) estate.datums[i];
  699. var->value = 0;
  700. var->isnull = true;
  701. var->shouldfree = false;
  702. }
  703. break;
  705. case PLPGSQL_DTYPE_ROW:
  706. case PLPGSQL_DTYPE_REC:
  707. case PLPGSQL_DTYPE_RECFIELD:
  708. case PLPGSQL_DTYPE_TRIGARG:
  709. break;
  711. default:
  712. elog(ERROR, "unknown dtype %d in plpgsql_exec_trigger()",
  713.  func->datums[i]->dtype);
  714. }
  715. }
  717. /* ----------
  718.  * Set the magic variable FOUND to false
  719.  * ----------
  720.  */
  721. exec_set_found(&estate, false);
  723. /* ----------
  724.  * Now call the toplevel block of statements
  725.  * ----------
  726.  */
  727. error_info_text = NULL;
  728. error_info_stmt = (PLpgSQL_stmt *) (func->action);
  729. if (exec_stmt_block(&estate, func->action) != PLPGSQL_RC_RETURN)
  730. {
  731. error_info_stmt = NULL;
  732. error_info_text = "at END of toplevel PL block";
  733. elog(ERROR, "control reaches end of trigger procedure without RETURN");
  734. }
  736. /* ----------
  737.  * Check that the returned tuple structure has the same attributes,
  738.  * the relation that fired the trigger has.
  739.  *
  740.  * XXX This way it is possible, that the trigger returns a tuple
  741.  *    where attributes don't have the correct atttypmod's length.
  742.  *    It's up to the trigger's programmer to ensure that this
  743.  *    doesn't happen. Jan
  744.  * ----------
  745.  */
  746. if (estate.retisnull)
  747. rettup = NULL;
  748. else
  749. {
  750. TupleDesc td1 = trigdata->tg_relation->rd_att;
  751. TupleDesc td2 = estate.rettupdesc;
  752. int i;
  754. if (td1->natts != td2->natts)
  755. elog(ERROR, "returned tuple structure doesn't match table of trigger event");
  756. for (i = 1; i <= td1->natts; i++)
  757. {
  758. if (SPI_gettypeid(td1, i) != SPI_gettypeid(td2, i))
  759. elog(ERROR, "returned tuple structure doesn't match table of trigger event");
  760. }
  762. rettup = SPI_copytuple((HeapTuple) (estate.retval));
  763. }
  765. /* ----------
  766.  * Restore the previous error info and elog() jump target
  767.  * ----------
  768.  */
  769. error_info_func = save_efunc;
  770. error_info_stmt = save_estmt;
  771. error_info_text = save_etext;
  772. memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
  774. /* ----------
  775.  * Return the triggers result
  776.  * ----------
  777.  */
  778. return rettup;
  779. }
  782. /* ----------
  783.  * Support functions for copying local execution variables
  784.  * ----------
  785.  */
  786. static PLpgSQL_var *
  787. copy_var(PLpgSQL_var * var)
  788. {
  789. PLpgSQL_var *new = palloc(sizeof(PLpgSQL_var));
  791. memcpy(new, var, sizeof(PLpgSQL_var));
  793. return new;
  794. }
  797. static PLpgSQL_rec *
  798. copy_rec(PLpgSQL_rec * rec)
  799. {
  800. PLpgSQL_rec *new = palloc(sizeof(PLpgSQL_rec));
  802. memcpy(new, rec, sizeof(PLpgSQL_rec));
  804. return new;
  805. }
  808. /* ----------
  809.  * exec_stmt_block Execute a block of statements
  810.  * ----------
  811.  */
  812. static int
  813. exec_stmt_block(PLpgSQL_execstate * estate, PLpgSQL_stmt_block * block)
  814. {
  815. int rc;
  816. int i;
  817. int n;
  819. /* ----------
  820.  * First initialize all variables declared in this block
  821.  * ----------
  822.  */
  823. for (i = 0; i < block->n_initvars; i++)
  824. {
  825. n = block->initvarnos[i];
  827. switch (estate->datums[n]->dtype)
  828. {
  829. case PLPGSQL_DTYPE_VAR:
  830. {
  831. PLpgSQL_var *var = (PLpgSQL_var *) (estate->datums[n]);
  833. if (!var->isconst || var->isnull)
  834. {
  835. if (var->default_val == NULL)
  836. {
  837. var->value = (Datum) 0;
  838. var->isnull = true;
  839. if (var->notnull)
  840. elog(ERROR, "variable '%s' declared NOT NULL cannot default to NULL", var->refname);
  841. }
  842. else
  843. {
  844. exec_assign_expr(estate, (PLpgSQL_datum *) var,
  845.  var->default_val);
  846. }
  847. }
  848. }
  849. break;
  851. case PLPGSQL_DTYPE_REC:
  852. {
  853. PLpgSQL_rec *rec = (PLpgSQL_rec *) (estate->datums[n]);
  855. rec->tup = NULL;
  856. rec->tupdesc = NULL;
  857. }
  858. break;
  860. case PLPGSQL_DTYPE_RECFIELD:
  861. break;
  863. default:
  864. elog(ERROR, "unknown dtype %d in exec_stmt_block()", estate->datums[n]->dtype);
  865. }
  867. }
  869. /* ----------
  870.  * Execute the statements in the block's body
  871.  * ----------
  872.  */
  873. rc = exec_stmts(estate, block->body);
  875. /* ----------
  876.  * Handle the return code.
  877.  * ----------
  878.  */
  879. switch (rc)
  880. {
  881. case PLPGSQL_RC_OK:
  882. return PLPGSQL_RC_OK;
  884. case PLPGSQL_RC_EXIT:
  885. if (estate->exitlabel == NULL)
  886. return PLPGSQL_RC_OK;
  887. if (block->label == NULL)
  888. return PLPGSQL_RC_EXIT;
  889. if (strcmp(block->label, estate->exitlabel))
  890. return PLPGSQL_RC_EXIT;
  891. estate->exitlabel = NULL;
  892. return PLPGSQL_RC_OK;
  894. case PLPGSQL_RC_RETURN:
  895. return PLPGSQL_RC_RETURN;
  897. default:
  898. elog(ERROR, "unknown rc %d from exec_stmt()", rc);
  899. }
  901. return PLPGSQL_RC_OK;
  902. }
  905. /* ----------
  906.  * exec_stmts Iterate over a list of statements
  907.  * as long as their return code is OK
  908.  * ----------
  909.  */
  910. static int
  911. exec_stmts(PLpgSQL_execstate * estate, PLpgSQL_stmts * stmts)
  912. {
  913. int rc;
  914. int i;
  916. for (i = 0; i < stmts->stmts_used; i++)
  917. {
  918. rc = exec_stmt(estate, (PLpgSQL_stmt *) (stmts->stmts[i]));
  919. if (rc != PLPGSQL_RC_OK)
  920. return rc;
  921. }
  923. return PLPGSQL_RC_OK;
  924. }
  927. /* ----------
  928.  * exec_stmt Distribute one statement to the statements
  929.  * type specific execution function.
  930.  * ----------
  931.  */
  932. static int
  933. exec_stmt(PLpgSQL_execstate * estate, PLpgSQL_stmt * stmt)
  934. {
  935. PLpgSQL_stmt *save_estmt;
  936. int rc = -1;
  938. save_estmt = error_info_stmt;
  939. error_info_stmt = stmt;
  941. switch (stmt->cmd_type)
  942. {
  943. case PLPGSQL_STMT_BLOCK:
  944. rc = exec_stmt_block(estate, (PLpgSQL_stmt_block *) stmt);
  945. break;
  947. case PLPGSQL_STMT_ASSIGN:
  948. rc = exec_stmt_assign(estate, (PLpgSQL_stmt_assign *) stmt);
  949. break;
  951. case PLPGSQL_STMT_IF:
  952. rc = exec_stmt_if(estate, (PLpgSQL_stmt_if *) stmt);
  953. break;
  955. case PLPGSQL_STMT_LOOP:
  956. rc = exec_stmt_loop(estate, (PLpgSQL_stmt_loop *) stmt);
  957. break;
  959. case PLPGSQL_STMT_WHILE:
  960. rc = exec_stmt_while(estate, (PLpgSQL_stmt_while *) stmt);
  961. break;
  963. case PLPGSQL_STMT_FORI:
  964. rc = exec_stmt_fori(estate, (PLpgSQL_stmt_fori *) stmt);
  965. break;
  967. case PLPGSQL_STMT_FORS:
  968. rc = exec_stmt_fors(estate, (PLpgSQL_stmt_fors *) stmt);
  969. break;
  971. case PLPGSQL_STMT_SELECT:
  972. rc = exec_stmt_select(estate, (PLpgSQL_stmt_select *) stmt);
  973. break;
  975. case PLPGSQL_STMT_EXIT:
  976. rc = exec_stmt_exit(estate, (PLpgSQL_stmt_exit *) stmt);
  977. break;
  979. case PLPGSQL_STMT_RETURN:
  980. rc = exec_stmt_return(estate, (PLpgSQL_stmt_return *) stmt);
  981. break;
  983. case PLPGSQL_STMT_RAISE:
  984. rc = exec_stmt_raise(estate, (PLpgSQL_stmt_raise *) stmt);
  985. break;
  987. case PLPGSQL_STMT_EXECSQL:
  988. rc = exec_stmt_execsql(estate, (PLpgSQL_stmt_execsql *) stmt);
  989. break;
  991. default:
  992. error_info_stmt = save_estmt;
  993. elog(ERROR, "unknown cmdtype %d in exec_stmt",
  994.  stmt->cmd_type);
  995. }
  997. error_info_stmt = save_estmt;
  999. return rc;
  1000. }
  1003. /* ----------
  1004.  * exec_stmt_assign Evaluate an expression and
  1005.  * put the result into a variable.
  1006.  * ----------
  1007.  */
  1008. static int
  1009. exec_stmt_assign(PLpgSQL_execstate * estate, PLpgSQL_stmt_assign * stmt)
  1010. {
  1011. if (stmt->varno < 0)
  1012. exec_assign_expr(estate, NULL, stmt->expr);
  1013. else
  1014. exec_assign_expr(estate, estate->datums[stmt->varno], stmt->expr);
  1016. return PLPGSQL_RC_OK;
  1017. }
  1020. /* ----------
  1021.  * exec_stmt_if Evaluate a bool expression and
  1022.  * execute the true or false body
  1023.  * conditionally.
  1024.  * ----------
  1025.  */
  1026. static int
  1027. exec_stmt_if(PLpgSQL_execstate * estate, PLpgSQL_stmt_if * stmt)
  1028. {
  1029. Datum value;
  1030. Oid valtype;
  1031. bool isnull = false;
  1033. value = exec_eval_expr(estate, stmt->cond, &isnull, &valtype);
  1035. if (value)
  1036. {
  1037. if (stmt->true_body != NULL)
  1038. return exec_stmts(estate, stmt->true_body);
  1039. }
  1040. else
  1041. {
  1042. if (stmt->false_body != NULL)
  1043. return exec_stmts(estate, stmt->false_body);
  1044. }
  1046. return PLPGSQL_RC_OK;
  1047. }
  1050. /* ----------
  1051.  * exec_stmt_loop Loop over statements until
  1052.  * an exit occurs.
  1053.  * ----------
  1054.  */
  1055. static int
  1056. exec_stmt_loop(PLpgSQL_execstate * estate, PLpgSQL_stmt_loop * stmt)
  1057. {
  1058. int rc;
  1060. for (;;)
  1061. {
  1062. rc = exec_stmts(estate, stmt->body);
  1064. switch (rc)
  1065. {
  1066. case PLPGSQL_RC_OK:
  1067. break;
  1069. case PLPGSQL_RC_EXIT:
  1070. if (estate->exitlabel == NULL)
  1071. return PLPGSQL_RC_OK;
  1072. if (stmt->label == NULL)
  1073. return PLPGSQL_RC_EXIT;
  1074. if (strcmp(stmt->label, estate->exitlabel))
  1075. return PLPGSQL_RC_EXIT;
  1076. estate->exitlabel = NULL;
  1077. return PLPGSQL_RC_OK;
  1079. case PLPGSQL_RC_RETURN:
  1080. return PLPGSQL_RC_RETURN;
  1082. default:
  1083. elog(ERROR, "unknown rc %d from exec_stmts()", rc);
  1084. }
  1085. }
  1087. return PLPGSQL_RC_OK;
  1088. }
  1091. /* ----------
  1092.  * exec_stmt_while Loop over statements as long
  1093.  * as an expression evaluates to
  1094.  * true or an exit occurs.
  1095.  * ----------
  1096.  */
  1097. static int
  1098. exec_stmt_while(PLpgSQL_execstate * estate, PLpgSQL_stmt_while * stmt)
  1099. {
  1100. Datum value;
  1101. Oid valtype;
  1102. bool isnull = false;
  1103. int rc;
  1105. for (;;)
  1106. {
  1107. value = exec_eval_expr(estate, stmt->cond, &isnull, &valtype);
  1108. if (!value)
  1109. break;
  1111. rc = exec_stmts(estate, stmt->body);
  1113. switch (rc)
  1114. {
  1115. case PLPGSQL_RC_OK:
  1116. break;
  1118. case PLPGSQL_RC_EXIT:
  1119. if (estate->exitlabel == NULL)
  1120. return PLPGSQL_RC_OK;
  1121. if (stmt->label == NULL)
  1122. return PLPGSQL_RC_EXIT;
  1123. if (strcmp(stmt->label, estate->exitlabel))
  1124. return PLPGSQL_RC_EXIT;
  1125. estate->exitlabel = NULL;
  1126. return PLPGSQL_RC_OK;
  1128. case PLPGSQL_RC_RETURN:
  1129. return PLPGSQL_RC_RETURN;
  1131. default:
  1132. elog(ERROR, "unknown rc %d from exec_stmts()", rc);
  1133. }
  1134. }
  1136. return PLPGSQL_RC_OK;
  1137. }
  1140. /* ----------
  1141.  * exec_stmt_fori Iterate an integer variable
  1142.  * from a lower to an upper value.
  1143.  * Loop can be left with exit.
  1144.  * ----------
  1145.  */
  1146. static int
  1147. exec_stmt_fori(PLpgSQL_execstate * estate, PLpgSQL_stmt_fori * stmt)
  1148. {
  1149. PLpgSQL_var *var;
  1150. Datum value;
  1151. Oid valtype;
  1152. bool isnull = false;
  1153. int rc;
  1155. /* ----------
  1156.  * Get the value of the lower bound into the loop var
  1157.  * ----------
  1158.  */
  1159. value = exec_eval_expr(estate, stmt->lower, &isnull, &valtype);
  1160. var = (PLpgSQL_var *) (estate->datums[stmt->var->varno]);
  1162. value = exec_cast_value(value, valtype, var->datatype->typoid,
  1163. &(var->datatype->typinput),
  1164. var->datatype->atttypmod, &isnull);
  1165. if (isnull)
  1166. elog(ERROR, "lower bound of FOR loop cannot be NULL");
  1167. var->value = value;
  1168. var->isnull = false;
  1170. /* ----------
  1171.  * Get the value of the upper bound
  1172.  * ----------
  1173.  */
  1174. value = exec_eval_expr(estate, stmt->upper, &isnull, &valtype);
  1175. value = exec_cast_value(value, valtype, var->datatype->typoid,
  1176. &(var->datatype->typinput),
  1177. var->datatype->atttypmod, &isnull);
  1178. if (isnull)
  1179. elog(ERROR, "upper bound of FOR loop cannot be NULL");
  1181. /* ----------
  1182.  * Now do the loop
  1183.  * ----------
  1184.  */
  1185. exec_set_found(estate, false);
  1186. for (;;)
  1187. {
  1188. /* ----------
  1189.  * Check bounds
  1190.  * ----------
  1191.  */
  1192. if (stmt->reverse)
  1193. {
  1194. if ((int4) (var->value) < (int4) value)
  1195. break;
  1196. }
  1197. else
  1198. {
  1199. if ((int4) (var->value) > (int4) value)
  1200. break;
  1201. }
  1202. exec_set_found(estate, true);
  1204. /* ----------
  1205.  * Execute the statements
  1206.  * ----------
  1207.  */
  1208. rc = exec_stmts(estate, stmt->body);
  1210. /* ----------
  1211.  * Check returncode
  1212.  * ----------
  1213.  */
  1214. switch (rc)
  1215. {
  1216. case PLPGSQL_RC_OK:
  1217. break;
  1219. case PLPGSQL_RC_EXIT:
  1220. if (estate->exitlabel == NULL)
  1221. return PLPGSQL_RC_OK;
  1222. if (stmt->label == NULL)
  1223. return PLPGSQL_RC_EXIT;
  1224. if (strcmp(stmt->label, estate->exitlabel))
  1225. return PLPGSQL_RC_EXIT;
  1226. estate->exitlabel = NULL;
  1227. return PLPGSQL_RC_OK;
  1229. case PLPGSQL_RC_RETURN:
  1230. return PLPGSQL_RC_RETURN;
  1232. default:
  1233. elog(ERROR, "unknown rc %d from exec_stmts()", rc);
  1234. }
  1236. /* ----------
  1237.  * Increase/decrease loop var
  1238.  * ----------
  1239.  */
  1240. if (stmt->reverse)
  1241. var->value--;
  1242. else
  1243. var->value++;
  1244. }
  1246. return PLPGSQL_RC_OK;
  1247. }
  1250. /* ----------
  1251.  * exec_stmt_fors Execute a query, assign each
  1252.  * tuple to a record or row and
  1253.  * execute a group of statements
  1254.  * for it.
  1255.  * ----------
  1256.  */
  1257. static int
  1258. exec_stmt_fors(PLpgSQL_execstate * estate, PLpgSQL_stmt_fors * stmt)
  1259. {
  1260. PLpgSQL_rec *rec = NULL;
  1261. PLpgSQL_row *row = NULL;
  1262. SPITupleTable *tuptab;
  1263. int rc;
  1264. int i;
  1265. int n;
  1267. /* ----------
  1268.  * Initialize the global found variable to false
  1269.  * ----------
  1270.  */
  1271. exec_set_found(estate, false);
  1273. /* ----------
  1274.  * Determine if we assign to a record or a row
  1275.  * ----------
  1276.  */
  1277. if (stmt->rec != NULL)
  1278. rec = (PLpgSQL_rec *) (estate->datums[stmt->rec->recno]);
  1279. else
  1280. {
  1281. if (stmt->row != NULL)
  1282. row = (PLpgSQL_row *) (estate->datums[stmt->row->rowno]);
  1283. else
  1284. elog(ERROR, "unsupported target in exec_stmt_fors()");
  1285. }
  1287. /* ----------
  1288.  * Run the query
  1289.  * ----------
  1290.  */
  1291. exec_run_select(estate, stmt->query, 0);
  1292. n = SPI_processed;
  1294. /* ----------
  1295.  * If the query didn't return any row, set the target
  1296.  * to NULL and return.
  1297.  * ----------
  1298.  */
  1299. if (n == 0)
  1300. {
  1301. exec_move_row(estate, rec, row, NULL, NULL);
  1302. return PLPGSQL_RC_OK;
  1303. }
  1305. /* ----------
  1306.  * There are tuples, so set found to true
  1307.  * ----------
  1308.  */
  1309. exec_set_found(estate, true);
  1311. /* ----------
  1312.  * Now do the loop
  1313.  * ----------
  1314.  */
  1315. tuptab = SPI_tuptable;
  1316. SPI_tuptable = NULL;
  1318. for (i = 0; i < n; i++)
  1319. {
  1320. /* ----------
  1321.  * Assign the tuple to the target
  1322.  * ----------
  1323.  */
  1324. exec_move_row(estate, rec, row, tuptab->vals[i], tuptab->tupdesc);
  1326. /* ----------
  1327.  * Execute the statements
  1328.  * ----------
  1329.  */
  1330. rc = exec_stmts(estate, stmt->body);
  1332. /* ----------
  1333.  * Check returncode
  1334.  * ----------
  1335.  */
  1336. switch (rc)
  1337. {
  1338. case PLPGSQL_RC_OK:
  1339. break;
  1341. case PLPGSQL_RC_EXIT:
  1342. if (estate->exitlabel == NULL)
  1343. return PLPGSQL_RC_OK;
  1344. if (stmt->label == NULL)
  1345. return PLPGSQL_RC_EXIT;
  1346. if (strcmp(stmt->label, estate->exitlabel))
  1347. return PLPGSQL_RC_EXIT;
  1348. estate->exitlabel = NULL;
  1349. return PLPGSQL_RC_OK;
  1351. case PLPGSQL_RC_RETURN:
  1352. return PLPGSQL_RC_RETURN;
  1354. default:
  1355. elog(ERROR, "unknown rc %d from exec_stmts()", rc);
  1356. }
  1357. }
  1359. return PLPGSQL_RC_OK;
  1360. }
  1363. /* ----------
  1364.  * exec_stmt_select Run a query and assign the first
  1365.  * row to a record or rowtype.
  1366.  *  ----------
  1367.  */
  1368. static int
  1369. exec_stmt_select(PLpgSQL_execstate * estate, PLpgSQL_stmt_select * stmt)
  1370. {
  1371. PLpgSQL_rec *rec = NULL;
  1372. PLpgSQL_row *row = NULL;
  1373. SPITupleTable *tuptab;
  1374. int n;
  1376. /* ----------
  1377.  * Initialize the global found variable to false
  1378.  * ----------
  1379.  */
  1380. exec_set_found(estate, false);
  1382. /* ----------
  1383.  * Determine if we assign to a record or a row
  1384.  * ----------
  1385.  */
  1386. if (stmt->rec != NULL)
  1387. rec = (PLpgSQL_rec *) (estate->datums[stmt->rec->recno]);
  1388. else
  1389. {
  1390. if (stmt->row != NULL)
  1391. row = (PLpgSQL_row *) (estate->datums[stmt->row->rowno]);
  1392. else
  1393. elog(ERROR, "unsupported target in exec_stmt_select()");
  1394. }
  1396. /* ----------
  1397.  * Run the query
  1398.  * ----------
  1399.  */
  1400. exec_run_select(estate, stmt->query, 1);
  1401. n = SPI_processed;
  1403. /* ----------
  1404.  * If the query didn't return any row, set the target
  1405.  * to NULL and return.
  1406.  * ----------
  1407.  */
  1408. if (n == 0)
  1409. {
  1410. exec_move_row(estate, rec, row, NULL, NULL);
  1411. return PLPGSQL_RC_OK;
  1412. }
  1414. /* ----------
  1415.  * Put the result into the target and set found to true
  1416.  * ----------
  1417.  */
  1418. tuptab = SPI_tuptable;
  1419. SPI_tuptable = NULL;
  1421. exec_move_row(estate, rec, row, tuptab->vals[0], tuptab->tupdesc);
  1423. exec_set_found(estate, true);
  1425. return PLPGSQL_RC_OK;
  1426. }
  1429. /* ----------
  1430.  * exec_stmt_exit Start exiting loop(s) or blocks
  1431.  * ----------
  1432.  */
  1433. static int
  1434. exec_stmt_exit(PLpgSQL_execstate * estate, PLpgSQL_stmt_exit * stmt)
  1435. {
  1436. Datum value;
  1437. Oid valtype;
  1438. bool isnull = false;
  1440. /* ----------
  1441.  * If the exit has a condition, check that it's true
  1442.  * ----------
  1443.  */
  1444. if (stmt->cond != NULL)
  1445. {
  1446. value = exec_eval_expr(estate, stmt->cond, &isnull, &valtype);
  1447. if (!value)
  1448. return PLPGSQL_RC_OK;
  1449. }
  1451. estate->exitlabel = stmt->label;
  1452. return PLPGSQL_RC_EXIT;
  1453. }
  1456. /* ----------
  1457.  * exec_stmt_return Evaluate an expression and start
  1458.  * returning from the function.
  1459.  * ----------
  1460.  */
  1461. static int
  1462. exec_stmt_return(PLpgSQL_execstate * estate, PLpgSQL_stmt_return * stmt)
  1463. {
  1464. if (estate->retistuple)
  1465. {
  1466. if (stmt->retrecno >= 0)
  1467. {
  1468. PLpgSQL_rec *rec = (PLpgSQL_rec *) (estate->datums[stmt->retrecno]);
  1470. estate->retval = (Datum) (rec->tup);
  1471. estate->rettupdesc = rec->tupdesc;
  1472. estate->retisnull = !HeapTupleIsValid(rec->tup);
  1474. return PLPGSQL_RC_RETURN;
  1475. }
  1477. if (stmt->expr == NULL)
  1478. {
  1479. estate->retval = (Datum) 0;
  1480. estate->rettupdesc = NULL;
  1481. estate->retisnull = true;
  1482. }
  1483. else
  1484. {
  1485. exec_run_select(estate, stmt->expr, 1);
  1486. estate->retval = (Datum) SPI_copytuple(SPI_tuptable->vals[0]);
  1487. estate->rettupdesc = SPI_tuptable->tupdesc;
  1488. estate->retisnull = false;
  1489. }
  1490. return PLPGSQL_RC_RETURN;
  1491. }
  1493. estate->retval = exec_eval_expr(estate, stmt->expr,
  1494. &(estate->retisnull),
  1495. &(estate->rettype));
  1497. return PLPGSQL_RC_RETURN;
  1498. }
  1501. /* ----------
  1502.  * exec_stmt_raise Build a message and throw it with
  1503.  * elog()
  1504.  * ----------
  1505.  */
  1506. static int
  1507. exec_stmt_raise(PLpgSQL_execstate * estate, PLpgSQL_stmt_raise * stmt)
  1508. {
  1509. HeapTuple typetup;
  1510. Form_pg_type typeStruct;
  1511. FmgrInfo finfo_output;
  1512. char    *extval;
  1513. int pidx = 0;
  1514. char c[2] = {0, 0};
  1515. char    *cp;
  1516. PLpgSQL_dstring ds;
  1517. PLpgSQL_var *var;
  1518. PLpgSQL_rec *rec;
  1519. PLpgSQL_recfield *recfield;
  1520. int fno;
  1522. plpgsql_dstring_init(&ds);
  1524. for (cp = stmt->message; *cp; cp++)
  1525. {
  1526. /* ----------
  1527.  * Occurences of a single % are replaced by the next
  1528.  * arguments external representation. Double %'s are
  1529.  * left as is so elog() will also don't touch them.
  1530.  * ----------
  1531.  */
  1532. if ((c[0] = *cp) == '%')
  1533. {
  1534. cp++;
  1535. if (*cp == '%')
  1536. {
  1537. plpgsql_dstring_append(&ds, c);
  1538. plpgsql_dstring_append(&ds, c);
  1539. continue;
  1540. }
  1541. cp--;
  1542. if (pidx >= stmt->nparams)
  1543. {
  1544. plpgsql_dstring_append(&ds, c);
  1545. plpgsql_dstring_append(&ds, c);
  1546. continue;
  1547. }
  1548. switch (estate->datums[stmt->params[pidx]]->dtype)
  1549. {
  1550. case PLPGSQL_DTYPE_VAR:
  1551. var = (PLpgSQL_var *)
  1552. (estate->datums[stmt->params[pidx]]);
  1553. if (var->isnull)
  1554. extval = "<NULL>";
  1555. else
  1556. {
  1557. typetup = SearchSysCacheTuple(TYPOID,
  1558. ObjectIdGetDatum(var->datatype->typoid), 0, 0, 0);
  1559. if (!HeapTupleIsValid(typetup))
  1560. elog(ERROR, "cache lookup for type %u failed (1)", var->datatype->typoid);
  1561. typeStruct = (Form_pg_type) GETSTRUCT(typetup);
  1563. fmgr_info(typeStruct->typoutput, &finfo_output);
  1564. extval = (char *) (*fmgr_faddr(&finfo_output)) (var->value, &(var->isnull), var->datatype->atttypmod);
  1565. }
  1566. plpgsql_dstring_append(&ds, extval);
  1567. break;
  1569. case PLPGSQL_DTYPE_RECFIELD:
  1570. recfield = (PLpgSQL_recfield *)
  1571. (estate->datums[stmt->params[pidx]]);
  1572. rec = (PLpgSQL_rec *)
  1573. (estate->datums[recfield->recno]);
  1574. if (!HeapTupleIsValid(rec->tup))
  1575. extval = "<NULL>";
  1576. else
  1577. {
  1578. fno = SPI_fnumber(rec->tupdesc, recfield->fieldname);
  1579. if (fno == SPI_ERROR_NOATTRIBUTE)
  1580. elog(ERROR, "record %s has no field %s", rec->refname, recfield->fieldname);
  1581. extval = SPI_getvalue(rec->tup, rec->tupdesc, fno);
  1582. }
  1583. plpgsql_dstring_append(&ds, extval);
  1584. break;
  1586. case PLPGSQL_DTYPE_TRIGARG:
  1587. {
  1588. PLpgSQL_trigarg *trigarg;
  1589. int value;
  1590. Oid valtype;
  1591. bool valisnull = false;
  1593. trigarg = (PLpgSQL_trigarg *)
  1594. (estate->datums[stmt->params[pidx]]);
  1595. value = (int) exec_eval_expr(estate, trigarg->argnum,
  1596.    &valisnull, &valtype);
  1597. if (valisnull)
  1598. extval = "<INDEX_IS_NULL>";
  1599. else
  1600. {
  1601. if (value < 0 || value >= estate->trig_nargs)
  1602. extval = "<OUT_OF_RANGE>";
  1603. else
  1604. extval = textout((text *) (estate->trig_argv[value]));
  1605. }
  1606. plpgsql_dstring_append(&ds, extval);
  1607. }
  1608. break;
  1610. default:
  1611. c[0] = '?';
  1612. plpgsql_dstring_append(&ds, c);
  1613. break;
  1614. }
  1615. pidx++;
  1616. continue;
  1617. }
  1619. /* ----------
  1620.  * Occurences of single ' are removed. double ' are reduced
  1621.  * to single ones.
  1622.  * ----------
  1623.  */
  1624. if (*cp == ''')
  1625. {
  1626. cp++;
  1627. if (*cp == ''')
  1628. plpgsql_dstring_append(&ds, c);
  1629. else
  1630. cp--;
  1631. continue;
  1632. }
  1633. plpgsql_dstring_append(&ds, c);
  1634. }
  1636. /* ----------
  1637.  * Now suppress debug info and throw the elog()
  1638.  * ----------
  1639.  */
  1640. if (stmt->elog_level == ERROR)
  1641. {
  1642. error_info_func = NULL;
  1643. error_info_stmt = NULL;
  1644. error_info_text = NULL;
  1645. }
  1646. elog(stmt->elog_level, "%s", plpgsql_dstring_get(&ds));
  1647. plpgsql_dstring_free(&ds);
  1649. return PLPGSQL_RC_OK;
  1650. }
  1653. /* ----------
  1654.  * Generate a prepared plan
  1655.  * ----------
  1656.  */
  1657. static void
  1658. exec_prepare_plan(PLpgSQL_execstate * estate,
  1659.   PLpgSQL_expr * expr)
  1660. {
  1661. PLpgSQL_var *var;
  1662. PLpgSQL_rec *rec;
  1663. PLpgSQL_recfield *recfield;
  1664. int i;
  1665. int fno;
  1666. void    *plan;
  1667. Oid    *argtypes;
  1669. /* ----------
  1670.  * Setup the argtypes array
  1671.  * ----------
  1672.  */
  1673. argtypes = malloc(sizeof(Oid *) * (expr->nparams + 1));
  1675. for (i = 0; i < expr->nparams; i++)
  1676. {
  1677. switch (estate->datums[expr->params[i]]->dtype)
  1678. {
  1679. case PLPGSQL_DTYPE_VAR:
  1680. var = (PLpgSQL_var *) (estate->datums[expr->params[i]]);
  1681. argtypes[i] = var->datatype->typoid;
  1682. break;
  1684. case PLPGSQL_DTYPE_RECFIELD:
  1685. recfield = (PLpgSQL_recfield *) (estate->datums[expr->params[i]]);
  1686. rec = (PLpgSQL_rec *) (estate->datums[recfield->recno]);
  1688. if (!HeapTupleIsValid(rec->tup))
  1689. elog(ERROR, "record %s is unassigned yet", rec->refname);
  1690. fno = SPI_fnumber(rec->tupdesc, recfield->fieldname);
  1691. if (fno == SPI_ERROR_NOATTRIBUTE)
  1692. elog(ERROR, "record %s has no field %s", rec->refname, recfield->fieldname);
  1693. argtypes[i] = SPI_gettypeid(rec->tupdesc, fno);
  1694. break;
  1696. case PLPGSQL_DTYPE_TRIGARG:
  1697. argtypes[i] = (Oid) TEXTOID;
  1698. break;
  1700. default:
  1701. elog(ERROR, "unknown parameter dtype %d in exec_run_select()", estate->datums[expr->params[i]]);
  1702. }
  1703. }
  1705. /* ----------
  1706.  * Generate and save the plan
  1707.  * ----------
  1708.  */
  1709. plan = SPI_prepare(expr->query, expr->nparams, argtypes);
  1710. if (plan == NULL)
  1711. elog(ERROR, "SPI_prepare() failed on "%s"", expr->query);
  1712. expr->plan = SPI_saveplan(plan);
  1713. expr->plan_argtypes = argtypes;
  1714. expr->plan_simple_expr = NULL;
  1715. exec_simple_check_plan(expr);
  1716. }
  1719. /* ----------
  1720.  * exec_stmt_execsql Execute an SQL statement not
  1721.  * returning any data.
  1722.  * ----------
  1723.  */
  1724. static int
  1725. exec_stmt_execsql(PLpgSQL_execstate * estate,
  1726.   PLpgSQL_stmt_execsql * stmt)
  1727. {
  1728. PLpgSQL_var *var;
  1729. PLpgSQL_rec *rec;
  1730. PLpgSQL_recfield *recfield;
  1731. PLpgSQL_trigarg *trigarg;
  1732. int tgargno;
  1733. Oid tgargoid;
  1734. int fno;
  1735. int i;
  1736. Datum    *values;
  1737. char    *nulls;
  1738. int rc;
  1739. PLpgSQL_expr *expr = stmt->sqlstmt;
  1740. bool isnull;
  1742. /* ----------
  1743.  * On the first call for this expression generate the plan
  1744.  * ----------
  1745.  */
  1746. if (expr->plan == NULL)
  1747. exec_prepare_plan(estate, expr);
  1749. /* ----------
  1750.  * Now build up the values and nulls arguments for SPI_execp()
  1751.  * ----------
  1752.  */
  1753. values = palloc(sizeof(Datum) * (expr->nparams + 1));
  1754. nulls = palloc(expr->nparams + 1);
  1756. for (i = 0; i < expr->nparams; i++)
  1757. {
  1758. switch (estate->datums[expr->params[i]]->dtype)
  1759. {
  1760. case PLPGSQL_DTYPE_VAR:
  1761. var = (PLpgSQL_var *) (estate->datums[expr->params[i]]);
  1762. values[i] = var->value;
  1763. if (var->isnull)
  1764. nulls[i] = 'n';
  1765. else
  1766. nulls[i] = ' ';
  1767. break;
  1769. case PLPGSQL_DTYPE_RECFIELD:
  1770. recfield = (PLpgSQL_recfield *) (estate->datums[expr->params[i]]);
  1771. rec = (PLpgSQL_rec *) (estate->datums[recfield->recno]);
  1773. if (!HeapTupleIsValid(rec->tup))
  1774. elog(ERROR, "record %s is unassigned yet", rec->refname);
  1775. fno = SPI_fnumber(rec->tupdesc, recfield->fieldname);
  1776. if (fno == SPI_ERROR_NOATTRIBUTE)
  1777. elog(ERROR, "record %s has no field %s", rec->refname, recfield->fieldname);
  1779. if (expr->plan_argtypes[i] != SPI_gettypeid(rec->tupdesc, fno))
  1780. elog(ERROR, "type of %s.%s doesn't match that when preparing the plan", rec->refname, recfield->fieldname);
  1782. values[i] = SPI_getbinval(rec->tup, rec->tupdesc, fno, &isnull);
  1783. if (isnull)
  1784. nulls[i] = 'n';
  1785. else
  1786. nulls[i] = ' ';
  1787. break;
  1789. case PLPGSQL_DTYPE_TRIGARG:
  1790. trigarg = (PLpgSQL_trigarg *) (estate->datums[expr->params[i]]);
  1791. tgargno = (int) exec_eval_expr(estate, trigarg->argnum,
  1792.    &isnull, &tgargoid);
  1793. if (isnull || tgargno < 0 || tgargno >= estate->trig_nargs)
  1794. {
  1795. values[i] = 0;
  1796. nulls[i] = 'n';
  1797. }
  1798. else
  1799. {
  1800. values[i] = estate->trig_argv[tgargno];
  1801. nulls[i] = ' ';
  1802. }
  1803. break;
  1805. default:
  1806. elog(ERROR, "unknown parameter dtype %d in exec_stmt_execsql()", estate->datums[expr->params[i]]->dtype);
  1807. }
  1808. }
  1809. nulls[i] = '';
  1811. /* ----------
  1812.  * Execute the plan
  1813.  * ----------
  1814.  */
  1815. rc = SPI_execp(expr->plan, values, nulls, 0);
  1816. switch (rc)
  1817. {
  1818. case SPI_OK_UTILITY:
  1819. case SPI_OK_SELINTO:
  1820. case SPI_OK_INSERT:
  1821. case SPI_OK_DELETE:
  1822. case SPI_OK_UPDATE:
  1823. break;
  1825. case SPI_OK_SELECT:
  1826. elog(ERROR, "unexpected SELECT query in exec_stmt_execsql()");
  1828. default:
  1829. elog(ERROR, "error executing query "%s"",
  1830.  expr->query);
  1831. }
  1832. pfree(values);
  1833. pfree(nulls);
  1835. return PLPGSQL_RC_OK;
  1836. }
  1839. /* ----------
  1840.  * exec_assign_expr Put an expressions result into
  1841.  * a variable.
  1842.  * ----------
  1843.  */
  1844. static void
  1845. exec_assign_expr(PLpgSQL_execstate * estate, PLpgSQL_datum * target,
  1846.  PLpgSQL_expr * expr)
  1847. {
  1848. Datum value;
  1849. Oid valtype;
  1850. bool isnull = false;
  1852. value = exec_eval_expr(estate, expr, &isnull, &valtype);
  1853. if (target != NULL)
  1854. exec_assign_value(estate, target, value, valtype, &isnull);
  1855. }
  1858. /* ----------
  1859.  * exec_assign_value Put a value into a target field
  1860.  * ----------
  1861.  */
  1862. static void
  1863. exec_assign_value(PLpgSQL_execstate * estate,
  1864.   PLpgSQL_datum * target,
  1865.   Datum value, Oid valtype, bool *isNull)
  1866. {
  1867. PLpgSQL_var *var;
  1868. PLpgSQL_rec *rec;
  1869. PLpgSQL_recfield *recfield;
  1870. int fno;
  1871. int i;
  1872. int natts;
  1873. Datum    *values;
  1874. char    *nulls;
  1875. bool attisnull;
  1876. Oid atttype;
  1877. int4 atttypmod;
  1878. HeapTuple typetup;
  1879. Form_pg_type typeStruct;
  1880. FmgrInfo finfo_input;
  1882. switch (target->dtype)
  1883. {
  1884. case PLPGSQL_DTYPE_VAR:
  1885. /* ----------
  1886.  * Target field is a variable - that's easy
  1887.  * ----------
  1888.  */
  1889. var = (PLpgSQL_var *) target;
  1890. var->value = exec_cast_value(value, valtype, var->datatype->typoid,
  1891.  &(var->datatype->typinput),
  1892.    var->datatype->atttypmod, isNull);
  1894. if (isNull && var->notnull)
  1895. elog(ERROR, "NULL assignment to variable '%s' declared NOT NULL", var->refname);
  1897. var->isnull = *isNull;
  1898. break;
  1900. case PLPGSQL_DTYPE_RECFIELD:
  1901. /* ----------
  1902.  * Target field is a record
  1903.  * ----------
  1904.  */
  1905. recfield = (PLpgSQL_recfield *) target;
  1906. rec = (PLpgSQL_rec *) (estate->datums[recfield->recno]);
  1908. /* ----------
  1909.  * Check that there is already a tuple in the record.
  1910.  * We need that because records don't have any predefined
  1911.  * field structure.
  1912.  * ----------
  1913.  */
  1914. if (!HeapTupleIsValid(rec->tup))
  1915. elog(ERROR, "record %s is unassigned yet - don't know it's tuple structure", rec->refname);
  1917. /* ----------
  1918.  * Get the number of the records field to change and the
  1919.  * number of attributes in the tuple.
  1920.  * ----------
  1921.  */
  1922. fno = SPI_fnumber(rec->tupdesc, recfield->fieldname);
  1923. if (fno == SPI_ERROR_NOATTRIBUTE)
  1924. elog(ERROR, "record %s has no field %s", rec->refname, recfield->fieldname);
  1925. fno--;
  1926. natts = rec->tupdesc->natts;
  1928. /* ----------
  1929.  * We loop over the attributes of the rec's current tuple
  1930.  * and collect the values in a Datum array along with the
  1931.  * nulls information.
  1932.  * ----------
  1933.  */
  1934. values = palloc(sizeof(Datum) * natts);
  1935. nulls = palloc(natts + 1);
  1937. for (i = 0; i < natts; i++)
  1938. {
  1939. /* ----------
  1940.  * If this isn't the field we assign to, just use the
  1941.  * value that's already in the tuple.
  1942.  * ----------
  1943.  */
  1944. if (i != fno)
  1945. {
  1946. values[i] = SPI_getbinval(rec->tup, rec->tupdesc,
  1947.   i + 1, &attisnull);
  1948. if (attisnull)
  1949. nulls[i] = 'n';
  1950. else
  1951. nulls[i] = ' ';
  1952. continue;
  1953. }
  1955. /* ----------
  1956.  * This is the field to change. Get it's type
  1957.  * and cast the value we insert to that type.
  1958.  * ----------
  1959.  */
  1960. atttype = SPI_gettypeid(rec->tupdesc, i + 1);
  1961. atttypmod = rec->tupdesc->attrs[i]->atttypmod;
  1962. typetup = SearchSysCacheTuple(TYPOID,
  1963.  ObjectIdGetDatum(atttype), 0, 0, 0);
  1964. if (!HeapTupleIsValid(typetup))
  1965. elog(ERROR, "cache lookup for type %u failed", atttype);
  1966. typeStruct = (Form_pg_type) GETSTRUCT(typetup);
  1967. fmgr_info(typeStruct->typinput, &finfo_input);
  1969. attisnull = *isNull;
  1970. values[i] = exec_cast_value(value, valtype,
  1971.    atttype, &finfo_input, atttypmod, &attisnull);
  1972. if (attisnull)
  1973. nulls[i] = 'n';
  1974. else
  1975. nulls[i] = ' ';
  1976. }
  1978. /* ----------
  1979.  * Now call heap_formtuple() to create a new tuple
  1980.  * that replaces the old one in the record.
  1981.  * ----------
  1982.  */
  1983. nulls[i] = '';
  1984. rec->tup = heap_formtuple(rec->tupdesc, values, nulls);
  1985. pfree(values);
  1986. pfree(nulls);
  1988. break;
  1990. default:
  1991. elog(ERROR, "unknown dtype %d in exec_assign_value()",
  1992.  target->dtype);
  1993. }
  1994. }
  1997. /* ----------
  1998.  * exec_eval_expr Evaluate an expression and return
  1999.  * the result Datum.
  2000.  * ----------
  2001.  */
  2002. static Datum
  2003. exec_eval_expr(PLpgSQL_execstate * estate,
  2004.    PLpgSQL_expr * expr,
  2005.    bool *isNull,
  2006.    Oid *rettype)
  2007. {
  2008. int rc;
  2010. /* ----------
  2011.  * If not already done create a plan for this expression
  2012.  * ----------
  2013.  */
  2014. if (expr->plan == NULL)
  2015. exec_prepare_plan(estate, expr);
  2017. /* ----------
  2018.  * If this is a simple expression, bypass SPI and use the
  2019.  * executor directly
  2020.  * ----------
  2021.  */
  2022. if (expr->plan_simple_expr != NULL)
  2023. return exec_eval_simple_expr(estate, expr, isNull, rettype);
  2025. rc = exec_run_select(estate, expr, 2);
  2026. if (rc != SPI_OK_SELECT)
  2027. elog(ERROR, "query "%s" didn't return data", expr->query);
  2029. /* ----------
  2030.  * If there are no rows selected, the result is NULL.
  2031.  * ----------
  2032.  */
  2033. if (SPI_processed == 0)
  2034. {
  2035. *isNull = true;
  2036. return (Datum) 0;
  2037. }
  2039. /* ----------
  2040.  * Check that the expression returned one single Datum
  2041.  * ----------
  2042.  */
  2043. if (SPI_processed > 1)
  2044. elog(ERROR, "query "%s" didn't return a single value", expr->query);
  2045. if (SPI_tuptable->tupdesc->natts != 1)
  2046. elog(ERROR, "query "%s" didn't return a single value", expr->query);
  2048. /* ----------
  2049.  * Return the result and it's type
  2050.  * ----------
  2051.  */
  2052. *rettype = SPI_gettypeid(SPI_tuptable->tupdesc, 1);
  2053. return SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, isNull);
  2054. }
  2057. /* ----------
  2058.  * exec_run_select Execute a select query
  2059.  * ----------
  2060.  */
  2061. static int
  2062. exec_run_select(PLpgSQL_execstate * estate,
  2063. PLpgSQL_expr * expr, int maxtuples)
  2064. {
  2065. PLpgSQL_var *var;
  2066. PLpgSQL_rec *rec;
  2067. PLpgSQL_recfield *recfield;
  2068. PLpgSQL_trigarg *trigarg;
  2069. int tgargno;
  2070. Oid tgargoid;
  2071. int i;
  2072. Datum    *values;
  2073. char    *nulls;
  2074. int rc;
  2075. int fno;
  2076. bool isnull;
  2078. /* ----------
  2079.  * On the first call for this expression generate the plan
  2080.  * ----------
  2081.  */
  2082. if (expr->plan == NULL)
  2083. exec_prepare_plan(estate, expr);
  2085. /* ----------
  2086.  * Now build up the values and nulls arguments for SPI_execp()
  2087.  * ----------
  2088.  */
  2089. values = palloc(sizeof(Datum) * (expr->nparams + 1));
  2090. nulls = palloc(expr->nparams + 1);
  2092. for (i = 0; i < expr->nparams; i++)
  2093. {
  2094. switch (estate->datums[expr->params[i]]->dtype)
  2095. {
  2096. case PLPGSQL_DTYPE_VAR:
  2097. var = (PLpgSQL_var *) (estate->datums[expr->params[i]]);
  2098. values[i] = var->value;
  2099. if (var->isnull)
  2100. nulls[i] = 'n';
  2101. else
  2102. nulls[i] = ' ';
  2103. break;
  2105. case PLPGSQL_DTYPE_RECFIELD:
  2106. recfield = (PLpgSQL_recfield *) (estate->datums[expr->params[i]]);
  2107. rec = (PLpgSQL_rec *) (estate->datums[recfield->recno]);
  2109. if (!HeapTupleIsValid(rec->tup))
  2110. elog(ERROR, "record %s is unassigned yet", rec->refname);
  2111. fno = SPI_fnumber(rec->tupdesc, recfield->fieldname);
  2112. if (fno == SPI_ERROR_NOATTRIBUTE)
  2113. elog(ERROR, "record %s has no field %s", rec->refname, recfield->fieldname);
  2115. if (expr->plan_argtypes[i] != SPI_gettypeid(rec->tupdesc, fno))
  2116. elog(ERROR, "type of %s.%s doesn't match that when preparing the plan", rec->refname, recfield->fieldname);
  2118. values[i] = SPI_getbinval(rec->tup, rec->tupdesc, fno, &isnull);
  2119. if (isnull)
  2120. nulls[i] = 'n';
  2121. else
  2122. nulls[i] = ' ';
  2123. break;
  2125. case PLPGSQL_DTYPE_TRIGARG:
  2126. trigarg = (PLpgSQL_trigarg *) (estate->datums[expr->params[i]]);
  2127. tgargno = (int) exec_eval_expr(estate, trigarg->argnum,
  2128.    &isnull, &tgargoid);
  2129. if (isnull || tgargno < 0 || tgargno >= estate->trig_nargs)
  2130. {
  2131. values[i] = 0;
  2132. nulls[i] = 'n';
  2133. }
  2134. else
  2135. {
  2136. values[i] = estate->trig_argv[tgargno];
  2137. nulls[i] = ' ';
  2138. }
  2139. break;
  2141. default:
  2142. elog(ERROR, "unknown parameter dtype %d in exec_eval_expr()", estate->datums[expr->params[i]]);
  2143. }
  2144. }
  2145. nulls[i] = '';
  2147. /* ----------
  2148.  * Execute the query
  2149.  * ----------
  2150.  */
  2151. rc = SPI_execp(expr->plan, values, nulls, maxtuples);
  2152. if (rc != SPI_OK_SELECT)
  2153. elog(ERROR, "query "%s" isn't a SELECT", expr->query);
  2154. pfree(values);
  2155. pfree(nulls);
  2157. return rc;
  2158. }
  2161. /* ----------
  2162.  * exec_eval_simple_expr - Evaluate a simple expression returning
  2163.  * a Datum by directly calling ExecEvalExpr().
  2164.  * ----------
  2165.  */
  2166. static Datum
  2167. exec_eval_simple_expr(PLpgSQL_execstate * estate,
  2168.   PLpgSQL_expr * expr,
  2169.   bool *isNull,
  2170.   Oid *rettype)
  2171. {
  2172. Datum retval;
  2173. PLpgSQL_var *var;
  2174. PLpgSQL_rec *rec;
  2175. PLpgSQL_recfield *recfield;
  2176. PLpgSQL_trigarg *trigarg;
  2177. int tgargno;
  2178. Oid tgargoid;
  2179. int fno;
  2180. int i;
  2181. bool isnull;
  2182. bool isdone;
  2183. ExprContext *econtext;
  2184. ParamListInfo paramLI;
  2186. /* ----------
  2187.  * Create a simple expression context to hold the arguments
  2188.  * ----------
  2189.  */
  2190. econtext = makeNode(ExprContext);
  2191. paramLI = (ParamListInfo) palloc((expr->nparams + 1) *
  2192.  sizeof(ParamListInfoData));
  2193. econtext->ecxt_param_list_info = paramLI;
  2195. /* ----------
  2196.  * Put the parameter values into the parameter list info of
  2197.  * the expression context.
  2198.  * ----------
  2199.  */
  2200. for (i = 0; i < expr->nparams; i++, paramLI++)
  2201. {
  2202. paramLI->kind = PARAM_NUM;
  2203. paramLI->id = i + 1;
  2205. switch (estate->datums[expr->params[i]]->dtype)
  2206. {
  2207. case PLPGSQL_DTYPE_VAR:
  2208. var = (PLpgSQL_var *) (estate->datums[expr->params[i]]);
  2209. paramLI->isnull = var->isnull;
  2210. paramLI->value = var->value;
  2211. break;
  2213. case PLPGSQL_DTYPE_RECFIELD:
  2214. recfield = (PLpgSQL_recfield *) (estate->datums[expr->params[i]]);
  2215. rec = (PLpgSQL_rec *) (estate->datums[recfield->recno]);
  2217. if (!HeapTupleIsValid(rec->tup))
  2218. elog(ERROR, "record %s is unassigned yet", rec->refname);
  2219. fno = SPI_fnumber(rec->tupdesc, recfield->fieldname);
  2220. if (fno == SPI_ERROR_NOATTRIBUTE)
  2221. elog(ERROR, "record %s has no field %s", rec->refname, recfield->fieldname);
  2223. if (expr->plan_argtypes[i] != SPI_gettypeid(rec->tupdesc, fno))
  2224. elog(ERROR, "type of %s.%s doesn't match that when preparing the plan", rec->refname, recfield->fieldname);
  2226. paramLI->value = SPI_getbinval(rec->tup, rec->tupdesc, fno, &isnull);
  2227. paramLI->isnull = isnull;
  2228. break;
  2230. case PLPGSQL_DTYPE_TRIGARG:
  2231. trigarg = (PLpgSQL_trigarg *) (estate->datums[expr->params[i]]);
  2232. tgargno = (int) exec_eval_expr(estate, trigarg->argnum,
  2233.    &isnull, &tgargoid);
  2234. if (isnull || tgargno < 0 || tgargno >= estate->trig_nargs)
  2235. {
  2236. paramLI->value = 0;
  2237. paramLI->isnull = TRUE;
  2238. }
  2239. else
  2240. {
  2241. paramLI->value = estate->trig_argv[tgargno];
  2242. paramLI->isnull = FALSE;
  2243. }
  2244. break;
  2246. default:
  2247. elog(ERROR, "unknown parameter dtype %d in exec_eval_simple_expr()", estate->datums[expr->params[i]]->dtype);
  2248. }
  2249. }
  2250. paramLI->kind = PARAM_INVALID;
  2252. /* ----------
  2253.  * Initialize things
  2254.  * ----------
  2255.  */
  2256. *isNull = FALSE;
  2257. *rettype = expr->plan_simple_type;
  2258. isdone = FALSE;
  2260. /* ----------
  2261.  * Clear the function cache
  2262.  * ----------
  2263.  */
  2264. exec_eval_clear_fcache(expr->plan_simple_expr);
  2266. /* ----------
  2267.  * Now call the executor to evaluate the expression
  2268.  * ----------
  2269.  */
  2270. SPI_push();
  2271. retval = ExecEvalExpr(expr->plan_simple_expr,
  2272.   econtext,
  2273.   isNull,
  2274.   &isdone);
  2275. SPI_pop();
  2277. /* ----------
  2278.  * That's it.
  2279.  * ----------
  2280.  */
  2281. return retval;
  2282. }
  2285. /* ----------
  2286.  * exec_move_row Move one tuples values into a
  2287.  * record or row
  2288.  * ----------
  2289.  */
  2290. static void
  2291. exec_move_row(PLpgSQL_execstate * estate,
  2292.   PLpgSQL_rec * rec,
  2293.   PLpgSQL_row * row,
  2294.   HeapTuple tup, TupleDesc tupdesc)
  2295. {
  2296. PLpgSQL_var *var;
  2297. int i;
  2298. Datum value;
  2299. Oid valtype;
  2300. bool isnull;
  2302. /* ----------
  2303.  * Record is simple - just put the tuple and it's descriptor
  2304.  * into the record
  2305.  * ----------
  2306.  */
  2307. if (rec != NULL)
  2308. {
  2309. if (HeapTupleIsValid(tup))
  2310. {
  2311. rec->tup = tup;
  2312. rec->tupdesc = tupdesc;
  2313. }
  2314. else
  2315. {
  2316. rec->tup = NULL;
  2317. rec->tupdesc = NULL;
  2318. }
  2320. return;
  2321. }
  2324. /* ----------
  2325.  * Row is a bit more complicated in that we assign the single
  2326.  * attributes of the query to the variables the row points to.
  2327.  * ----------
  2328.  */
  2329. if (row != NULL)
  2330. {
  2331. if (HeapTupleIsValid(tup))
  2332. {
  2333. if (row->nfields != tupdesc->natts)
  2334. {
  2335. elog(ERROR, "query didn't return correct # of attributes for %s",
  2336.  row->refname);
  2337. }
  2339. for (i = 0; i < row->nfields; i++)
  2340. {
  2341. var = (PLpgSQL_var *) (estate->datums[row->varnos[i]]);
  2343. valtype = SPI_gettypeid(tupdesc, i + 1);
  2344. value = SPI_getbinval(tup, tupdesc, i + 1, &isnull);
  2345. exec_assign_value(estate, estate->datums[row->varnos[i]],
  2346.   value, valtype, &isnull);
  2348. }
  2349. }
  2350. else
  2351. {
  2352. for (i = 0; i < row->nfields; i++)
  2353. {
  2354. bool nullval = true;
  2356. exec_assign_value(estate, estate->datums[row->varnos[i]],
  2357.   (Datum) 0, 0, &nullval);
  2358. }
  2359. }
  2361. return;
  2362. }
  2364. elog(ERROR, "unsupported target in exec_move_row()");
  2365. }
  2368. /* ----------
  2369.  * exec_cast_value Cast a value if required
  2370.  * ----------
  2371.  */
  2372. static Datum
  2373. exec_cast_value(Datum value, Oid valtype,
  2374. Oid reqtype,
  2375. FmgrInfo *reqinput,
  2376. int16 reqtypmod,
  2377. bool *isnull)
  2378. {
  2379. if (!*isnull)
  2380. {
  2381. /* ----------
  2382.  * If the type of the queries return value isn't
  2383.  * that of the variable, convert it.
  2384.  * ----------
  2385.  */
  2386. if (valtype != reqtype || reqtypmod > 0)
  2387. {
  2388. HeapTuple typetup;
  2389. Form_pg_type typeStruct;
  2390. FmgrInfo finfo_output;
  2391. char    *extval;
  2393. typetup = SearchSysCacheTuple(TYPOID,
  2394.  ObjectIdGetDatum(valtype), 0, 0, 0);
  2395. if (!HeapTupleIsValid(typetup))
  2396. elog(ERROR, "cache lookup for type %u failed", valtype);
  2397. typeStruct = (Form_pg_type) GETSTRUCT(typetup);
  2399. fmgr_info(typeStruct->typoutput, &finfo_output);
  2400. extval = (char *) (*fmgr_faddr(&finfo_output)) (value, &isnull, -1);
  2401. value = (Datum) (*fmgr_faddr(reqinput)) (extval, &isnull, reqtypmod);
  2402. }
  2403. }
  2405. return value;
  2406. }
  2409. /* ----------
  2410.  * exec_simple_check_node - Recursively check if an expression
  2411.  * is made only of simple things we can
  2412.  * hand out directly to ExecEvalExpr()
  2413.  * instead of calling SPI.
  2414.  * ----------
  2415.  */
  2416. static bool
  2417. exec_simple_check_node(Node *node)
  2418. {
  2419. switch (nodeTag(node))
  2420. {
  2421. case T_Expr:
  2422. {
  2423. Expr    *expr = (Expr *) node;
  2424. List    *l;
  2426. switch (expr->opType)
  2427. {
  2428. case OP_EXPR:
  2429. case FUNC_EXPR:
  2430. case OR_EXPR:
  2431. case AND_EXPR:
  2432. case NOT_EXPR:
  2433. break;
  2435. default:
  2436. return FALSE;
  2437. }
  2439. foreach(l, expr->args)
  2440. {
  2441. if (!exec_simple_check_node(lfirst(l)))
  2442. return FALSE;
  2443. }
  2445. return TRUE;
  2446. }
  2448. case T_Param:
  2449. return TRUE;
  2451. case T_Const:
  2452. return TRUE;
  2454. default:
  2455. return FALSE;
  2456. }
  2457. }
  2460. /* ----------
  2461.  * exec_simple_check_plan - Check if a plan is simple enough to
  2462.  * be evaluated by ExecEvalExpr() instead
  2463.  * of SPI.
  2464.  * ----------
  2465.  */
  2466. static void
  2467. exec_simple_check_plan(PLpgSQL_expr * expr)
  2468. {
  2469. _SPI_plan  *spi_plan = (_SPI_plan *) expr->plan;
  2470. Plan    *plan;
  2471. TargetEntry *tle;
  2473. expr->plan_simple_expr = NULL;
  2475. /* ----------
  2476.  * 1. We can only evaluate queries that resulted in one single
  2477.  *   execution plan
  2478.  * ----------
  2479.  */
  2480. if (length(spi_plan->ptlist) != 1)
  2481. return;
  2483. plan = (Plan *) lfirst(spi_plan->ptlist);
  2485. /* ----------
  2486.  * 2. It must be a RESULT plan --> no scan's required
  2487.  * ----------
  2488.  */
  2489. if (plan == NULL) /* utility statement produces this */
  2490. return;
  2492. if (nodeTag(plan) != T_Result)
  2493. return;
  2495. /* ----------
  2496.  * 3. The plan must have a single attribute as result
  2497.  * ----------
  2498.  */
  2499. if (length(plan->targetlist) != 1)
  2500. return;
  2502. /* ----------
  2503.  * 4. Don't know if all these can break us, so let SPI handle
  2504.  *   those plans
  2505.  * ----------
  2506.  */
  2507. if (plan->qual != NULL || plan->lefttree != NULL || plan->righttree != NULL)
  2508. return;
  2510. /* ----------
  2511.  * 5. Check that all the nodes in the expression are one of
  2512.  *   Expr, Param or Const.
  2513.  * ----------
  2514.  */
  2515. tle = (TargetEntry *) lfirst(plan->targetlist);
  2516. if (!exec_simple_check_node(tle->expr))
  2517. return;
  2519. /* ----------
  2520.  * Yes - this is a simple expression. Remember the expression
  2521.  * and the return type
  2522.  * ----------
  2523.  */
  2524. expr->plan_simple_expr = tle->expr;
  2526. switch (nodeTag(tle->expr))
  2527. {
  2528. case T_Expr:
  2529. expr->plan_simple_type =
  2530. ((Expr *) (tle->expr))->typeOid;
  2531. break;
  2533. case T_Param:
  2534. expr->plan_simple_type =
  2535. ((Param *) (tle->expr))->paramtype;
  2536. break;
  2538. case T_Const:
  2539. expr->plan_simple_type = ((Const *) (tle->expr))->consttype;
  2540. break;
  2542. default:
  2543. expr->plan_simple_type = InvalidOid;
  2544. }
  2546. return;
  2547. }
  2550. /* ----------
  2551.  * exec_eval_clear_fcache - The function cache is palloc()'d by
  2552.  * the executor, and contains call specific
  2553.  * data based on the arguments. This has
  2554.  * to be recalculated.
  2555.  * ----------
  2556.  */
  2557. static void
  2558. exec_eval_clear_fcache(Node *node)
  2559. {
  2560. Expr    *expr;
  2561. List    *l;
  2563. if (nodeTag(node) != T_Expr)
  2564. return;
  2566. expr = (Expr *) node;
  2568. switch (expr->opType)
  2569. {
  2570. case OP_EXPR:
  2571. ((Oper *) (expr->oper))->op_fcache = NULL;
  2572. break;
  2574. case FUNC_EXPR:
  2575. ((Func *) (expr->oper))->func_fcache = NULL;
  2576. break;
  2578. default:
  2579. break;
  2580. }
  2582. foreach(l, expr->args)
  2583. exec_eval_clear_fcache(lfirst(l));
  2584. }
  2587. /* ----------
  2588.  * exec_set_found Set the global found variable
  2589.  * to true/false
  2590.  * ----------
  2591.  */
  2592. static void
  2593. exec_set_found(PLpgSQL_execstate * estate, bool state)
  2594. {
  2595. PLpgSQL_var *var;
  2597. var = (PLpgSQL_var *) (estate->datums[estate->found_varno]);
  2598. var->value = (Datum) state;
  2599. var->isnull = false;
  2600. }