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

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

数据库系统

开发平台：

Unix_Linux

trigger.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * trigger.c
  4.  *   PostgreSQL TRIGGERs support code.
  5.  *
  6.  *-------------------------------------------------------------------------
  7.  */
  8. #include "postgres.h"
  11. #include "access/genam.h"
  12. #include "access/heapam.h"
  13. #include "catalog/catalog.h"
  14. #include "catalog/catname.h"
  15. #include "catalog/indexing.h"
  16. #include "catalog/pg_language.h"
  17. #include "catalog/pg_proc.h"
  18. #include "catalog/pg_trigger.h"
  19. #include "commands/trigger.h"
  20. #include "executor/executor.h"
  21. #include "miscadmin.h"
  22. #include "utils/acl.h"
  23. #include "utils/builtins.h"
  24. #include "utils/inval.h"
  25. #include "utils/syscache.h"
  27. DLLIMPORT TriggerData *CurrentTriggerData = NULL;
  29. void RelationBuildTriggers(Relation relation);
  30. void FreeTriggerDesc(Relation relation);
  32. static void DescribeTrigger(TriggerDesc *trigdesc, Trigger *trigger);
  33. static HeapTuple GetTupleForTrigger(EState *estate, ItemPointer tid,
  34.    TupleTableSlot **newSlot);
  36. extern GlobalMemory CacheCxt;
  38. void
  39. CreateTrigger(CreateTrigStmt *stmt)
  40. {
  41. int16 tgtype;
  42. int16 tgattr[8] = {0};
  43. Datum values[Natts_pg_trigger];
  44. char nulls[Natts_pg_trigger];
  45. Relation rel;
  46. Relation tgrel;
  47. HeapScanDesc tgscan;
  48. ScanKeyData key;
  49. Relation pgrel;
  50. HeapTuple tuple;
  51. Relation idescs[Num_pg_trigger_indices];
  52. Relation ridescs[Num_pg_class_indices];
  53. MemoryContext oldcxt;
  54. Oid fargtypes[8];
  55. int found = 0;
  56. int i;
  58. if (!allowSystemTableMods && IsSystemRelationName(stmt->relname))
  59. elog(ERROR, "CreateTrigger: can't create trigger for system relation %s", stmt->relname);
  61. #ifndef NO_SECURITY
  62. if (!pg_ownercheck(GetPgUserName(), stmt->relname, RELNAME))
  63. elog(ERROR, "%s: %s", stmt->relname, aclcheck_error_strings[ACLCHECK_NOT_OWNER]);
  64. #endif
  66. rel = heap_openr(stmt->relname);
  67. if (!RelationIsValid(rel))
  68. elog(ERROR, "CreateTrigger: there is no relation %s", stmt->relname);
  70. LockRelation(rel, AccessExclusiveLock);
  72. TRIGGER_CLEAR_TYPE(tgtype);
  73. if (stmt->before)
  74. TRIGGER_SETT_BEFORE(tgtype);
  75. if (stmt->row)
  76. TRIGGER_SETT_ROW(tgtype);
  77. else
  78. elog(ERROR, "CreateTrigger: STATEMENT triggers are unimplemented, yet");
  80. for (i = 0; i < 3 && stmt->actions[i]; i++)
  81. {
  82. switch (stmt->actions[i])
  83. {
  84. case 'i':
  85. if (TRIGGER_FOR_INSERT(tgtype))
  86. elog(ERROR, "CreateTrigger: double INSERT event specified");
  87. TRIGGER_SETT_INSERT(tgtype);
  88. break;
  89. case 'd':
  90. if (TRIGGER_FOR_DELETE(tgtype))
  91. elog(ERROR, "CreateTrigger: double DELETE event specified");
  92. TRIGGER_SETT_DELETE(tgtype);
  93. break;
  94. case 'u':
  95. if (TRIGGER_FOR_UPDATE(tgtype))
  96. elog(ERROR, "CreateTrigger: double UPDATE event specified");
  97. TRIGGER_SETT_UPDATE(tgtype);
  98. break;
  99. default:
  100. elog(ERROR, "CreateTrigger: unknown event specified");
  101. break;
  102. }
  103. }
  105. /* Scan pg_trigger */
  106. tgrel = heap_openr(TriggerRelationName);
  107. LockRelation(tgrel, AccessExclusiveLock);
  108. ScanKeyEntryInitialize(&key, 0, Anum_pg_trigger_tgrelid,
  109.    F_OIDEQ, RelationGetRelid(rel));
  110. tgscan = heap_beginscan(tgrel, 0, SnapshotNow, 1, &key);
  111. while (HeapTupleIsValid(tuple = heap_getnext(tgscan, 0)))
  112. {
  113. Form_pg_trigger pg_trigger = (Form_pg_trigger) GETSTRUCT(tuple);
  115. if (namestrcmp(&(pg_trigger->tgname), stmt->trigname) == 0)
  116. elog(ERROR, "CreateTrigger: trigger %s already defined on relation %s",
  117.  stmt->trigname, stmt->relname);
  118. else
  119. found++;
  120. }
  121. heap_endscan(tgscan);
  123. MemSet(fargtypes, 0, 8 * sizeof(Oid));
  124. tuple = SearchSysCacheTuple(PRONAME,
  125. PointerGetDatum(stmt->funcname),
  126. Int32GetDatum(0),
  127. PointerGetDatum(fargtypes),
  128. 0);
  129. if (!HeapTupleIsValid(tuple) ||
  130. ((Form_pg_proc) GETSTRUCT(tuple))->pronargs != 0)
  131. elog(ERROR, "CreateTrigger: function %s() does not exist",
  132.  stmt->funcname);
  133. if (((Form_pg_proc) GETSTRUCT(tuple))->prorettype != 0)
  134. elog(ERROR, "CreateTrigger: function %s() must return OPAQUE",
  135.  stmt->funcname);
  136. if (((Form_pg_proc) GETSTRUCT(tuple))->prolang != ClanguageId)
  137. {
  138. HeapTuple langTup;
  140. langTup = SearchSysCacheTuple(LANOID,
  141. ObjectIdGetDatum(((Form_pg_proc) GETSTRUCT(tuple))->prolang),
  142.   0, 0, 0);
  143. if (!HeapTupleIsValid(langTup))
  144. elog(ERROR, "CreateTrigger: cache lookup for PL failed");
  146. if (((Form_pg_language) GETSTRUCT(langTup))->lanispl == false)
  147. elog(ERROR, "CreateTrigger: only C and PL functions are supported");
  148. }
  150. MemSet(nulls, ' ', Natts_pg_trigger * sizeof(char));
  152. values[Anum_pg_trigger_tgrelid - 1] = ObjectIdGetDatum(RelationGetRelid(rel));
  153. values[Anum_pg_trigger_tgname - 1] = NameGetDatum(namein(stmt->trigname));
  154. values[Anum_pg_trigger_tgfoid - 1] = ObjectIdGetDatum(tuple->t_data->t_oid);
  155. values[Anum_pg_trigger_tgtype - 1] = Int16GetDatum(tgtype);
  156. if (stmt->args)
  157. {
  158. List    *le;
  159. char    *args;
  160. int16 nargs = length(stmt->args);
  161. int len = 0;
  163. foreach(le, stmt->args)
  164. {
  165. char    *ar = (char *) lfirst(le);
  167. len += strlen(ar) + VARHDRSZ;
  168. for (; *ar; ar++)
  169. {
  170. if (*ar == '\')
  171. len++;
  172. }
  173. }
  174. args = (char *) palloc(len + 1);
  175. args[0] = 0;
  176. foreach(le, stmt->args)
  177. {
  178. char    *s = (char *) lfirst(le);
  179. char    *d = args + strlen(args);
  181. while (*s)
  182. {
  183. if (*s == '\')
  184. *d++ = '\';
  185. *d++ = *s++;
  186. }
  187. *d = 0;
  188. strcat(args, "\000");
  189. }
  190. values[Anum_pg_trigger_tgnargs - 1] = Int16GetDatum(nargs);
  191. values[Anum_pg_trigger_tgargs - 1] = PointerGetDatum(byteain(args));
  192. }
  193. else
  194. {
  195. values[Anum_pg_trigger_tgnargs - 1] = Int16GetDatum(0);
  196. values[Anum_pg_trigger_tgargs - 1] = PointerGetDatum(byteain(""));
  197. }
  198. values[Anum_pg_trigger_tgattr - 1] = PointerGetDatum(tgattr);
  200. tuple = heap_formtuple(tgrel->rd_att, values, nulls);
  201. heap_insert(tgrel, tuple);
  202. CatalogOpenIndices(Num_pg_trigger_indices, Name_pg_trigger_indices, idescs);
  203. CatalogIndexInsert(idescs, Num_pg_trigger_indices, tgrel, tuple);
  204. CatalogCloseIndices(Num_pg_trigger_indices, idescs);
  205. pfree(tuple);
  206. UnlockRelation(tgrel, AccessExclusiveLock);
  207. heap_close(tgrel);
  209. pfree(DatumGetPointer(values[Anum_pg_trigger_tgname - 1]));
  210. pfree(DatumGetPointer(values[Anum_pg_trigger_tgargs - 1]));
  212. /* update pg_class */
  213. tuple = SearchSysCacheTupleCopy(RELNAME,
  214. PointerGetDatum(stmt->relname),
  215. 0, 0, 0);
  216. if (!HeapTupleIsValid(tuple))
  217. elog(ERROR, "CreateTrigger: relation %s not found in pg_class", stmt->relname);
  219. pgrel = heap_openr(RelationRelationName);
  220. ((Form_pg_class) GETSTRUCT(tuple))->reltriggers = found + 1;
  221. RelationInvalidateHeapTuple(pgrel, tuple);
  222. heap_replace(pgrel, &tuple->t_self, tuple, NULL);
  223. CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices, ridescs);
  224. CatalogIndexInsert(ridescs, Num_pg_class_indices, pgrel, tuple);
  225. CatalogCloseIndices(Num_pg_class_indices, ridescs);
  226. pfree(tuple);
  227. heap_close(pgrel);
  229. CommandCounterIncrement();
  230. oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
  231. FreeTriggerDesc(rel);
  232. rel->rd_rel->reltriggers = found + 1;
  233. RelationBuildTriggers(rel);
  234. MemoryContextSwitchTo(oldcxt);
  235. heap_close(rel);
  236. return;
  237. }
  239. void
  240. DropTrigger(DropTrigStmt *stmt)
  241. {
  242. Relation rel;
  243. Relation tgrel;
  244. HeapScanDesc tgscan;
  245. ScanKeyData key;
  246. Relation pgrel;
  247. HeapTuple tuple;
  248. Relation ridescs[Num_pg_class_indices];
  249. MemoryContext oldcxt;
  250. int found = 0;
  251. int tgfound = 0;
  253. #ifndef NO_SECURITY
  254. if (!pg_ownercheck(GetPgUserName(), stmt->relname, RELNAME))
  255. elog(ERROR, "%s: %s", stmt->relname, aclcheck_error_strings[ACLCHECK_NOT_OWNER]);
  256. #endif
  258. rel = heap_openr(stmt->relname);
  259. if (!RelationIsValid(rel))
  260. elog(ERROR, "DropTrigger: there is no relation %s", stmt->relname);
  262. LockRelation(rel, AccessExclusiveLock);
  264. tgrel = heap_openr(TriggerRelationName);
  265. LockRelation(tgrel, AccessExclusiveLock);
  266. ScanKeyEntryInitialize(&key, 0, Anum_pg_trigger_tgrelid,
  267.    F_OIDEQ, RelationGetRelid(rel));
  268. tgscan = heap_beginscan(tgrel, 0, SnapshotNow, 1, &key);
  269. while (HeapTupleIsValid(tuple = heap_getnext(tgscan, 0)))
  270. {
  271. Form_pg_trigger pg_trigger = (Form_pg_trigger) GETSTRUCT(tuple);
  273. if (namestrcmp(&(pg_trigger->tgname), stmt->trigname) == 0)
  274. {
  275. heap_delete(tgrel, &tuple->t_self, NULL);
  276. tgfound++;
  277. }
  278. else
  279. found++;
  280. }
  281. if (tgfound == 0)
  282. elog(ERROR, "DropTrigger: there is no trigger %s on relation %s",
  283.  stmt->trigname, stmt->relname);
  284. if (tgfound > 1)
  285. elog(NOTICE, "DropTrigger: found (and deleted) %d trigger %s on relation %s",
  286.  tgfound, stmt->trigname, stmt->relname);
  287. heap_endscan(tgscan);
  288. UnlockRelation(tgrel, AccessExclusiveLock);
  289. heap_close(tgrel);
  291. tuple = SearchSysCacheTupleCopy(RELNAME,
  292. PointerGetDatum(stmt->relname),
  293. 0, 0, 0);
  294. if (!HeapTupleIsValid(tuple))
  295. elog(ERROR, "DropTrigger: relation %s not found in pg_class", stmt->relname);
  297. /* update pg_class */
  298. pgrel = heap_openr(RelationRelationName);
  299. ((Form_pg_class) GETSTRUCT(tuple))->reltriggers = found;
  300. RelationInvalidateHeapTuple(pgrel, tuple);
  301. heap_replace(pgrel, &tuple->t_self, tuple, NULL);
  302. CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices, ridescs);
  303. CatalogIndexInsert(ridescs, Num_pg_class_indices, pgrel, tuple);
  304. CatalogCloseIndices(Num_pg_class_indices, ridescs);
  305. pfree(tuple);
  306. heap_close(pgrel);
  308. CommandCounterIncrement();
  309. oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
  310. FreeTriggerDesc(rel);
  311. rel->rd_rel->reltriggers = found;
  312. if (found > 0)
  313. RelationBuildTriggers(rel);
  314. MemoryContextSwitchTo(oldcxt);
  315. heap_close(rel);
  316. return;
  317. }
  319. void
  320. RelationRemoveTriggers(Relation rel)
  321. {
  322. Relation tgrel;
  323. HeapScanDesc tgscan;
  324. ScanKeyData key;
  325. HeapTuple tup;
  327. tgrel = heap_openr(TriggerRelationName);
  328. LockRelation(tgrel, AccessExclusiveLock);
  329. ScanKeyEntryInitialize(&key, 0, Anum_pg_trigger_tgrelid,
  330.    F_OIDEQ, RelationGetRelid(rel));
  332. tgscan = heap_beginscan(tgrel, 0, SnapshotNow, 1, &key);
  334. while (HeapTupleIsValid(tup = heap_getnext(tgscan, 0)))
  335. heap_delete(tgrel, &tup->t_self, NULL);
  337. heap_endscan(tgscan);
  338. UnlockRelation(tgrel, AccessExclusiveLock);
  339. heap_close(tgrel);
  341. }
  343. void
  344. RelationBuildTriggers(Relation relation)
  345. {
  346. TriggerDesc *trigdesc = (TriggerDesc *) palloc(sizeof(TriggerDesc));
  347. int ntrigs = relation->rd_rel->reltriggers;
  348. Trigger    *triggers = NULL;
  349. Trigger    *build;
  350. Relation tgrel;
  351. Form_pg_trigger pg_trigger;
  352. Relation irel;
  353. ScanKeyData skey;
  354. HeapTupleData tuple;
  355. IndexScanDesc sd;
  356. RetrieveIndexResult indexRes;
  357. Buffer buffer;
  358. struct varlena *val;
  359. bool isnull;
  360. int found;
  362. MemSet(trigdesc, 0, sizeof(TriggerDesc));
  364. ScanKeyEntryInitialize(&skey,
  365.    (bits16) 0x0,
  366.    (AttrNumber) 1,
  367.    (RegProcedure) F_OIDEQ,
  368.    ObjectIdGetDatum(RelationGetRelid(relation)));
  370. tgrel = heap_openr(TriggerRelationName);
  371. irel = index_openr(TriggerRelidIndex);
  372. sd = index_beginscan(irel, false, 1, &skey);
  374. for (found = 0;;)
  375. {
  376. indexRes = index_getnext(sd, ForwardScanDirection);
  377. if (!indexRes)
  378. break;
  380. tuple.t_self = indexRes->heap_iptr;
  381. heap_fetch(tgrel, SnapshotNow, &tuple, &buffer);
  382. pfree(indexRes);
  383. if (!tuple.t_data)
  384. continue;
  385. if (found == ntrigs)
  386. elog(ERROR, "RelationBuildTriggers: unexpected record found for rel %.*s",
  387.  NAMEDATALEN, relation->rd_rel->relname.data);
  389. pg_trigger = (Form_pg_trigger) GETSTRUCT(&tuple);
  391. if (triggers == NULL)
  392. triggers = (Trigger *) palloc(sizeof(Trigger));
  393. else
  394. triggers = (Trigger *) repalloc(triggers, (found + 1) * sizeof(Trigger));
  395. build = &(triggers[found]);
  397. build->tgname = nameout(&(pg_trigger->tgname));
  398. build->tgfoid = pg_trigger->tgfoid;
  399. build->tgfunc.fn_addr = NULL;
  400. build->tgtype = pg_trigger->tgtype;
  401. build->tgnargs = pg_trigger->tgnargs;
  402. memcpy(build->tgattr, &(pg_trigger->tgattr), 8 * sizeof(int16));
  403. val = (struct varlena *) fastgetattr(&tuple,
  404.  Anum_pg_trigger_tgargs,
  405.  tgrel->rd_att, &isnull);
  406. if (isnull)
  407. elog(ERROR, "RelationBuildTriggers: tgargs IS NULL for rel %.*s",
  408.  NAMEDATALEN, relation->rd_rel->relname.data);
  409. if (build->tgnargs > 0)
  410. {
  411. char    *p;
  412. int i;
  414. val = (struct varlena *) fastgetattr(&tuple,
  415.  Anum_pg_trigger_tgargs,
  416.  tgrel->rd_att, &isnull);
  417. if (isnull)
  418. elog(ERROR, "RelationBuildTriggers: tgargs IS NULL for rel %.*s",
  419.  NAMEDATALEN, relation->rd_rel->relname.data);
  420. p = (char *) VARDATA(val);
  421. build->tgargs = (char **) palloc(build->tgnargs * sizeof(char *));
  422. for (i = 0; i < build->tgnargs; i++)
  423. {
  424. build->tgargs[i] = (char *) palloc(strlen(p) + 1);
  425. strcpy(build->tgargs[i], p);
  426. p += strlen(p) + 1;
  427. }
  428. }
  429. else
  430. build->tgargs = NULL;
  432. found++;
  433. ReleaseBuffer(buffer);
  434. }
  436. if (found < ntrigs)
  437. elog(ERROR, "RelationBuildTriggers: %d record not found for rel %.*s",
  438.  ntrigs - found,
  439.  NAMEDATALEN, relation->rd_rel->relname.data);
  441. index_endscan(sd);
  442. pfree(sd);
  443. index_close(irel);
  444. heap_close(tgrel);
  446. /* Build trigdesc */
  447. trigdesc->triggers = triggers;
  448. for (found = 0; found < ntrigs; found++)
  449. {
  450. build = &(triggers[found]);
  451. DescribeTrigger(trigdesc, build);
  452. }
  454. relation->trigdesc = trigdesc;
  456. }
  458. void
  459. FreeTriggerDesc(Relation relation)
  460. {
  461. TriggerDesc *trigdesc = relation->trigdesc;
  462. Trigger  ***t;
  463. Trigger    *trigger;
  464. int i;
  466. if (trigdesc == NULL)
  467. return;
  469. t = trigdesc->tg_before_statement;
  470. for (i = 0; i < 3; i++)
  471. if (t[i] != NULL)
  472. pfree(t[i]);
  473. t = trigdesc->tg_before_row;
  474. for (i = 0; i < 3; i++)
  475. if (t[i] != NULL)
  476. pfree(t[i]);
  477. t = trigdesc->tg_after_row;
  478. for (i = 0; i < 3; i++)
  479. if (t[i] != NULL)
  480. pfree(t[i]);
  481. t = trigdesc->tg_after_statement;
  482. for (i = 0; i < 3; i++)
  483. if (t[i] != NULL)
  484. pfree(t[i]);
  486. trigger = trigdesc->triggers;
  487. for (i = 0; i < relation->rd_rel->reltriggers; i++)
  488. {
  489. pfree(trigger->tgname);
  490. if (trigger->tgnargs > 0)
  491. {
  492. while (--(trigger->tgnargs) >= 0)
  493. pfree(trigger->tgargs[trigger->tgnargs]);
  494. pfree(trigger->tgargs);
  495. }
  496. trigger++;
  497. }
  498. pfree(trigdesc->triggers);
  499. pfree(trigdesc);
  500. relation->trigdesc = NULL;
  501. return;
  502. }
  504. static void
  505. DescribeTrigger(TriggerDesc *trigdesc, Trigger *trigger)
  506. {
  507. uint16    *n;
  508. Trigger  ***t,
  509.  ***tp;
  511. if (TRIGGER_FOR_ROW(trigger->tgtype)) /* Is ROW/STATEMENT
  512.  * trigger */
  513. {
  514. if (TRIGGER_FOR_BEFORE(trigger->tgtype))
  515. {
  516. n = trigdesc->n_before_row;
  517. t = trigdesc->tg_before_row;
  518. }
  519. else
  520. {
  521. n = trigdesc->n_after_row;
  522. t = trigdesc->tg_after_row;
  523. }
  524. }
  525. else
  526. /* STATEMENT (NI) */
  527. {
  528. if (TRIGGER_FOR_BEFORE(trigger->tgtype))
  529. {
  530. n = trigdesc->n_before_statement;
  531. t = trigdesc->tg_before_statement;
  532. }
  533. else
  534. {
  535. n = trigdesc->n_after_statement;
  536. t = trigdesc->tg_after_statement;
  537. }
  538. }
  540. if (TRIGGER_FOR_INSERT(trigger->tgtype))
  541. {
  542. tp = &(t[TRIGGER_EVENT_INSERT]);
  543. if (*tp == NULL)
  544. *tp = (Trigger **) palloc(sizeof(Trigger *));
  545. else
  546. *tp = (Trigger **) repalloc(*tp, (n[TRIGGER_EVENT_INSERT] + 1) *
  547. sizeof(Trigger *));
  548. (*tp)[n[TRIGGER_EVENT_INSERT]] = trigger;
  549. (n[TRIGGER_EVENT_INSERT])++;
  550. }
  552. if (TRIGGER_FOR_DELETE(trigger->tgtype))
  553. {
  554. tp = &(t[TRIGGER_EVENT_DELETE]);
  555. if (*tp == NULL)
  556. *tp = (Trigger **) palloc(sizeof(Trigger *));
  557. else
  558. *tp = (Trigger **) repalloc(*tp, (n[TRIGGER_EVENT_DELETE] + 1) *
  559. sizeof(Trigger *));
  560. (*tp)[n[TRIGGER_EVENT_DELETE]] = trigger;
  561. (n[TRIGGER_EVENT_DELETE])++;
  562. }
  564. if (TRIGGER_FOR_UPDATE(trigger->tgtype))
  565. {
  566. tp = &(t[TRIGGER_EVENT_UPDATE]);
  567. if (*tp == NULL)
  568. *tp = (Trigger **) palloc(sizeof(Trigger *));
  569. else
  570. *tp = (Trigger **) repalloc(*tp, (n[TRIGGER_EVENT_UPDATE] + 1) *
  571. sizeof(Trigger *));
  572. (*tp)[n[TRIGGER_EVENT_UPDATE]] = trigger;
  573. (n[TRIGGER_EVENT_UPDATE])++;
  574. }
  576. }
  578. static HeapTuple
  579. ExecCallTriggerFunc(Trigger *trigger)
  580. {
  582. if (trigger->tgfunc.fn_addr == NULL)
  583. fmgr_info(trigger->tgfoid, &trigger->tgfunc);
  585. if (trigger->tgfunc.fn_plhandler != NULL)
  586. {
  587. return (HeapTuple) (*(trigger->tgfunc.fn_plhandler))
  588. (&trigger->tgfunc);
  589. }
  591. return (HeapTuple) ((*fmgr_faddr(&trigger->tgfunc)) ());
  592. }
  594. HeapTuple
  595. ExecBRInsertTriggers(Relation rel, HeapTuple trigtuple)
  596. {
  597. TriggerData *SaveTriggerData;
  598. int ntrigs = rel->trigdesc->n_before_row[TRIGGER_EVENT_INSERT];
  599. Trigger   **trigger = rel->trigdesc->tg_before_row[TRIGGER_EVENT_INSERT];
  600. HeapTuple newtuple = trigtuple;
  601. HeapTuple oldtuple;
  602. int i;
  604. SaveTriggerData = (TriggerData *) palloc(sizeof(TriggerData));
  605. SaveTriggerData->tg_event = TRIGGER_EVENT_INSERT | TRIGGER_EVENT_ROW | TRIGGER_EVENT_BEFORE;
  606. SaveTriggerData->tg_relation = rel;
  607. SaveTriggerData->tg_newtuple = NULL;
  608. for (i = 0; i < ntrigs; i++)
  609. {
  610. CurrentTriggerData = SaveTriggerData;
  611. CurrentTriggerData->tg_trigtuple = oldtuple = newtuple;
  612. CurrentTriggerData->tg_trigger = trigger[i];
  613. newtuple = ExecCallTriggerFunc(trigger[i]);
  614. if (newtuple == NULL)
  615. break;
  616. else if (oldtuple != newtuple && oldtuple != trigtuple)
  617. pfree(oldtuple);
  618. }
  619. CurrentTriggerData = NULL;
  620. pfree(SaveTriggerData);
  621. return newtuple;
  622. }
  624. void
  625. ExecARInsertTriggers(Relation rel, HeapTuple trigtuple)
  626. {
  627. TriggerData *SaveTriggerData;
  628. int ntrigs = rel->trigdesc->n_after_row[TRIGGER_EVENT_INSERT];
  629. Trigger   **trigger = rel->trigdesc->tg_after_row[TRIGGER_EVENT_INSERT];
  630. int i;
  632. SaveTriggerData = (TriggerData *) palloc(sizeof(TriggerData));
  633. SaveTriggerData->tg_event = TRIGGER_EVENT_INSERT | TRIGGER_EVENT_ROW;
  634. SaveTriggerData->tg_relation = rel;
  635. SaveTriggerData->tg_newtuple = NULL;
  636. for (i = 0; i < ntrigs; i++)
  637. {
  638. CurrentTriggerData = SaveTriggerData;
  639. CurrentTriggerData->tg_trigtuple = trigtuple;
  640. CurrentTriggerData->tg_trigger = trigger[i];
  641. ExecCallTriggerFunc(trigger[i]);
  642. }
  643. CurrentTriggerData = NULL;
  644. pfree(SaveTriggerData);
  645. return;
  646. }
  648. bool
  649. ExecBRDeleteTriggers(EState *estate, ItemPointer tupleid)
  650. {
  651. Relation rel = estate->es_result_relation_info->ri_RelationDesc;
  652. TriggerData *SaveTriggerData;
  653. int ntrigs = rel->trigdesc->n_before_row[TRIGGER_EVENT_DELETE];
  654. Trigger   **trigger = rel->trigdesc->tg_before_row[TRIGGER_EVENT_DELETE];
  655. HeapTuple trigtuple;
  656. HeapTuple newtuple = NULL;
  657. TupleTableSlot *newSlot;
  658. int i;
  660. trigtuple = GetTupleForTrigger(estate, tupleid, &newSlot);
  661. if (trigtuple == NULL)
  662. return false;
  664. SaveTriggerData = (TriggerData *) palloc(sizeof(TriggerData));
  665. SaveTriggerData->tg_event = TRIGGER_EVENT_DELETE | TRIGGER_EVENT_ROW | TRIGGER_EVENT_BEFORE;
  666. SaveTriggerData->tg_relation = rel;
  667. SaveTriggerData->tg_newtuple = NULL;
  668. for (i = 0; i < ntrigs; i++)
  669. {
  670. CurrentTriggerData = SaveTriggerData;
  671. CurrentTriggerData->tg_trigtuple = trigtuple;
  672. CurrentTriggerData->tg_trigger = trigger[i];
  673. newtuple = ExecCallTriggerFunc(trigger[i]);
  674. if (newtuple == NULL)
  675. break;
  676. if (newtuple != trigtuple)
  677. pfree(newtuple);
  678. }
  679. CurrentTriggerData = NULL;
  680. pfree(SaveTriggerData);
  681. pfree(trigtuple);
  683. return (newtuple == NULL) ? false : true;
  684. }
  686. void
  687. ExecARDeleteTriggers(EState *estate, ItemPointer tupleid)
  688. {
  689. Relation rel = estate->es_result_relation_info->ri_RelationDesc;
  690. TriggerData *SaveTriggerData;
  691. int ntrigs = rel->trigdesc->n_after_row[TRIGGER_EVENT_DELETE];
  692. Trigger   **trigger = rel->trigdesc->tg_after_row[TRIGGER_EVENT_DELETE];
  693. HeapTuple trigtuple;
  694. int i;
  696. trigtuple = GetTupleForTrigger(estate, tupleid, NULL);
  697. Assert(trigtuple != NULL);
  699. SaveTriggerData = (TriggerData *) palloc(sizeof(TriggerData));
  700. SaveTriggerData->tg_event = TRIGGER_EVENT_DELETE | TRIGGER_EVENT_ROW;
  701. SaveTriggerData->tg_relation = rel;
  702. SaveTriggerData->tg_newtuple = NULL;
  703. for (i = 0; i < ntrigs; i++)
  704. {
  705. CurrentTriggerData = SaveTriggerData;
  706. CurrentTriggerData->tg_trigtuple = trigtuple;
  707. CurrentTriggerData->tg_trigger = trigger[i];
  708. ExecCallTriggerFunc(trigger[i]);
  709. }
  710. CurrentTriggerData = NULL;
  711. pfree(SaveTriggerData);
  712. pfree(trigtuple);
  713. return;
  714. }
  716. HeapTuple
  717. ExecBRUpdateTriggers(EState *estate, ItemPointer tupleid, HeapTuple newtuple)
  718. {
  719. Relation rel = estate->es_result_relation_info->ri_RelationDesc;
  720. TriggerData *SaveTriggerData;
  721. int ntrigs = rel->trigdesc->n_before_row[TRIGGER_EVENT_UPDATE];
  722. Trigger   **trigger = rel->trigdesc->tg_before_row[TRIGGER_EVENT_UPDATE];
  723. HeapTuple trigtuple;
  724. HeapTuple oldtuple;
  725. HeapTuple intuple = newtuple;
  726. TupleTableSlot *newSlot;
  727. int i;
  729. trigtuple = GetTupleForTrigger(estate, tupleid, &newSlot);
  730. if (trigtuple == NULL)
  731. return NULL;
  733. /*
  734.  * In READ COMMITTED isolevel it's possible that newtuple was changed
  735.  * due to concurrent update.
  736.  */
  737. if (newSlot != NULL)
  738. intuple = newtuple = ExecRemoveJunk(estate->es_junkFilter, newSlot);
  740. SaveTriggerData = (TriggerData *) palloc(sizeof(TriggerData));
  741. SaveTriggerData->tg_event = TRIGGER_EVENT_UPDATE | TRIGGER_EVENT_ROW | TRIGGER_EVENT_BEFORE;
  742. SaveTriggerData->tg_relation = rel;
  743. for (i = 0; i < ntrigs; i++)
  744. {
  745. CurrentTriggerData = SaveTriggerData;
  746. CurrentTriggerData->tg_trigtuple = trigtuple;
  747. CurrentTriggerData->tg_newtuple = oldtuple = newtuple;
  748. CurrentTriggerData->tg_trigger = trigger[i];
  749. newtuple = ExecCallTriggerFunc(trigger[i]);
  750. if (newtuple == NULL)
  751. break;
  752. else if (oldtuple != newtuple && oldtuple != intuple)
  753. pfree(oldtuple);
  754. }
  755. CurrentTriggerData = NULL;
  756. pfree(SaveTriggerData);
  757. pfree(trigtuple);
  758. return newtuple;
  759. }
  761. void
  762. ExecARUpdateTriggers(EState *estate, ItemPointer tupleid, HeapTuple newtuple)
  763. {
  764. Relation rel = estate->es_result_relation_info->ri_RelationDesc;
  765. TriggerData *SaveTriggerData;
  766. int ntrigs = rel->trigdesc->n_after_row[TRIGGER_EVENT_UPDATE];
  767. Trigger   **trigger = rel->trigdesc->tg_after_row[TRIGGER_EVENT_UPDATE];
  768. HeapTuple trigtuple;
  769. int i;
  771. trigtuple = GetTupleForTrigger(estate, tupleid, NULL);
  772. Assert(trigtuple != NULL);
  774. SaveTriggerData = (TriggerData *) palloc(sizeof(TriggerData));
  775. SaveTriggerData->tg_event = TRIGGER_EVENT_UPDATE | TRIGGER_EVENT_ROW;
  776. SaveTriggerData->tg_relation = rel;
  777. for (i = 0; i < ntrigs; i++)
  778. {
  779. CurrentTriggerData = SaveTriggerData;
  780. CurrentTriggerData->tg_trigtuple = trigtuple;
  781. CurrentTriggerData->tg_newtuple = newtuple;
  782. CurrentTriggerData->tg_trigger = trigger[i];
  783. ExecCallTriggerFunc(trigger[i]);
  784. }
  785. CurrentTriggerData = NULL;
  786. pfree(SaveTriggerData);
  787. pfree(trigtuple);
  788. return;
  789. }
  791. extern TupleTableSlot *EvalPlanQual(EState *estate, Index rti, ItemPointer tid);
  793. static HeapTuple
  794. GetTupleForTrigger(EState *estate, ItemPointer tid, TupleTableSlot **newSlot)
  795. {
  796. Relation relation = estate->es_result_relation_info->ri_RelationDesc;
  797. HeapTupleData tuple;
  798. HeapTuple result;
  799. Buffer buffer;
  801. if (newSlot != NULL)
  802. {
  803. int test;
  805. /*
  806.  * mark tuple for update
  807.  */
  808. *newSlot = NULL;
  809. tuple.t_self = *tid;
  810. ltrmark:;
  811. test = heap_mark4update(relation, &tuple, &buffer);
  812. switch (test)
  813. {
  814. case HeapTupleSelfUpdated:
  815. ReleaseBuffer(buffer);
  816. return (NULL);
  818. case HeapTupleMayBeUpdated:
  819. break;
  821. case HeapTupleUpdated:
  822. ReleaseBuffer(buffer);
  823. if (XactIsoLevel == XACT_SERIALIZABLE)
  824. elog(ERROR, "Can't serialize access due to concurrent update");
  825. else if (!(ItemPointerEquals(&(tuple.t_self), tid)))
  826. {
  827. TupleTableSlot *epqslot = EvalPlanQual(estate,
  828.  estate->es_result_relation_info->ri_RangeTableIndex,
  829. &(tuple.t_self));
  831. if (!(TupIsNull(epqslot)))
  832. {
  833. *tid = tuple.t_self;
  834. *newSlot = epqslot;
  835. goto ltrmark;
  836. }
  837. }
  839. /*
  840.  * if tuple was deleted or PlanQual failed for updated
  841.  * tuple - we have not process this tuple!
  842.  */
  843. return (NULL);
  845. default:
  846. ReleaseBuffer(buffer);
  847. elog(ERROR, "Unknown status %u from heap_mark4update", test);
  848. return (NULL);
  849. }
  850. }
  851. else
  852. {
  853. PageHeader dp;
  854. ItemId lp;
  856. buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
  858. if (!BufferIsValid(buffer))
  859. elog(ERROR, "GetTupleForTrigger: failed ReadBuffer");
  861. dp = (PageHeader) BufferGetPage(buffer);
  862. lp = PageGetItemId(dp, ItemPointerGetOffsetNumber(tid));
  864. Assert(ItemIdIsUsed(lp));
  866. tuple.t_data = (HeapTupleHeader) PageGetItem((Page) dp, lp);
  867. tuple.t_len = ItemIdGetLength(lp);
  868. tuple.t_self = *tid;
  869. }
  871. result = heap_copytuple(&tuple);
  872. ReleaseBuffer(buffer);
  874. return result;
  875. }