[フレーム]

event_trigger.c

Go to the documentation of this file.

1/*-------------------------------------------------------------------------

2 *

3 * event_trigger.c

4 * PostgreSQL EVENT TRIGGER support code.

5 *

8 *

9 * IDENTIFICATION

10 * src/backend/commands/event_trigger.c

11 *

12 *-------------------------------------------------------------------------

13 */

14#include "postgres.h"

15

16#include "access/heapam.h"

17#include "access/htup_details.h"

18#include "access/table.h"

19#include "access/xact.h"

20#include "catalog/catalog.h"

21#include "catalog/dependency.h"

22#include "catalog/indexing.h"

23#include "catalog/objectaccess.h"

24#include "catalog/pg_attrdef.h"

25#include "catalog/pg_authid.h"

26#include "catalog/pg_auth_members.h"

27#include "catalog/pg_database.h"

28#include "catalog/pg_event_trigger.h"

29#include "catalog/pg_namespace.h"

30#include "catalog/pg_opclass.h"

31#include "catalog/pg_opfamily.h"

32#include "catalog/pg_parameter_acl.h"

33#include "catalog/pg_policy.h"

34#include "catalog/pg_proc.h"

35#include "catalog/pg_tablespace.h"

36#include "catalog/pg_trigger.h"

37#include "catalog/pg_ts_config.h"

38#include "catalog/pg_type.h"

39#include "commands/event_trigger.h"

40#include "commands/extension.h"

41#include "commands/trigger.h"

42#include "funcapi.h"

43#include "lib/ilist.h"

44#include "miscadmin.h"

45#include "parser/parse_func.h"

46#include "pgstat.h"

47#include "storage/lmgr.h"

48#include "tcop/deparse_utility.h"

49#include "tcop/utility.h"

50#include "utils/acl.h"

51#include "utils/builtins.h"

52#include "utils/evtcache.h"

53#include "utils/fmgroids.h"

54#include "utils/fmgrprotos.h"

55#include "utils/lsyscache.h"

56#include "utils/memutils.h"

57#include "utils/rel.h"

58#include "utils/snapmgr.h"

59#include "utils/syscache.h"

60

61 typedef struct EventTriggerQueryState

62{

63 /* memory context for this state's objects */

64 MemoryContext cxt;

65

66 /* sql_drop */

67 slist_head SQLDropList;

68 bool in_sql_drop;

69

70 /* table_rewrite */

71 Oid table_rewrite_oid; /* InvalidOid, or set for table_rewrite

72 * event */

73 int table_rewrite_reason; /* AT_REWRITE reason */

74

75 /* Support for command collection */

76 bool commandCollectionInhibited;

77 CollectedCommand *currentCommand;

78 List *commandList; /* list of CollectedCommand; see

79 * deparse_utility.h */

80 struct EventTriggerQueryState *previous;

81 } EventTriggerQueryState;

82

83 static EventTriggerQueryState *currentEventTriggerState = NULL;

84

85/* GUC parameter */

86 bool event_triggers = true;

87

88/* Support for dropped objects */

89 typedef struct SQLDropObject

90{

91 ObjectAddress address;

92 const char *schemaname;

93 const char *objname;

94 const char *objidentity;

95 const char *objecttype;

96 List *addrnames;

97 List *addrargs;

98 bool original;

99 bool normal;

100 bool istemp;

101 slist_node next;

102 } SQLDropObject;

103

104static void AlterEventTriggerOwner_internal(Relation rel,

105 HeapTuple tup,

106 Oid newOwnerId);

107static void error_duplicate_filter_variable(const char *defname);

108static Datum filter_list_to_array(List *filterlist);

109static Oid insert_event_trigger_tuple(const char *trigname, const char *eventname,

110 Oid evtOwner, Oid funcoid, List *taglist);

111static void validate_ddl_tags(const char *filtervar, List *taglist);

112static void validate_table_rewrite_tags(const char *filtervar, List *taglist);

113static void EventTriggerInvoke(List *fn_oid_list, EventTriggerData *trigdata);

114static bool obtain_object_name_namespace(const ObjectAddress *object,

115 SQLDropObject *obj);

116static const char *stringify_grant_objtype(ObjectType objtype);

117static const char *stringify_adefprivs_objtype(ObjectType objtype);

118static void SetDatabaseHasLoginEventTriggers(void);

119

120/*

121 * Create an event trigger.

122 */

123Oid

124 CreateEventTrigger(CreateEventTrigStmt *stmt)

125{

126 HeapTuple tuple;

127 Oid funcoid;

128 Oid funcrettype;

129 Oid evtowner = GetUserId();

130 ListCell *lc;

131 List *tags = NULL;

132

133 /*

134 * It would be nice to allow database owners or even regular users to do

135 * this, but there are obvious privilege escalation risks which would have

136 * to somehow be plugged first.

137 */

138 if (!superuser())

139 ereport(ERROR,

140 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),

141 errmsg("permission denied to create event trigger \"%s\"",

142 stmt->trigname),

143 errhint("Must be superuser to create an event trigger.")));

144

145 /* Validate event name. */

146 if (strcmp(stmt->eventname, "ddl_command_start") != 0 &&

147 strcmp(stmt->eventname, "ddl_command_end") != 0 &&

148 strcmp(stmt->eventname, "sql_drop") != 0 &&

149 strcmp(stmt->eventname, "login") != 0 &&

150 strcmp(stmt->eventname, "table_rewrite") != 0)

151 ereport(ERROR,

152 (errcode(ERRCODE_SYNTAX_ERROR),

153 errmsg("unrecognized event name \"%s\"",

154 stmt->eventname)));

155

156 /* Validate filter conditions. */

157 foreach(lc, stmt->whenclause)

158 {

159 DefElem *def = (DefElem *) lfirst(lc);

160

161 if (strcmp(def->defname, "tag") == 0)

162 {

163 if (tags != NULL)

164 error_duplicate_filter_variable(def->defname);

165 tags = (List *) def->arg;

166 }

167 else

168 ereport(ERROR,

169 (errcode(ERRCODE_SYNTAX_ERROR),

170 errmsg("unrecognized filter variable \"%s\"", def->defname)));

171 }

172

173 /* Validate tag list, if any. */

174 if ((strcmp(stmt->eventname, "ddl_command_start") == 0 ||

175 strcmp(stmt->eventname, "ddl_command_end") == 0 ||

176 strcmp(stmt->eventname, "sql_drop") == 0)

177 && tags != NULL)

178 validate_ddl_tags("tag", tags);

179 else if (strcmp(stmt->eventname, "table_rewrite") == 0

180 && tags != NULL)

181 validate_table_rewrite_tags("tag", tags);

182 else if (strcmp(stmt->eventname, "login") == 0 && tags != NULL)

183 ereport(ERROR,

184 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

185 errmsg("tag filtering is not supported for login event triggers")));

186

187 /*

188 * Give user a nice error message if an event trigger of the same name

189 * already exists.

190 */

191 tuple = SearchSysCache1(EVENTTRIGGERNAME, CStringGetDatum(stmt->trigname));

192 if (HeapTupleIsValid(tuple))

193 ereport(ERROR,

194 (errcode(ERRCODE_DUPLICATE_OBJECT),

195 errmsg("event trigger \"%s\" already exists",

196 stmt->trigname)));

197

198 /* Find and validate the trigger function. */

199 funcoid = LookupFuncName(stmt->funcname, 0, NULL, false);

200 funcrettype = get_func_rettype(funcoid);

201 if (funcrettype != EVENT_TRIGGEROID)

202 ereport(ERROR,

203 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

204 errmsg("function %s must return type %s",

205 NameListToString(stmt->funcname), "event_trigger")));

206

207 /* Insert catalog entries. */

208 return insert_event_trigger_tuple(stmt->trigname, stmt->eventname,

209 evtowner, funcoid, tags);

210}

211

212/*

213 * Validate DDL command tags.

214 */

215static void

216 validate_ddl_tags(const char *filtervar, List *taglist)

217{

218 ListCell *lc;

219

220 foreach(lc, taglist)

221 {

222 const char *tagstr = strVal(lfirst(lc));

223 CommandTag commandTag = GetCommandTagEnum(tagstr);

224

225 if (commandTag == CMDTAG_UNKNOWN)

226 ereport(ERROR,

227 (errcode(ERRCODE_SYNTAX_ERROR),

228 errmsg("filter value \"%s\" not recognized for filter variable \"%s\"",

229 tagstr, filtervar)));

230 if (!command_tag_event_trigger_ok(commandTag))

231 ereport(ERROR,

232 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

233 /* translator: %s represents an SQL statement name */

234 errmsg("event triggers are not supported for %s",

235 tagstr)));

236 }

237}

238

239/*

240 * Validate DDL command tags for event table_rewrite.

241 */

242static void

243 validate_table_rewrite_tags(const char *filtervar, List *taglist)

244{

245 ListCell *lc;

246

247 foreach(lc, taglist)

248 {

249 const char *tagstr = strVal(lfirst(lc));

250 CommandTag commandTag = GetCommandTagEnum(tagstr);

251

252 if (!command_tag_table_rewrite_ok(commandTag))

253 ereport(ERROR,

254 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

255 /* translator: %s represents an SQL statement name */

256 errmsg("event triggers are not supported for %s",

257 tagstr)));

258 }

259}

260

261/*

262 * Complain about a duplicate filter variable.

263 */

264static void

265 error_duplicate_filter_variable(const char *defname)

266{

267 ereport(ERROR,

268 (errcode(ERRCODE_SYNTAX_ERROR),

269 errmsg("filter variable \"%s\" specified more than once",

270 defname)));

271}

272

273/*

274 * Insert the new pg_event_trigger row and record dependencies.

275 */

276static Oid

277 insert_event_trigger_tuple(const char *trigname, const char *eventname, Oid evtOwner,

278 Oid funcoid, List *taglist)

279{

280 Relation tgrel;

281 Oid trigoid;

282 HeapTuple tuple;

283 Datum values[Natts_pg_event_trigger];

284 bool nulls[Natts_pg_event_trigger];

285 NameData evtnamedata,

286 evteventdata;

287 ObjectAddress myself,

288 referenced;

289

290 /* Open pg_event_trigger. */

291 tgrel = table_open(EventTriggerRelationId, RowExclusiveLock);

292

293 /* Build the new pg_trigger tuple. */

294 trigoid = GetNewOidWithIndex(tgrel, EventTriggerOidIndexId,

295 Anum_pg_event_trigger_oid);

296 values[Anum_pg_event_trigger_oid - 1] = ObjectIdGetDatum(trigoid);

297 memset(nulls, false, sizeof(nulls));

298 namestrcpy(&evtnamedata, trigname);

299 values[Anum_pg_event_trigger_evtname - 1] = NameGetDatum(&evtnamedata);

300 namestrcpy(&evteventdata, eventname);

301 values[Anum_pg_event_trigger_evtevent - 1] = NameGetDatum(&evteventdata);

302 values[Anum_pg_event_trigger_evtowner - 1] = ObjectIdGetDatum(evtOwner);

303 values[Anum_pg_event_trigger_evtfoid - 1] = ObjectIdGetDatum(funcoid);

304 values[Anum_pg_event_trigger_evtenabled - 1] =

305 CharGetDatum(TRIGGER_FIRES_ON_ORIGIN);

306 if (taglist == NIL)

307 nulls[Anum_pg_event_trigger_evttags - 1] = true;

308 else

309 values[Anum_pg_event_trigger_evttags - 1] =

310 filter_list_to_array(taglist);

311

312 /* Insert heap tuple. */

313 tuple = heap_form_tuple(tgrel->rd_att, values, nulls);

314 CatalogTupleInsert(tgrel, tuple);

315 heap_freetuple(tuple);

316

317 /*

318 * Login event triggers have an additional flag in pg_database to enable

319 * faster lookups in hot codepaths. Set the flag unless already True.

320 */

321 if (strcmp(eventname, "login") == 0)

322 SetDatabaseHasLoginEventTriggers();

323

324 /* Depend on owner. */

325 recordDependencyOnOwner(EventTriggerRelationId, trigoid, evtOwner);

326

327 /* Depend on event trigger function. */

328 myself.classId = EventTriggerRelationId;

329 myself.objectId = trigoid;

330 myself.objectSubId = 0;

331 referenced.classId = ProcedureRelationId;

332 referenced.objectId = funcoid;

333 referenced.objectSubId = 0;

334 recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

335

336 /* Depend on extension, if any. */

337 recordDependencyOnCurrentExtension(&myself, false);

338

339 /* Post creation hook for new event trigger */

340 InvokeObjectPostCreateHook(EventTriggerRelationId, trigoid, 0);

341

342 /* Close pg_event_trigger. */

343 table_close(tgrel, RowExclusiveLock);

344

345 return trigoid;

346}

347

348/*

349 * In the parser, a clause like WHEN tag IN ('cmd1', 'cmd2') is represented

350 * by a DefElem whose value is a List of String nodes; in the catalog, we

351 * store the list of strings as a text array. This function transforms the

352 * former representation into the latter one.

353 *

354 * For cleanliness, we store command tags in the catalog as text. It's

355 * possible (although not currently anticipated) that we might have

356 * a case-sensitive filter variable in the future, in which case this would

357 * need some further adjustment.

358 */

359static Datum

360 filter_list_to_array(List *filterlist)

361{

362 ListCell *lc;

363 Datum *data;

364 int i = 0,

365 l = list_length(filterlist);

366

367 data = (Datum *) palloc(l * sizeof(Datum));

368

369 foreach(lc, filterlist)

370 {

371 const char *value = strVal(lfirst(lc));

372 char *result,

373 *p;

374

375 result = pstrdup(value);

376 for (p = result; *p; p++)

377 *p = pg_ascii_toupper((unsigned char) *p);

378 data[i++] = PointerGetDatum(cstring_to_text(result));

379 pfree(result);

380 }

381

382 return PointerGetDatum(construct_array_builtin(data, l, TEXTOID));

383}

384

385/*

386 * Set pg_database.dathasloginevt flag for current database indicating that

387 * current database has on login event triggers.

388 */

389void

390 SetDatabaseHasLoginEventTriggers(void)

391{

392 /* Set dathasloginevt flag in pg_database */

393 Form_pg_database db;

394 Relation pg_db = table_open(DatabaseRelationId, RowExclusiveLock);

395 ItemPointerData otid;

396 HeapTuple tuple;

397

398 /*

399 * Use shared lock to prevent a conflict with EventTriggerOnLogin() trying

400 * to reset pg_database.dathasloginevt flag. Note, this lock doesn't

401 * effectively blocks database or other objection. It's just custom lock

402 * tag used to prevent multiple backends changing

403 * pg_database.dathasloginevt flag.

404 */

405 LockSharedObject(DatabaseRelationId, MyDatabaseId, 0, AccessExclusiveLock);

406

407 tuple = SearchSysCacheLockedCopy1(DATABASEOID, ObjectIdGetDatum(MyDatabaseId));

408 if (!HeapTupleIsValid(tuple))

409 elog(ERROR, "cache lookup failed for database %u", MyDatabaseId);

410 otid = tuple->t_self;

411 db = (Form_pg_database) GETSTRUCT(tuple);

412 if (!db->dathasloginevt)

413 {

414 db->dathasloginevt = true;

415 CatalogTupleUpdate(pg_db, &otid, tuple);

416 CommandCounterIncrement();

417 }

418 UnlockTuple(pg_db, &otid, InplaceUpdateTupleLock);

419 table_close(pg_db, RowExclusiveLock);

420 heap_freetuple(tuple);

421}

422

423/*

424 * ALTER EVENT TRIGGER foo ENABLE|DISABLE|ENABLE ALWAYS|REPLICA

425 */

426Oid

427 AlterEventTrigger(AlterEventTrigStmt *stmt)

428{

429 Relation tgrel;

430 HeapTuple tup;

431 Oid trigoid;

432 Form_pg_event_trigger evtForm;

433 char tgenabled = stmt->tgenabled;

434

435 tgrel = table_open(EventTriggerRelationId, RowExclusiveLock);

436

437 tup = SearchSysCacheCopy1(EVENTTRIGGERNAME,

438 CStringGetDatum(stmt->trigname));

439 if (!HeapTupleIsValid(tup))

440 ereport(ERROR,

441 (errcode(ERRCODE_UNDEFINED_OBJECT),

442 errmsg("event trigger \"%s\" does not exist",

443 stmt->trigname)));

444

445 evtForm = (Form_pg_event_trigger) GETSTRUCT(tup);

446 trigoid = evtForm->oid;

447

448 if (!object_ownercheck(EventTriggerRelationId, trigoid, GetUserId()))

449 aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_EVENT_TRIGGER,

450 stmt->trigname);

451

452 /* tuple is a copy, so we can modify it below */

453 evtForm->evtenabled = tgenabled;

454

455 CatalogTupleUpdate(tgrel, &tup->t_self, tup);

456

457 /*

458 * Login event triggers have an additional flag in pg_database to enable

459 * faster lookups in hot codepaths. Set the flag unless already True.

460 */

461 if (namestrcmp(&evtForm->evtevent, "login") == 0 &&

462 tgenabled != TRIGGER_DISABLED)

463 SetDatabaseHasLoginEventTriggers();

464

465 InvokeObjectPostAlterHook(EventTriggerRelationId,

466 trigoid, 0);

467

468 /* clean up */

469 heap_freetuple(tup);

470 table_close(tgrel, RowExclusiveLock);

471

472 return trigoid;

473}

474

475/*

476 * Change event trigger's owner -- by name

477 */

478ObjectAddress

479 AlterEventTriggerOwner(const char *name, Oid newOwnerId)

480{

481 Oid evtOid;

482 HeapTuple tup;

483 Form_pg_event_trigger evtForm;

484 Relation rel;

485 ObjectAddress address;

486

487 rel = table_open(EventTriggerRelationId, RowExclusiveLock);

488

489 tup = SearchSysCacheCopy1(EVENTTRIGGERNAME, CStringGetDatum(name));

490

491 if (!HeapTupleIsValid(tup))

492 ereport(ERROR,

493 (errcode(ERRCODE_UNDEFINED_OBJECT),

494 errmsg("event trigger \"%s\" does not exist", name)));

495

496 evtForm = (Form_pg_event_trigger) GETSTRUCT(tup);

497 evtOid = evtForm->oid;

498

499 AlterEventTriggerOwner_internal(rel, tup, newOwnerId);

500

501 ObjectAddressSet(address, EventTriggerRelationId, evtOid);

502

503 heap_freetuple(tup);

504

505 table_close(rel, RowExclusiveLock);

506

507 return address;

508}

509

510/*

511 * Change event trigger owner, by OID

512 */

513void

514 AlterEventTriggerOwner_oid(Oid trigOid, Oid newOwnerId)

515{

516 HeapTuple tup;

517 Relation rel;

518

519 rel = table_open(EventTriggerRelationId, RowExclusiveLock);

520

521 tup = SearchSysCacheCopy1(EVENTTRIGGEROID, ObjectIdGetDatum(trigOid));

522

523 if (!HeapTupleIsValid(tup))

524 ereport(ERROR,

525 (errcode(ERRCODE_UNDEFINED_OBJECT),

526 errmsg("event trigger with OID %u does not exist", trigOid)));

527

528 AlterEventTriggerOwner_internal(rel, tup, newOwnerId);

529

530 heap_freetuple(tup);

531

532 table_close(rel, RowExclusiveLock);

533}

534

535/*

536 * Internal workhorse for changing an event trigger's owner

537 */

538static void

539 AlterEventTriggerOwner_internal(Relation rel, HeapTuple tup, Oid newOwnerId)

540{

541 Form_pg_event_trigger form;

542

543 form = (Form_pg_event_trigger) GETSTRUCT(tup);

544

545 if (form->evtowner == newOwnerId)

546 return;

547

548 if (!object_ownercheck(EventTriggerRelationId, form->oid, GetUserId()))

549 aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_EVENT_TRIGGER,

550 NameStr(form->evtname));

551

552 /* New owner must be a superuser */

553 if (!superuser_arg(newOwnerId))

554 ereport(ERROR,

555 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),

556 errmsg("permission denied to change owner of event trigger \"%s\"",

557 NameStr(form->evtname)),

558 errhint("The owner of an event trigger must be a superuser.")));

559

560 form->evtowner = newOwnerId;

561 CatalogTupleUpdate(rel, &tup->t_self, tup);

562

563 /* Update owner dependency reference */

564 changeDependencyOnOwner(EventTriggerRelationId,

565 form->oid,

566 newOwnerId);

567

568 InvokeObjectPostAlterHook(EventTriggerRelationId,

569 form->oid, 0);

570}

571

572/*

573 * get_event_trigger_oid - Look up an event trigger by name to find its OID.

574 *

575 * If missing_ok is false, throw an error if trigger not found. If

576 * true, just return InvalidOid.

577 */

578Oid

579 get_event_trigger_oid(const char *trigname, bool missing_ok)

580{

581 Oid oid;

582

583 oid = GetSysCacheOid1(EVENTTRIGGERNAME, Anum_pg_event_trigger_oid,

584 CStringGetDatum(trigname));

585 if (!OidIsValid(oid) && !missing_ok)

586 ereport(ERROR,

587 (errcode(ERRCODE_UNDEFINED_OBJECT),

588 errmsg("event trigger \"%s\" does not exist", trigname)));

589 return oid;

590}

591

592/*

593 * Return true when we want to fire given Event Trigger and false otherwise,

594 * filtering on the session replication role and the event trigger registered

595 * tags matching.

596 */

597static bool

598 filter_event_trigger(CommandTag tag, EventTriggerCacheItem *item)

599{

600 /*

601 * Filter by session replication role, knowing that we never see disabled

602 * items down here.

603 */

604 if (SessionReplicationRole == SESSION_REPLICATION_ROLE_REPLICA)

605 {

606 if (item->enabled == TRIGGER_FIRES_ON_ORIGIN)

607 return false;

608 }

609 else

610 {

611 if (item->enabled == TRIGGER_FIRES_ON_REPLICA)

612 return false;

613 }

614

615 /* Filter by tags, if any were specified. */

616 if (!bms_is_empty(item->tagset) && !bms_is_member(tag, item->tagset))

617 return false;

618

619 /* if we reach that point, we're not filtering out this item */

620 return true;

621}

622

623static CommandTag

624 EventTriggerGetTag(Node *parsetree, EventTriggerEvent event)

625{

626 if (event == EVT_Login)

627 return CMDTAG_LOGIN;

628 else

629 return CreateCommandTag(parsetree);

630}

631

632/*

633 * Setup for running triggers for the given event. Return value is an OID list

634 * of functions to run; if there are any, trigdata is filled with an

635 * appropriate EventTriggerData for them to receive.

636 */

637static List *

638 EventTriggerCommonSetup(Node *parsetree,

639 EventTriggerEvent event, const char *eventstr,

640 EventTriggerData *trigdata, bool unfiltered)

641{

642 CommandTag tag;

643 List *cachelist;

644 ListCell *lc;

645 List *runlist = NIL;

646

647 /*

648 * We want the list of command tags for which this procedure is actually

649 * invoked to match up exactly with the list that CREATE EVENT TRIGGER

650 * accepts. This debugging cross-check will throw an error if this

651 * function is invoked for a command tag that CREATE EVENT TRIGGER won't

652 * accept. (Unfortunately, there doesn't seem to be any simple, automated

653 * way to verify that CREATE EVENT TRIGGER doesn't accept extra stuff that

654 * never reaches this control point.)

655 *

656 * If this cross-check fails for you, you probably need to either adjust

657 * standard_ProcessUtility() not to invoke event triggers for the command

658 * type in question, or you need to adjust event_trigger_ok to accept the

659 * relevant command tag.

660 */

661#ifdef USE_ASSERT_CHECKING

662 {

663 CommandTag dbgtag;

664

665 dbgtag = EventTriggerGetTag(parsetree, event);

666

667 if (event == EVT_DDLCommandStart ||

668 event == EVT_DDLCommandEnd ||

669 event == EVT_SQLDrop ||

670 event == EVT_Login)

671 {

672 if (!command_tag_event_trigger_ok(dbgtag))

673 elog(ERROR, "unexpected command tag \"%s\"", GetCommandTagName(dbgtag));

674 }

675 else if (event == EVT_TableRewrite)

676 {

677 if (!command_tag_table_rewrite_ok(dbgtag))

678 elog(ERROR, "unexpected command tag \"%s\"", GetCommandTagName(dbgtag));

679 }

680 }

681#endif

682

683 /* Use cache to find triggers for this event; fast exit if none. */

684 cachelist = EventCacheLookup(event);

685 if (cachelist == NIL)

686 return NIL;

687

688 /* Get the command tag. */

689 tag = EventTriggerGetTag(parsetree, event);

690

691 /*

692 * Filter list of event triggers by command tag, and copy them into our

693 * memory context. Once we start running the command triggers, or indeed

694 * once we do anything at all that touches the catalogs, an invalidation

695 * might leave cachelist pointing at garbage, so we must do this before we

696 * can do much else.

697 */

698 foreach(lc, cachelist)

699 {

700 EventTriggerCacheItem *item = lfirst(lc);

701

702 if (unfiltered || filter_event_trigger(tag, item))

703 {

704 /* We must plan to fire this trigger. */

705 runlist = lappend_oid(runlist, item->fnoid);

706 }

707 }

708

709 /* Don't spend any more time on this if no functions to run */

710 if (runlist == NIL)

711 return NIL;

712

713 trigdata->type = T_EventTriggerData;

714 trigdata->event = eventstr;

715 trigdata->parsetree = parsetree;

716 trigdata->tag = tag;

717

718 return runlist;

719}

720

721/*

722 * Fire ddl_command_start triggers.

723 */

724void

725 EventTriggerDDLCommandStart(Node *parsetree)

726{

727 List *runlist;

728 EventTriggerData trigdata;

729

730 /*

731 * Event Triggers are completely disabled in standalone mode. There are

732 * (at least) two reasons for this:

733 *

734 * 1. A sufficiently broken event trigger might not only render the

735 * database unusable, but prevent disabling itself to fix the situation.

736 * In this scenario, restarting in standalone mode provides an escape

737 * hatch.

738 *

739 * 2. BuildEventTriggerCache relies on systable_beginscan_ordered, and

740 * therefore will malfunction if pg_event_trigger's indexes are damaged.

741 * To allow recovery from a damaged index, we need some operating mode

742 * wherein event triggers are disabled. (Or we could implement

743 * heapscan-and-sort logic for that case, but having disaster recovery

744 * scenarios depend on code that's otherwise untested isn't appetizing.)

745 *

746 * Additionally, event triggers can be disabled with a superuser-only GUC

747 * to make fixing database easier as per 1 above.

748 */

749 if (!IsUnderPostmaster || !event_triggers)

750 return;

751

752 runlist = EventTriggerCommonSetup(parsetree,

753 EVT_DDLCommandStart,

754 "ddl_command_start",

755 &trigdata, false);

756 if (runlist == NIL)

757 return;

758

759 /* Run the triggers. */

760 EventTriggerInvoke(runlist, &trigdata);

761

762 /* Cleanup. */

763 list_free(runlist);

764

765 /*

766 * Make sure anything the event triggers did will be visible to the main

767 * command.

768 */

769 CommandCounterIncrement();

770}

771

772/*

773 * Fire ddl_command_end triggers.

774 */

775void

776 EventTriggerDDLCommandEnd(Node *parsetree)

777{

778 List *runlist;

779 EventTriggerData trigdata;

780

781 /*

782 * See EventTriggerDDLCommandStart for a discussion about why event

783 * triggers are disabled in single user mode or via GUC.

784 */

785 if (!IsUnderPostmaster || !event_triggers)

786 return;

787

788 /*

789 * Also do nothing if our state isn't set up, which it won't be if there

790 * weren't any relevant event triggers at the start of the current DDL

791 * command. This test might therefore seem optional, but it's important

792 * because EventTriggerCommonSetup might find triggers that didn't exist

793 * at the time the command started. Although this function itself

794 * wouldn't crash, the event trigger functions would presumably call

795 * pg_event_trigger_ddl_commands which would fail. Better to do nothing

796 * until the next command.

797 */

798 if (!currentEventTriggerState)

799 return;

800

801 runlist = EventTriggerCommonSetup(parsetree,

802 EVT_DDLCommandEnd, "ddl_command_end",

803 &trigdata, false);

804 if (runlist == NIL)

805 return;

806

807 /*

808 * Make sure anything the main command did will be visible to the event

809 * triggers.

810 */

811 CommandCounterIncrement();

812

813 /* Run the triggers. */

814 EventTriggerInvoke(runlist, &trigdata);

815

816 /* Cleanup. */

817 list_free(runlist);

818}

819

820/*

821 * Fire sql_drop triggers.

822 */

823void

824 EventTriggerSQLDrop(Node *parsetree)

825{

826 List *runlist;

827 EventTriggerData trigdata;

828

829 /*

830 * See EventTriggerDDLCommandStart for a discussion about why event

831 * triggers are disabled in single user mode or via a GUC.

832 */

833 if (!IsUnderPostmaster || !event_triggers)

834 return;

835

836 /*

837 * Use current state to determine whether this event fires at all. If

838 * there are no triggers for the sql_drop event, then we don't have

839 * anything to do here. Note that dropped object collection is disabled

840 * if this is the case, so even if we were to try to run, the list would

841 * be empty.

842 */

843 if (!currentEventTriggerState ||

844 slist_is_empty(&currentEventTriggerState->SQLDropList))

845 return;

846

847 runlist = EventTriggerCommonSetup(parsetree,

848 EVT_SQLDrop, "sql_drop",

849 &trigdata, false);

850

851 /*

852 * Nothing to do if run list is empty. Note this typically can't happen,

853 * because if there are no sql_drop events, then objects-to-drop wouldn't

854 * have been collected in the first place and we would have quit above.

855 * But it could occur if event triggers were dropped partway through.

856 */

857 if (runlist == NIL)

858 return;

859

860 /*

861 * Make sure anything the main command did will be visible to the event

862 * triggers.

863 */

864 CommandCounterIncrement();

865

866 /*

867 * Make sure pg_event_trigger_dropped_objects only works when running

868 * these triggers. Use PG_TRY to ensure in_sql_drop is reset even when

869 * one trigger fails. (This is perhaps not necessary, as the currentState

870 * variable will be removed shortly by our caller, but it seems better to

871 * play safe.)

872 */

873 currentEventTriggerState->in_sql_drop = true;

874

875 /* Run the triggers. */

876 PG_TRY();

877 {

878 EventTriggerInvoke(runlist, &trigdata);

879 }

880 PG_FINALLY();

881 {

882 currentEventTriggerState->in_sql_drop = false;

883 }

884 PG_END_TRY();

885

886 /* Cleanup. */

887 list_free(runlist);

888}

889

890/*

891 * Fire login event triggers if any are present. The dathasloginevt

892 * pg_database flag is left unchanged when an event trigger is dropped to avoid

893 * complicating the codepath in the case of multiple event triggers. This

894 * function will instead unset the flag if no trigger is defined.

895 */

896void

897 EventTriggerOnLogin(void)

898{

899 List *runlist;

900 EventTriggerData trigdata;

901

902 /*

903 * See EventTriggerDDLCommandStart for a discussion about why event

904 * triggers are disabled in single user mode or via a GUC. We also need a

905 * database connection (some background workers don't have it).

906 */

907 if (!IsUnderPostmaster || !event_triggers ||

908 !OidIsValid(MyDatabaseId) || !MyDatabaseHasLoginEventTriggers)

909 return;

910

911 StartTransactionCommand();

912 runlist = EventTriggerCommonSetup(NULL,

913 EVT_Login, "login",

914 &trigdata, false);

915

916 if (runlist != NIL)

917 {

918 /*

919 * Event trigger execution may require an active snapshot.

920 */

921 PushActiveSnapshot(GetTransactionSnapshot());

922

923 /* Run the triggers. */

924 EventTriggerInvoke(runlist, &trigdata);

925

926 /* Cleanup. */

927 list_free(runlist);

928

929 PopActiveSnapshot();

930 }

931

932 /*

933 * There is no active login event trigger, but our

934 * pg_database.dathasloginevt is set. Try to unset this flag. We use the

935 * lock to prevent concurrent SetDatabaseHasLoginEventTriggers(), but we

936 * don't want to hang the connection waiting on the lock. Thus, we are

937 * just trying to acquire the lock conditionally.

938 */

939 else if (ConditionalLockSharedObject(DatabaseRelationId, MyDatabaseId,

940 0, AccessExclusiveLock))

941 {

942 /*

943 * The lock is held. Now we need to recheck that login event triggers

944 * list is still empty. Once the list is empty, we know that even if

945 * there is a backend which concurrently inserts/enables a login event

946 * trigger, it will update pg_database.dathasloginevt *afterwards*.

947 */

948 runlist = EventTriggerCommonSetup(NULL,

949 EVT_Login, "login",

950 &trigdata, true);

951

952 if (runlist == NIL)

953 {

954 Relation pg_db = table_open(DatabaseRelationId, RowExclusiveLock);

955 HeapTuple tuple;

956 void *state;

957 Form_pg_database db;

958 ScanKeyData key[1];

959

960 /* Fetch a copy of the tuple to scribble on */

961 ScanKeyInit(&key[0],

962 Anum_pg_database_oid,

963 BTEqualStrategyNumber, F_OIDEQ,

964 ObjectIdGetDatum(MyDatabaseId));

965

966 systable_inplace_update_begin(pg_db, DatabaseOidIndexId, true,

967 NULL, 1, key, &tuple, &state);

968

969 if (!HeapTupleIsValid(tuple))

970 elog(ERROR, "could not find tuple for database %u", MyDatabaseId);

971

972 db = (Form_pg_database) GETSTRUCT(tuple);

973 if (db->dathasloginevt)

974 {

975 db->dathasloginevt = false;

976

977 /*

978 * Do an "in place" update of the pg_database tuple. Doing

979 * this instead of regular updates serves two purposes. First,

980 * that avoids possible waiting on the row-level lock. Second,

981 * that avoids dealing with TOAST.

982 */

983 systable_inplace_update_finish(state, tuple);

984 }

985 else

986 systable_inplace_update_cancel(state);

987 table_close(pg_db, RowExclusiveLock);

988 heap_freetuple(tuple);

989 }

990 else

991 {

992 list_free(runlist);

993 }

994 }

995 CommitTransactionCommand();

996}

997

998

999/*

1000 * Fire table_rewrite triggers.

1001 */

1002void

1003 EventTriggerTableRewrite(Node *parsetree, Oid tableOid, int reason)

1004{

1005 List *runlist;

1006 EventTriggerData trigdata;

1007

1008 /*

1009 * See EventTriggerDDLCommandStart for a discussion about why event

1010 * triggers are disabled in single user mode or via a GUC.

1011 */

1012 if (!IsUnderPostmaster || !event_triggers)

1013 return;

1014

1015 /*

1016 * Also do nothing if our state isn't set up, which it won't be if there

1017 * weren't any relevant event triggers at the start of the current DDL

1018 * command. This test might therefore seem optional, but it's

1019 * *necessary*, because EventTriggerCommonSetup might find triggers that

1020 * didn't exist at the time the command started.

1021 */

1022 if (!currentEventTriggerState)

1023 return;

1024

1025 runlist = EventTriggerCommonSetup(parsetree,

1026 EVT_TableRewrite,

1027 "table_rewrite",

1028 &trigdata, false);

1029 if (runlist == NIL)

1030 return;

1031

1032 /*

1033 * Make sure pg_event_trigger_table_rewrite_oid only works when running

1034 * these triggers. Use PG_TRY to ensure table_rewrite_oid is reset even

1035 * when one trigger fails. (This is perhaps not necessary, as the

1036 * currentState variable will be removed shortly by our caller, but it

1037 * seems better to play safe.)

1038 */

1039 currentEventTriggerState->table_rewrite_oid = tableOid;

1040 currentEventTriggerState->table_rewrite_reason = reason;

1041

1042 /* Run the triggers. */

1043 PG_TRY();

1044 {

1045 EventTriggerInvoke(runlist, &trigdata);

1046 }

1047 PG_FINALLY();

1048 {

1049 currentEventTriggerState->table_rewrite_oid = InvalidOid;

1050 currentEventTriggerState->table_rewrite_reason = 0;

1051 }

1052 PG_END_TRY();

1053

1054 /* Cleanup. */

1055 list_free(runlist);

1056

1057 /*

1058 * Make sure anything the event triggers did will be visible to the main

1059 * command.

1060 */

1061 CommandCounterIncrement();

1062}

1063

1064/*

1065 * Invoke each event trigger in a list of event triggers.

1066 */

1067static void

1068 EventTriggerInvoke(List *fn_oid_list, EventTriggerData *trigdata)

1069{

1070 MemoryContext context;

1071 MemoryContext oldcontext;

1072 ListCell *lc;

1073 bool first = true;

1074

1075 /* Guard against stack overflow due to recursive event trigger */

1076 check_stack_depth();

1077

1078 /*

1079 * Let's evaluate event triggers in their own memory context, so that any

1080 * leaks get cleaned up promptly.

1081 */

1082 context = AllocSetContextCreate(CurrentMemoryContext,

1083 "event trigger context",

1084 ALLOCSET_DEFAULT_SIZES);

1085 oldcontext = MemoryContextSwitchTo(context);

1086

1087 /* Call each event trigger. */

1088 foreach(lc, fn_oid_list)

1089 {

1090 LOCAL_FCINFO(fcinfo, 0);

1091 Oid fnoid = lfirst_oid(lc);

1092 FmgrInfo flinfo;

1093 PgStat_FunctionCallUsage fcusage;

1094

1095 elog(DEBUG1, "EventTriggerInvoke %u", fnoid);

1096

1097 /*

1098 * We want each event trigger to be able to see the results of the

1099 * previous event trigger's action. Caller is responsible for any

1100 * command-counter increment that is needed between the event trigger

1101 * and anything else in the transaction.

1102 */

1103 if (first)

1104 first = false;

1105 else

1106 CommandCounterIncrement();

1107

1108 /* Look up the function */

1109 fmgr_info(fnoid, &flinfo);

1110

1111 /* Call the function, passing no arguments but setting a context. */

1112 InitFunctionCallInfoData(*fcinfo, &flinfo, 0,

1113 InvalidOid, (Node *) trigdata, NULL);

1114 pgstat_init_function_usage(fcinfo, &fcusage);

1115 FunctionCallInvoke(fcinfo);

1116 pgstat_end_function_usage(&fcusage, true);

1117

1118 /* Reclaim memory. */

1119 MemoryContextReset(context);

1120 }

1121

1122 /* Restore old memory context and delete the temporary one. */

1123 MemoryContextSwitchTo(oldcontext);

1124 MemoryContextDelete(context);

1125}

1126

1127/*

1128 * Do event triggers support this object type?

1129 *

1130 * See also event trigger documentation in event-trigger.sgml.

1131 */

1132bool

1133 EventTriggerSupportsObjectType(ObjectType obtype)

1134{

1135 switch (obtype)

1136 {

1137 case OBJECT_DATABASE:

1138 case OBJECT_TABLESPACE:

1139 case OBJECT_ROLE:

1140 case OBJECT_PARAMETER_ACL:

1141 /* no support for global objects (except subscriptions) */

1142 return false;

1143 case OBJECT_EVENT_TRIGGER:

1144 /* no support for event triggers on event triggers */

1145 return false;

1146 default:

1147 return true;

1148 }

1149}

1150

1151/*

1152 * Do event triggers support this object class?

1153 *

1154 * See also event trigger documentation in event-trigger.sgml.

1155 */

1156bool

1157 EventTriggerSupportsObject(const ObjectAddress *object)

1158{

1159 switch (object->classId)

1160 {

1161 case DatabaseRelationId:

1162 case TableSpaceRelationId:

1163 case AuthIdRelationId:

1164 case AuthMemRelationId:

1165 case ParameterAclRelationId:

1166 /* no support for global objects (except subscriptions) */

1167 return false;

1168 case EventTriggerRelationId:

1169 /* no support for event triggers on event triggers */

1170 return false;

1171 default:

1172 return true;

1173 }

1174}

1175

1176/*

1177 * Prepare event trigger state for a new complete query to run, if necessary;

1178 * returns whether this was done. If it was, EventTriggerEndCompleteQuery must

1179 * be called when the query is done, regardless of whether it succeeds or fails

1180 * -- so use of a PG_TRY block is mandatory.

1181 */

1182bool

1183 EventTriggerBeginCompleteQuery(void)

1184{

1185 EventTriggerQueryState *state;

1186 MemoryContext cxt;

1187

1188 /*

1189 * Currently, sql_drop, table_rewrite, ddl_command_end events are the only

1190 * reason to have event trigger state at all; so if there are none, don't

1191 * install one.

1192 */

1193 if (!trackDroppedObjectsNeeded())

1194 return false;

1195

1196 cxt = AllocSetContextCreate(TopMemoryContext,

1197 "event trigger state",

1198 ALLOCSET_DEFAULT_SIZES);

1199 state = MemoryContextAlloc(cxt, sizeof(EventTriggerQueryState));

1200 state->cxt = cxt;

1201 slist_init(&(state->SQLDropList));

1202 state->in_sql_drop = false;

1203 state->table_rewrite_oid = InvalidOid;

1204

1205 state->commandCollectionInhibited = currentEventTriggerState ?

1206 currentEventTriggerState->commandCollectionInhibited : false;

1207 state->currentCommand = NULL;

1208 state->commandList = NIL;

1209 state->previous = currentEventTriggerState;

1210 currentEventTriggerState = state;

1211

1212 return true;

1213}

1214

1215/*

1216 * Query completed (or errored out) -- clean up local state, return to previous

1217 * one.

1218 *

1219 * Note: it's an error to call this routine if EventTriggerBeginCompleteQuery

1220 * returned false previously.

1221 *

1222 * Note: this might be called in the PG_CATCH block of a failing transaction,

1223 * so be wary of running anything unnecessary. (In particular, it's probably

1224 * unwise to try to allocate memory.)

1225 */

1226void

1227 EventTriggerEndCompleteQuery(void)

1228{

1229 EventTriggerQueryState *prevstate;

1230

1231 prevstate = currentEventTriggerState->previous;

1232

1233 /* this avoids the need for retail pfree of SQLDropList items: */

1234 MemoryContextDelete(currentEventTriggerState->cxt);

1235

1236 currentEventTriggerState = prevstate;

1237}

1238

1239/*

1240 * Do we need to keep close track of objects being dropped?

1241 *

1242 * This is useful because there is a cost to running with them enabled.

1243 */

1244bool

1245 trackDroppedObjectsNeeded(void)

1246{

1247 /*

1248 * true if any sql_drop, table_rewrite, ddl_command_end event trigger

1249 * exists

1250 */

1251 return (EventCacheLookup(EVT_SQLDrop) != NIL) ||

1252 (EventCacheLookup(EVT_TableRewrite) != NIL) ||

1253 (EventCacheLookup(EVT_DDLCommandEnd) != NIL);

1254}

1255

1256/*

1257 * Support for dropped objects information on event trigger functions.

1258 *

1259 * We keep the list of objects dropped by the current command in current

1260 * state's SQLDropList (comprising SQLDropObject items). Each time a new

1261 * command is to start, a clean EventTriggerQueryState is created; commands

1262 * that drop objects do the dependency.c dance to drop objects, which

1263 * populates the current state's SQLDropList; when the event triggers are

1264 * invoked they can consume the list via pg_event_trigger_dropped_objects().

1265 * When the command finishes, the EventTriggerQueryState is cleared, and

1266 * the one from the previous command is restored (when no command is in

1267 * execution, the current state is NULL).

1268 *

1269 * All this lets us support the case that an event trigger function drops

1270 * objects "reentrantly".

1271 */

1272

1273/*

1274 * Register one object as being dropped by the current command.

1275 */

1276void

1277 EventTriggerSQLDropAddObject(const ObjectAddress *object, bool original, bool normal)

1278{

1279 SQLDropObject *obj;

1280 MemoryContext oldcxt;

1281

1282 if (!currentEventTriggerState)

1283 return;

1284

1285 Assert(EventTriggerSupportsObject(object));

1286

1287 oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);

1288

1289 obj = palloc0(sizeof(SQLDropObject));

1290 obj->address = *object;

1291 obj->original = original;

1292 obj->normal = normal;

1293

1294 if (object->classId == NamespaceRelationId)

1295 {

1296 /* Special handling is needed for temp namespaces */

1297 if (isTempNamespace(object->objectId))

1298 obj->istemp = true;

1299 else if (isAnyTempNamespace(object->objectId))

1300 {

1301 /* don't report temp schemas except my own */

1302 pfree(obj);

1303 MemoryContextSwitchTo(oldcxt);

1304 return;

1305 }

1306 obj->objname = get_namespace_name(object->objectId);

1307 }

1308 else if (object->classId == AttrDefaultRelationId)

1309 {

1310 /* We treat a column default as temp if its table is temp */

1311 ObjectAddress colobject;

1312

1313 colobject = GetAttrDefaultColumnAddress(object->objectId);

1314 if (OidIsValid(colobject.objectId))

1315 {

1316 if (!obtain_object_name_namespace(&colobject, obj))

1317 {

1318 pfree(obj);

1319 MemoryContextSwitchTo(oldcxt);

1320 return;

1321 }

1322 }

1323 }

1324 else if (object->classId == TriggerRelationId)

1325 {

1326 /* Similarly, a trigger is temp if its table is temp */

1327 /* Sadly, there's no lsyscache.c support for trigger objects */

1328 Relation pg_trigger_rel;

1329 ScanKeyData skey[1];

1330 SysScanDesc sscan;

1331 HeapTuple tuple;

1332 Oid relid;

1333

1334 /* Fetch the trigger's table OID the hard way */

1335 pg_trigger_rel = table_open(TriggerRelationId, AccessShareLock);

1336 ScanKeyInit(&skey[0],

1337 Anum_pg_trigger_oid,

1338 BTEqualStrategyNumber, F_OIDEQ,

1339 ObjectIdGetDatum(object->objectId));

1340 sscan = systable_beginscan(pg_trigger_rel, TriggerOidIndexId, true,

1341 NULL, 1, skey);

1342 tuple = systable_getnext(sscan);

1343 if (HeapTupleIsValid(tuple))

1344 relid = ((Form_pg_trigger) GETSTRUCT(tuple))->tgrelid;

1345 else

1346 relid = InvalidOid; /* shouldn't happen */

1347 systable_endscan(sscan);

1348 table_close(pg_trigger_rel, AccessShareLock);

1349 /* Do nothing if we didn't find the trigger */

1350 if (OidIsValid(relid))

1351 {

1352 ObjectAddress relobject;

1353

1354 relobject.classId = RelationRelationId;

1355 relobject.objectId = relid;

1356 /* Arbitrarily set objectSubId nonzero so as not to fill objname */

1357 relobject.objectSubId = 1;

1358 if (!obtain_object_name_namespace(&relobject, obj))

1359 {

1360 pfree(obj);

1361 MemoryContextSwitchTo(oldcxt);

1362 return;

1363 }

1364 }

1365 }

1366 else if (object->classId == PolicyRelationId)

1367 {

1368 /* Similarly, a policy is temp if its table is temp */

1369 /* Sadly, there's no lsyscache.c support for policy objects */

1370 Relation pg_policy_rel;

1371 ScanKeyData skey[1];

1372 SysScanDesc sscan;

1373 HeapTuple tuple;

1374 Oid relid;

1375

1376 /* Fetch the policy's table OID the hard way */

1377 pg_policy_rel = table_open(PolicyRelationId, AccessShareLock);

1378 ScanKeyInit(&skey[0],

1379 Anum_pg_policy_oid,

1380 BTEqualStrategyNumber, F_OIDEQ,

1381 ObjectIdGetDatum(object->objectId));

1382 sscan = systable_beginscan(pg_policy_rel, PolicyOidIndexId, true,

1383 NULL, 1, skey);

1384 tuple = systable_getnext(sscan);

1385 if (HeapTupleIsValid(tuple))

1386 relid = ((Form_pg_policy) GETSTRUCT(tuple))->polrelid;

1387 else

1388 relid = InvalidOid; /* shouldn't happen */

1389 systable_endscan(sscan);

1390 table_close(pg_policy_rel, AccessShareLock);

1391 /* Do nothing if we didn't find the policy */

1392 if (OidIsValid(relid))

1393 {

1394 ObjectAddress relobject;

1395

1396 relobject.classId = RelationRelationId;

1397 relobject.objectId = relid;

1398 /* Arbitrarily set objectSubId nonzero so as not to fill objname */

1399 relobject.objectSubId = 1;

1400 if (!obtain_object_name_namespace(&relobject, obj))

1401 {

1402 pfree(obj);

1403 MemoryContextSwitchTo(oldcxt);

1404 return;

1405 }

1406 }

1407 }

1408 else

1409 {

1410 /* Generic handling for all other object classes */

1411 if (!obtain_object_name_namespace(object, obj))

1412 {

1413 /* don't report temp objects except my own */

1414 pfree(obj);

1415 MemoryContextSwitchTo(oldcxt);

1416 return;

1417 }

1418 }

1419

1420 /* object identity, objname and objargs */

1421 obj->objidentity =

1422 getObjectIdentityParts(&obj->address, &obj->addrnames, &obj->addrargs,

1423 false);

1424

1425 /* object type */

1426 obj->objecttype = getObjectTypeDescription(&obj->address, false);

1427

1428 slist_push_head(&(currentEventTriggerState->SQLDropList), &obj->next);

1429

1430 MemoryContextSwitchTo(oldcxt);

1431}

1432

1433/*

1434 * Fill obj->objname, obj->schemaname, and obj->istemp based on object.

1435 *

1436 * Returns true if this object should be reported, false if it should

1437 * be ignored because it is a temporary object of another session.

1438 */

1439static bool

1440 obtain_object_name_namespace(const ObjectAddress *object, SQLDropObject *obj)

1441{

1442 /*

1443 * Obtain schema names from the object's catalog tuple, if one exists;

1444 * this lets us skip objects in temp schemas. We trust that

1445 * ObjectProperty contains all object classes that can be

1446 * schema-qualified.

1447 *

1448 * Currently, this function does nothing for object classes that are not

1449 * in ObjectProperty, but we might sometime add special cases for that.

1450 */

1451 if (is_objectclass_supported(object->classId))

1452 {

1453 Relation catalog;

1454 HeapTuple tuple;

1455

1456 catalog = table_open(object->classId, AccessShareLock);

1457 tuple = get_catalog_object_by_oid(catalog,

1458 get_object_attnum_oid(object->classId),

1459 object->objectId);

1460

1461 if (tuple)

1462 {

1463 AttrNumber attnum;

1464 Datum datum;

1465 bool isnull;

1466

1467 attnum = get_object_attnum_namespace(object->classId);

1468 if (attnum != InvalidAttrNumber)

1469 {

1470 datum = heap_getattr(tuple, attnum,

1471 RelationGetDescr(catalog), &isnull);

1472 if (!isnull)

1473 {

1474 Oid namespaceId;

1475

1476 namespaceId = DatumGetObjectId(datum);

1477 /* temp objects are only reported if they are my own */

1478 if (isTempNamespace(namespaceId))

1479 {

1480 obj->schemaname = "pg_temp";

1481 obj->istemp = true;

1482 }

1483 else if (isAnyTempNamespace(namespaceId))

1484 {

1485 /* no need to fill any fields of *obj */

1486 table_close(catalog, AccessShareLock);

1487 return false;

1488 }

1489 else

1490 {

1491 obj->schemaname = get_namespace_name(namespaceId);

1492 obj->istemp = false;

1493 }

1494 }

1495 }

1496

1497 if (get_object_namensp_unique(object->classId) &&

1498 object->objectSubId == 0)

1499 {

1500 attnum = get_object_attnum_name(object->classId);

1501 if (attnum != InvalidAttrNumber)

1502 {

1503 datum = heap_getattr(tuple, attnum,

1504 RelationGetDescr(catalog), &isnull);

1505 if (!isnull)

1506 obj->objname = pstrdup(NameStr(*DatumGetName(datum)));

1507 }

1508 }

1509 }

1510

1511 table_close(catalog, AccessShareLock);

1512 }

1513

1514 return true;

1515}

1516

1517/*

1518 * pg_event_trigger_dropped_objects

1519 *

1520 * Make the list of dropped objects available to the user function run by the

1521 * Event Trigger.

1522 */

1523Datum

1524 pg_event_trigger_dropped_objects(PG_FUNCTION_ARGS)

1525{

1526 ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;

1527 slist_iter iter;

1528

1529 /*

1530 * Protect this function from being called out of context

1531 */

1532 if (!currentEventTriggerState ||

1533 !currentEventTriggerState->in_sql_drop)

1534 ereport(ERROR,

1535 (errcode(ERRCODE_E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED),

1536 errmsg("%s can only be called in a sql_drop event trigger function",

1537 "pg_event_trigger_dropped_objects()")));

1538

1539 /* Build tuplestore to hold the result rows */

1540 InitMaterializedSRF(fcinfo, 0);

1541

1542 slist_foreach(iter, &(currentEventTriggerState->SQLDropList))

1543 {

1544 SQLDropObject *obj;

1545 int i = 0;

1546 Datum values[12] = {0};

1547 bool nulls[12] = {0};

1548

1549 obj = slist_container(SQLDropObject, next, iter.cur);

1550

1551 /* classid */

1552 values[i++] = ObjectIdGetDatum(obj->address.classId);

1553

1554 /* objid */

1555 values[i++] = ObjectIdGetDatum(obj->address.objectId);

1556

1557 /* objsubid */

1558 values[i++] = Int32GetDatum(obj->address.objectSubId);

1559

1560 /* original */

1561 values[i++] = BoolGetDatum(obj->original);

1562

1563 /* normal */

1564 values[i++] = BoolGetDatum(obj->normal);

1565

1566 /* is_temporary */

1567 values[i++] = BoolGetDatum(obj->istemp);

1568

1569 /* object_type */

1570 values[i++] = CStringGetTextDatum(obj->objecttype);

1571

1572 /* schema_name */

1573 if (obj->schemaname)

1574 values[i++] = CStringGetTextDatum(obj->schemaname);

1575 else

1576 nulls[i++] = true;

1577

1578 /* object_name */

1579 if (obj->objname)

1580 values[i++] = CStringGetTextDatum(obj->objname);

1581 else

1582 nulls[i++] = true;

1583

1584 /* object_identity */

1585 if (obj->objidentity)

1586 values[i++] = CStringGetTextDatum(obj->objidentity);

1587 else

1588 nulls[i++] = true;

1589

1590 /* address_names and address_args */

1591 if (obj->addrnames)

1592 {

1593 values[i++] = PointerGetDatum(strlist_to_textarray(obj->addrnames));

1594

1595 if (obj->addrargs)

1596 values[i++] = PointerGetDatum(strlist_to_textarray(obj->addrargs));

1597 else

1598 values[i++] = PointerGetDatum(construct_empty_array(TEXTOID));

1599 }

1600 else

1601 {

1602 nulls[i++] = true;

1603 nulls[i++] = true;

1604 }

1605

1606 tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,

1607 values, nulls);

1608 }

1609

1610 return (Datum) 0;

1611}

1612

1613/*

1614 * pg_event_trigger_table_rewrite_oid

1615 *

1616 * Make the Oid of the table going to be rewritten available to the user

1617 * function run by the Event Trigger.

1618 */

1619Datum

1620 pg_event_trigger_table_rewrite_oid(PG_FUNCTION_ARGS)

1621{

1622 /*

1623 * Protect this function from being called out of context

1624 */

1625 if (!currentEventTriggerState ||

1626 currentEventTriggerState->table_rewrite_oid == InvalidOid)

1627 ereport(ERROR,

1628 (errcode(ERRCODE_E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED),

1629 errmsg("%s can only be called in a table_rewrite event trigger function",

1630 "pg_event_trigger_table_rewrite_oid()")));

1631

1632 PG_RETURN_OID(currentEventTriggerState->table_rewrite_oid);

1633}

1634

1635/*

1636 * pg_event_trigger_table_rewrite_reason

1637 *

1638 * Make the rewrite reason available to the user.

1639 */

1640Datum

1641 pg_event_trigger_table_rewrite_reason(PG_FUNCTION_ARGS)

1642{

1643 /*

1644 * Protect this function from being called out of context

1645 */

1646 if (!currentEventTriggerState ||

1647 currentEventTriggerState->table_rewrite_reason == 0)

1648 ereport(ERROR,

1649 (errcode(ERRCODE_E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED),

1650 errmsg("%s can only be called in a table_rewrite event trigger function",

1651 "pg_event_trigger_table_rewrite_reason()")));

1652

1653 PG_RETURN_INT32(currentEventTriggerState->table_rewrite_reason);

1654}

1655

1656/*-------------------------------------------------------------------------

1657 * Support for DDL command deparsing

1658 *

1659 * The routines below enable an event trigger function to obtain a list of

1660 * DDL commands as they are executed. There are three main pieces to this

1661 * feature:

1662 *

1663 * 1) Within ProcessUtilitySlow, or some sub-routine thereof, each DDL command

1664 * adds a struct CollectedCommand representation of itself to the command list,

1665 * using the routines below.

1666 *

1667 * 2) Some time after that, ddl_command_end fires and the command list is made

1668 * available to the event trigger function via pg_event_trigger_ddl_commands();

1669 * the complete command details are exposed as a column of type pg_ddl_command.

1670 *

1671 * 3) An extension can install a function capable of taking a value of type

1672 * pg_ddl_command and transform it into some external, user-visible and/or

1673 * -modifiable representation.

1674 *-------------------------------------------------------------------------

1675 */

1676

1677/*

1678 * Inhibit DDL command collection.

1679 */

1680void

1681 EventTriggerInhibitCommandCollection(void)

1682{

1683 if (!currentEventTriggerState)

1684 return;

1685

1686 currentEventTriggerState->commandCollectionInhibited = true;

1687}

1688

1689/*

1690 * Re-establish DDL command collection.

1691 */

1692void

1693 EventTriggerUndoInhibitCommandCollection(void)

1694{

1695 if (!currentEventTriggerState)

1696 return;

1697

1698 currentEventTriggerState->commandCollectionInhibited = false;

1699}

1700

1701/*

1702 * EventTriggerCollectSimpleCommand

1703 * Save data about a simple DDL command that was just executed

1704 *

1705 * address identifies the object being operated on. secondaryObject is an

1706 * object address that was related in some way to the executed command; its

1707 * meaning is command-specific.

1708 *

1709 * For instance, for an ALTER obj SET SCHEMA command, objtype is the type of

1710 * object being moved, objectId is its OID, and secondaryOid is the OID of the

1711 * old schema. (The destination schema OID can be obtained by catalog lookup

1712 * of the object.)

1713 */

1714void

1715 EventTriggerCollectSimpleCommand(ObjectAddress address,

1716 ObjectAddress secondaryObject,

1717 Node *parsetree)

1718{

1719 MemoryContext oldcxt;

1720 CollectedCommand *command;

1721

1722 /* ignore if event trigger context not set, or collection disabled */

1723 if (!currentEventTriggerState ||

1724 currentEventTriggerState->commandCollectionInhibited)

1725 return;

1726

1727 oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);

1728

1729 command = palloc(sizeof(CollectedCommand));

1730

1731 command->type = SCT_Simple;

1732 command->in_extension = creating_extension;

1733

1734 command->d.simple.address = address;

1735 command->d.simple.secondaryObject = secondaryObject;

1736 command->parsetree = copyObject(parsetree);

1737

1738 currentEventTriggerState->commandList = lappend(currentEventTriggerState->commandList,

1739 command);

1740

1741 MemoryContextSwitchTo(oldcxt);

1742}

1743

1744/*

1745 * EventTriggerAlterTableStart

1746 * Prepare to receive data on an ALTER TABLE command about to be executed

1747 *

1748 * Note we don't collect the command immediately; instead we keep it in

1749 * currentCommand, and only when we're done processing the subcommands we will

1750 * add it to the command list.

1751 */

1752void

1753 EventTriggerAlterTableStart(Node *parsetree)

1754{

1755 MemoryContext oldcxt;

1756 CollectedCommand *command;

1757

1758 /* ignore if event trigger context not set, or collection disabled */

1759 if (!currentEventTriggerState ||

1760 currentEventTriggerState->commandCollectionInhibited)

1761 return;

1762

1763 oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);

1764

1765 command = palloc(sizeof(CollectedCommand));

1766

1767 command->type = SCT_AlterTable;

1768 command->in_extension = creating_extension;

1769

1770 command->d.alterTable.classId = RelationRelationId;

1771 command->d.alterTable.objectId = InvalidOid;

1772 command->d.alterTable.subcmds = NIL;

1773 command->parsetree = copyObject(parsetree);

1774

1775 command->parent = currentEventTriggerState->currentCommand;

1776 currentEventTriggerState->currentCommand = command;

1777

1778 MemoryContextSwitchTo(oldcxt);

1779}

1780

1781/*

1782 * Remember the OID of the object being affected by an ALTER TABLE.

1783 *

1784 * This is needed because in some cases we don't know the OID until later.

1785 */

1786void

1787 EventTriggerAlterTableRelid(Oid objectId)

1788{

1789 if (!currentEventTriggerState ||

1790 currentEventTriggerState->commandCollectionInhibited)

1791 return;

1792

1793 currentEventTriggerState->currentCommand->d.alterTable.objectId = objectId;

1794}

1795

1796/*

1797 * EventTriggerCollectAlterTableSubcmd

1798 * Save data about a single part of an ALTER TABLE.

1799 *

1800 * Several different commands go through this path, but apart from ALTER TABLE

1801 * itself, they are all concerned with AlterTableCmd nodes that are generated

1802 * internally, so that's all that this code needs to handle at the moment.

1803 */

1804void

1805 EventTriggerCollectAlterTableSubcmd(Node *subcmd, ObjectAddress address)

1806{

1807 MemoryContext oldcxt;

1808 CollectedATSubcmd *newsub;

1809

1810 /* ignore if event trigger context not set, or collection disabled */

1811 if (!currentEventTriggerState ||

1812 currentEventTriggerState->commandCollectionInhibited)

1813 return;

1814

1815 Assert(IsA(subcmd, AlterTableCmd));

1816 Assert(currentEventTriggerState->currentCommand != NULL);

1817 Assert(OidIsValid(currentEventTriggerState->currentCommand->d.alterTable.objectId));

1818

1819 oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);

1820

1821 newsub = palloc(sizeof(CollectedATSubcmd));

1822 newsub->address = address;

1823 newsub->parsetree = copyObject(subcmd);

1824

1825 currentEventTriggerState->currentCommand->d.alterTable.subcmds =

1826 lappend(currentEventTriggerState->currentCommand->d.alterTable.subcmds, newsub);

1827

1828 MemoryContextSwitchTo(oldcxt);

1829}

1830

1831/*

1832 * EventTriggerAlterTableEnd

1833 * Finish up saving an ALTER TABLE command, and add it to command list.

1834 *

1835 * FIXME this API isn't considering the possibility that an xact/subxact is

1836 * aborted partway through. Probably it's best to add an

1837 * AtEOSubXact_EventTriggers() to fix this.

1838 */

1839void

1840 EventTriggerAlterTableEnd(void)

1841{

1842 CollectedCommand *parent;

1843

1844 /* ignore if event trigger context not set, or collection disabled */

1845 if (!currentEventTriggerState ||

1846 currentEventTriggerState->commandCollectionInhibited)

1847 return;

1848

1849 parent = currentEventTriggerState->currentCommand->parent;

1850

1851 /* If no subcommands, don't collect */

1852 if (currentEventTriggerState->currentCommand->d.alterTable.subcmds != NIL)

1853 {

1854 MemoryContext oldcxt;

1855

1856 oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);

1857

1858 currentEventTriggerState->commandList =

1859 lappend(currentEventTriggerState->commandList,

1860 currentEventTriggerState->currentCommand);

1861

1862 MemoryContextSwitchTo(oldcxt);

1863 }

1864 else

1865 pfree(currentEventTriggerState->currentCommand);

1866

1867 currentEventTriggerState->currentCommand = parent;

1868}

1869

1870/*

1871 * EventTriggerCollectGrant

1872 * Save data about a GRANT/REVOKE command being executed

1873 *

1874 * This function creates a copy of the InternalGrant, as the original might

1875 * not have the right lifetime.

1876 */

1877void

1878 EventTriggerCollectGrant(InternalGrant *istmt)

1879{

1880 MemoryContext oldcxt;

1881 CollectedCommand *command;

1882 InternalGrant *icopy;

1883 ListCell *cell;

1884

1885 /* ignore if event trigger context not set, or collection disabled */

1886 if (!currentEventTriggerState ||

1887 currentEventTriggerState->commandCollectionInhibited)

1888 return;

1889

1890 oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);

1891

1892 /*

1893 * This is tedious, but necessary.

1894 */

1895 icopy = palloc(sizeof(InternalGrant));

1896 memcpy(icopy, istmt, sizeof(InternalGrant));

1897 icopy->objects = list_copy(istmt->objects);

1898 icopy->grantees = list_copy(istmt->grantees);

1899 icopy->col_privs = NIL;

1900 foreach(cell, istmt->col_privs)

1901 icopy->col_privs = lappend(icopy->col_privs, copyObject(lfirst(cell)));

1902

1903 /* Now collect it, using the copied InternalGrant */

1904 command = palloc(sizeof(CollectedCommand));

1905 command->type = SCT_Grant;

1906 command->in_extension = creating_extension;

1907 command->d.grant.istmt = icopy;

1908 command->parsetree = NULL;

1909

1910 currentEventTriggerState->commandList =

1911 lappend(currentEventTriggerState->commandList, command);

1912

1913 MemoryContextSwitchTo(oldcxt);

1914}

1915

1916/*

1917 * EventTriggerCollectAlterOpFam

1918 * Save data about an ALTER OPERATOR FAMILY ADD/DROP command being

1919 * executed

1920 */

1921void

1922 EventTriggerCollectAlterOpFam(AlterOpFamilyStmt *stmt, Oid opfamoid,

1923 List *operators, List *procedures)

1924{

1925 MemoryContext oldcxt;

1926 CollectedCommand *command;

1927

1928 /* ignore if event trigger context not set, or collection disabled */

1929 if (!currentEventTriggerState ||

1930 currentEventTriggerState->commandCollectionInhibited)

1931 return;

1932

1933 oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);

1934

1935 command = palloc(sizeof(CollectedCommand));

1936 command->type = SCT_AlterOpFamily;

1937 command->in_extension = creating_extension;

1938 ObjectAddressSet(command->d.opfam.address,

1939 OperatorFamilyRelationId, opfamoid);

1940 command->d.opfam.operators = operators;

1941 command->d.opfam.procedures = procedures;

1942 command->parsetree = (Node *) copyObject(stmt);

1943

1944 currentEventTriggerState->commandList =

1945 lappend(currentEventTriggerState->commandList, command);

1946

1947 MemoryContextSwitchTo(oldcxt);

1948}

1949

1950/*

1951 * EventTriggerCollectCreateOpClass

1952 * Save data about a CREATE OPERATOR CLASS command being executed

1953 */

1954void

1955 EventTriggerCollectCreateOpClass(CreateOpClassStmt *stmt, Oid opcoid,

1956 List *operators, List *procedures)

1957{

1958 MemoryContext oldcxt;

1959 CollectedCommand *command;

1960

1961 /* ignore if event trigger context not set, or collection disabled */

1962 if (!currentEventTriggerState ||

1963 currentEventTriggerState->commandCollectionInhibited)

1964 return;

1965

1966 oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);

1967

1968 command = palloc0(sizeof(CollectedCommand));

1969 command->type = SCT_CreateOpClass;

1970 command->in_extension = creating_extension;

1971 ObjectAddressSet(command->d.createopc.address,

1972 OperatorClassRelationId, opcoid);

1973 command->d.createopc.operators = operators;

1974 command->d.createopc.procedures = procedures;

1975 command->parsetree = (Node *) copyObject(stmt);

1976

1977 currentEventTriggerState->commandList =

1978 lappend(currentEventTriggerState->commandList, command);

1979

1980 MemoryContextSwitchTo(oldcxt);

1981}

1982

1983/*

1984 * EventTriggerCollectAlterTSConfig

1985 * Save data about an ALTER TEXT SEARCH CONFIGURATION command being

1986 * executed

1987 */

1988void

1989 EventTriggerCollectAlterTSConfig(AlterTSConfigurationStmt *stmt, Oid cfgId,

1990 Oid *dictIds, int ndicts)

1991{

1992 MemoryContext oldcxt;

1993 CollectedCommand *command;

1994

1995 /* ignore if event trigger context not set, or collection disabled */

1996 if (!currentEventTriggerState ||

1997 currentEventTriggerState->commandCollectionInhibited)

1998 return;

1999

2000 oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);

2001

2002 command = palloc0(sizeof(CollectedCommand));

2003 command->type = SCT_AlterTSConfig;

2004 command->in_extension = creating_extension;

2005 ObjectAddressSet(command->d.atscfg.address,

2006 TSConfigRelationId, cfgId);

2007 command->d.atscfg.dictIds = palloc(sizeof(Oid) * ndicts);

2008 memcpy(command->d.atscfg.dictIds, dictIds, sizeof(Oid) * ndicts);

2009 command->d.atscfg.ndicts = ndicts;

2010 command->parsetree = (Node *) copyObject(stmt);

2011

2012 currentEventTriggerState->commandList =

2013 lappend(currentEventTriggerState->commandList, command);

2014

2015 MemoryContextSwitchTo(oldcxt);

2016}

2017

2018/*

2019 * EventTriggerCollectAlterDefPrivs

2020 * Save data about an ALTER DEFAULT PRIVILEGES command being

2021 * executed

2022 */

2023void

2024 EventTriggerCollectAlterDefPrivs(AlterDefaultPrivilegesStmt *stmt)

2025{

2026 MemoryContext oldcxt;

2027 CollectedCommand *command;

2028

2029 /* ignore if event trigger context not set, or collection disabled */

2030 if (!currentEventTriggerState ||

2031 currentEventTriggerState->commandCollectionInhibited)

2032 return;

2033

2034 oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);

2035

2036 command = palloc0(sizeof(CollectedCommand));

2037 command->type = SCT_AlterDefaultPrivileges;

2038 command->d.defprivs.objtype = stmt->action->objtype;

2039 command->in_extension = creating_extension;

2040 command->parsetree = (Node *) copyObject(stmt);

2041

2042 currentEventTriggerState->commandList =

2043 lappend(currentEventTriggerState->commandList, command);

2044 MemoryContextSwitchTo(oldcxt);

2045}

2046

2047/*

2048 * In a ddl_command_end event trigger, this function reports the DDL commands

2049 * being run.

2050 */

2051Datum

2052 pg_event_trigger_ddl_commands(PG_FUNCTION_ARGS)

2053{

2054 ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;

2055 ListCell *lc;

2056

2057 /*

2058 * Protect this function from being called out of context

2059 */

2060 if (!currentEventTriggerState)

2061 ereport(ERROR,

2062 (errcode(ERRCODE_E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED),

2063 errmsg("%s can only be called in an event trigger function",

2064 "pg_event_trigger_ddl_commands()")));

2065

2066 /* Build tuplestore to hold the result rows */

2067 InitMaterializedSRF(fcinfo, 0);

2068

2069 foreach(lc, currentEventTriggerState->commandList)

2070 {

2071 CollectedCommand *cmd = lfirst(lc);

2072 Datum values[9];

2073 bool nulls[9] = {0};

2074 ObjectAddress addr;

2075 int i = 0;

2076

2077 /*

2078 * For IF NOT EXISTS commands that attempt to create an existing

2079 * object, the returned OID is Invalid. Don't return anything.

2080 *

2081 * One might think that a viable alternative would be to look up the

2082 * Oid of the existing object and run the deparse with that. But

2083 * since the parse tree might be different from the one that created

2084 * the object in the first place, we might not end up in a consistent

2085 * state anyway.

2086 */

2087 if (cmd->type == SCT_Simple &&

2088 !OidIsValid(cmd->d.simple.address.objectId))

2089 continue;

2090

2091 switch (cmd->type)

2092 {

2093 case SCT_Simple:

2094 case SCT_AlterTable:

2095 case SCT_AlterOpFamily:

2096 case SCT_CreateOpClass:

2097 case SCT_AlterTSConfig:

2098 {

2099 char *identity;

2100 char *type;

2101 char *schema = NULL;

2102

2103 if (cmd->type == SCT_Simple)

2104 addr = cmd->d.simple.address;

2105 else if (cmd->type == SCT_AlterTable)

2106 ObjectAddressSet(addr,

2107 cmd->d.alterTable.classId,

2108 cmd->d.alterTable.objectId);

2109 else if (cmd->type == SCT_AlterOpFamily)

2110 addr = cmd->d.opfam.address;

2111 else if (cmd->type == SCT_CreateOpClass)

2112 addr = cmd->d.createopc.address;

2113 else if (cmd->type == SCT_AlterTSConfig)

2114 addr = cmd->d.atscfg.address;

2115

2116 /*

2117 * If an object was dropped in the same command we may end

2118 * up in a situation where we generated a message but can

2119 * no longer look for the object information, so skip it

2120 * rather than failing. This can happen for example with

2121 * some subcommand combinations of ALTER TABLE.

2122 */

2123 identity = getObjectIdentity(&addr, true);

2124 if (identity == NULL)

2125 continue;

2126

2127 /* The type can never be NULL. */

2128 type = getObjectTypeDescription(&addr, true);

2129

2130 /*

2131 * Obtain schema name, if any ("pg_temp" if a temp

2132 * object). If the object class is not in the supported

2133 * list here, we assume it's a schema-less object type,

2134 * and thus "schema" remains set to NULL.

2135 */

2136 if (is_objectclass_supported(addr.classId))

2137 {

2138 AttrNumber nspAttnum;

2139

2140 nspAttnum = get_object_attnum_namespace(addr.classId);

2141 if (nspAttnum != InvalidAttrNumber)

2142 {

2143 Relation catalog;

2144 HeapTuple objtup;

2145 Oid schema_oid;

2146 bool isnull;

2147

2148 catalog = table_open(addr.classId, AccessShareLock);

2149 objtup = get_catalog_object_by_oid(catalog,

2150 get_object_attnum_oid(addr.classId),

2151 addr.objectId);

2152 if (!HeapTupleIsValid(objtup))

2153 elog(ERROR, "cache lookup failed for object %u/%u",

2154 addr.classId, addr.objectId);

2155 schema_oid =

2156 DatumGetObjectId(heap_getattr(objtup, nspAttnum,

2157 RelationGetDescr(catalog), &isnull));

2158 if (isnull)

2159 elog(ERROR,

2160 "invalid null namespace in object %u/%u/%d",

2161 addr.classId, addr.objectId, addr.objectSubId);

2162 schema = get_namespace_name_or_temp(schema_oid);

2163

2164 table_close(catalog, AccessShareLock);

2165 }

2166 }

2167

2168 /* classid */

2169 values[i++] = ObjectIdGetDatum(addr.classId);

2170 /* objid */

2171 values[i++] = ObjectIdGetDatum(addr.objectId);

2172 /* objsubid */

2173 values[i++] = Int32GetDatum(addr.objectSubId);

2174 /* command tag */

2175 values[i++] = CStringGetTextDatum(CreateCommandName(cmd->parsetree));

2176 /* object_type */

2177 values[i++] = CStringGetTextDatum(type);

2178 /* schema */

2179 if (schema == NULL)

2180 nulls[i++] = true;

2181 else

2182 values[i++] = CStringGetTextDatum(schema);

2183 /* identity */

2184 values[i++] = CStringGetTextDatum(identity);

2185 /* in_extension */

2186 values[i++] = BoolGetDatum(cmd->in_extension);

2187 /* command */

2188 values[i++] = PointerGetDatum(cmd);

2189 }

2190 break;

2191

2192 case SCT_AlterDefaultPrivileges:

2193 /* classid */

2194 nulls[i++] = true;

2195 /* objid */

2196 nulls[i++] = true;

2197 /* objsubid */

2198 nulls[i++] = true;

2199 /* command tag */

2200 values[i++] = CStringGetTextDatum(CreateCommandName(cmd->parsetree));

2201 /* object_type */

2202 values[i++] = CStringGetTextDatum(stringify_adefprivs_objtype(cmd->d.defprivs.objtype));

2203 /* schema */

2204 nulls[i++] = true;

2205 /* identity */

2206 nulls[i++] = true;

2207 /* in_extension */

2208 values[i++] = BoolGetDatum(cmd->in_extension);

2209 /* command */

2210 values[i++] = PointerGetDatum(cmd);

2211 break;

2212

2213 case SCT_Grant:

2214 /* classid */

2215 nulls[i++] = true;

2216 /* objid */

2217 nulls[i++] = true;

2218 /* objsubid */

2219 nulls[i++] = true;

2220 /* command tag */

2221 values[i++] = CStringGetTextDatum(cmd->d.grant.istmt->is_grant ?

2222 "GRANT" : "REVOKE");

2223 /* object_type */

2224 values[i++] = CStringGetTextDatum(stringify_grant_objtype(cmd->d.grant.istmt->objtype));

2225 /* schema */

2226 nulls[i++] = true;

2227 /* identity */

2228 nulls[i++] = true;

2229 /* in_extension */

2230 values[i++] = BoolGetDatum(cmd->in_extension);

2231 /* command */

2232 values[i++] = PointerGetDatum(cmd);

2233 break;

2234 }

2235

2236 tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,

2237 values, nulls);

2238 }

2239

2240 PG_RETURN_VOID();

2241}

2242

2243/*

2244 * Return the ObjectType as a string, as it would appear in GRANT and

2245 * REVOKE commands.

2246 */

2247static const char *

2248 stringify_grant_objtype(ObjectType objtype)

2249{

2250 switch (objtype)

2251 {

2252 case OBJECT_COLUMN:

2253 return "COLUMN";

2254 case OBJECT_TABLE:

2255 return "TABLE";

2256 case OBJECT_SEQUENCE:

2257 return "SEQUENCE";

2258 case OBJECT_DATABASE:

2259 return "DATABASE";

2260 case OBJECT_DOMAIN:

2261 return "DOMAIN";

2262 case OBJECT_FDW:

2263 return "FOREIGN DATA WRAPPER";

2264 case OBJECT_FOREIGN_SERVER:

2265 return "FOREIGN SERVER";

2266 case OBJECT_FUNCTION:

2267 return "FUNCTION";

2268 case OBJECT_LANGUAGE:

2269 return "LANGUAGE";

2270 case OBJECT_LARGEOBJECT:

2271 return "LARGE OBJECT";

2272 case OBJECT_SCHEMA:

2273 return "SCHEMA";

2274 case OBJECT_PARAMETER_ACL:

2275 return "PARAMETER";

2276 case OBJECT_PROCEDURE:

2277 return "PROCEDURE";

2278 case OBJECT_ROUTINE:

2279 return "ROUTINE";

2280 case OBJECT_TABLESPACE:

2281 return "TABLESPACE";

2282 case OBJECT_TYPE:

2283 return "TYPE";

2284 /* these currently aren't used */

2285 case OBJECT_ACCESS_METHOD:

2286 case OBJECT_AGGREGATE:

2287 case OBJECT_AMOP:

2288 case OBJECT_AMPROC:

2289 case OBJECT_ATTRIBUTE:

2290 case OBJECT_CAST:

2291 case OBJECT_COLLATION:

2292 case OBJECT_CONVERSION:

2293 case OBJECT_DEFAULT:

2294 case OBJECT_DEFACL:

2295 case OBJECT_DOMCONSTRAINT:

2296 case OBJECT_EVENT_TRIGGER:

2297 case OBJECT_EXTENSION:

2298 case OBJECT_FOREIGN_TABLE:

2299 case OBJECT_INDEX:

2300 case OBJECT_MATVIEW:

2301 case OBJECT_OPCLASS:

2302 case OBJECT_OPERATOR:

2303 case OBJECT_OPFAMILY:

2304 case OBJECT_POLICY:

2305 case OBJECT_PUBLICATION:

2306 case OBJECT_PUBLICATION_NAMESPACE:

2307 case OBJECT_PUBLICATION_REL:

2308 case OBJECT_ROLE:

2309 case OBJECT_RULE:

2310 case OBJECT_STATISTIC_EXT:

2311 case OBJECT_SUBSCRIPTION:

2312 case OBJECT_TABCONSTRAINT:

2313 case OBJECT_TRANSFORM:

2314 case OBJECT_TRIGGER:

2315 case OBJECT_TSCONFIGURATION:

2316 case OBJECT_TSDICTIONARY:

2317 case OBJECT_TSPARSER:

2318 case OBJECT_TSTEMPLATE:

2319 case OBJECT_USER_MAPPING:

2320 case OBJECT_VIEW:

2321 elog(ERROR, "unsupported object type: %d", (int) objtype);

2322 }

2323

2324 return "???"; /* keep compiler quiet */

2325}

2326

2327/*

2328 * Return the ObjectType as a string; as above, but use the spelling

2329 * in ALTER DEFAULT PRIVILEGES commands instead. Generally this is just

2330 * the plural.

2331 */

2332static const char *

2333 stringify_adefprivs_objtype(ObjectType objtype)

2334{

2335 switch (objtype)

2336 {

2337 case OBJECT_COLUMN:

2338 return "COLUMNS";

2339 case OBJECT_TABLE:

2340 return "TABLES";

2341 case OBJECT_SEQUENCE:

2342 return "SEQUENCES";

2343 case OBJECT_DATABASE:

2344 return "DATABASES";

2345 case OBJECT_DOMAIN:

2346 return "DOMAINS";

2347 case OBJECT_FDW:

2348 return "FOREIGN DATA WRAPPERS";

2349 case OBJECT_FOREIGN_SERVER:

2350 return "FOREIGN SERVERS";

2351 case OBJECT_FUNCTION:

2352 return "FUNCTIONS";

2353 case OBJECT_LANGUAGE:

2354 return "LANGUAGES";

2355 case OBJECT_LARGEOBJECT:

2356 return "LARGE OBJECTS";

2357 case OBJECT_SCHEMA:

2358 return "SCHEMAS";

2359 case OBJECT_PROCEDURE:

2360 return "PROCEDURES";

2361 case OBJECT_ROUTINE:

2362 return "ROUTINES";

2363 case OBJECT_TABLESPACE:

2364 return "TABLESPACES";

2365 case OBJECT_TYPE:

2366 return "TYPES";

2367 /* these currently aren't used */

2368 case OBJECT_ACCESS_METHOD:

2369 case OBJECT_AGGREGATE:

2370 case OBJECT_AMOP:

2371 case OBJECT_AMPROC:

2372 case OBJECT_ATTRIBUTE:

2373 case OBJECT_CAST:

2374 case OBJECT_COLLATION:

2375 case OBJECT_CONVERSION:

2376 case OBJECT_DEFAULT:

2377 case OBJECT_DEFACL:

2378 case OBJECT_DOMCONSTRAINT:

2379 case OBJECT_EVENT_TRIGGER:

2380 case OBJECT_EXTENSION:

2381 case OBJECT_FOREIGN_TABLE:

2382 case OBJECT_INDEX:

2383 case OBJECT_MATVIEW:

2384 case OBJECT_OPCLASS:

2385 case OBJECT_OPERATOR:

2386 case OBJECT_OPFAMILY:

2387 case OBJECT_PARAMETER_ACL:

2388 case OBJECT_POLICY:

2389 case OBJECT_PUBLICATION:

2390 case OBJECT_PUBLICATION_NAMESPACE:

2391 case OBJECT_PUBLICATION_REL:

2392 case OBJECT_ROLE:

2393 case OBJECT_RULE:

2394 case OBJECT_STATISTIC_EXT:

2395 case OBJECT_SUBSCRIPTION:

2396 case OBJECT_TABCONSTRAINT:

2397 case OBJECT_TRANSFORM:

2398 case OBJECT_TRIGGER:

2399 case OBJECT_TSCONFIGURATION:

2400 case OBJECT_TSDICTIONARY:

2401 case OBJECT_TSPARSER:

2402 case OBJECT_TSTEMPLATE:

2403 case OBJECT_USER_MAPPING:

2404 case OBJECT_VIEW:

2405 elog(ERROR, "unsupported object type: %d", (int) objtype);

2406 }

2407

2408 return "???"; /* keep compiler quiet */

2409}

acl.h

ACLCHECK_NOT_OWNER

@ ACLCHECK_NOT_OWNER

Definition: acl.h:185

aclcheck_error

void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)

Definition: aclchk.c:2652

object_ownercheck

bool object_ownercheck(Oid classid, Oid objectid, Oid roleid)

Definition: aclchk.c:4088

construct_empty_array

ArrayType * construct_empty_array(Oid elmtype)

Definition: arrayfuncs.c:3581

construct_array_builtin

ArrayType * construct_array_builtin(Datum *elems, int nelems, Oid elmtype)

Definition: arrayfuncs.c:3382

AttrNumber

int16 AttrNumber

Definition: attnum.h:21

InvalidAttrNumber

#define InvalidAttrNumber

Definition: attnum.h:23

bms_is_member

bool bms_is_member(int x, const Bitmapset *a)

Definition: bitmapset.c:510

bms_is_empty

#define bms_is_empty(a)

Definition: bitmapset.h:118

Definition: blutils.c:224

values

static Datum values[MAXATTR]

Definition: bootstrap.c:153

builtins.h

CStringGetTextDatum

#define CStringGetTextDatum(s)

Definition: builtins.h:97

NameStr

#define NameStr(name)

Definition: c.h:751

OidIsValid

#define OidIsValid(objectId)

Definition: c.h:774

GetNewOidWithIndex

Oid GetNewOidWithIndex(Relation relation, Oid indexId, AttrNumber oidcolumn)

Definition: catalog.c:448

catalog.h

GetCommandTagName

const char * GetCommandTagName(CommandTag commandTag)

Definition: cmdtag.c:47

GetCommandTagEnum

CommandTag GetCommandTagEnum(const char *commandname)

Definition: cmdtag.c:83

command_tag_event_trigger_ok

bool command_tag_event_trigger_ok(CommandTag commandTag)

Definition: cmdtag.c:66

command_tag_table_rewrite_ok

bool command_tag_table_rewrite_ok(CommandTag commandTag)

Definition: cmdtag.c:72

CommandTag

Definition: cmdtag.h:23

deparse_utility.h

SCT_Simple

@ SCT_Simple

Definition: deparse_utility.h:26

SCT_AlterTSConfig

@ SCT_AlterTSConfig

Definition: deparse_utility.h:32

SCT_AlterDefaultPrivileges

@ SCT_AlterDefaultPrivileges

Definition: deparse_utility.h:30

SCT_Grant

@ SCT_Grant

Definition: deparse_utility.h:28

SCT_CreateOpClass

@ SCT_CreateOpClass

Definition: deparse_utility.h:31

SCT_AlterOpFamily

@ SCT_AlterOpFamily

Definition: deparse_utility.h:29

SCT_AlterTable

@ SCT_AlterTable

Definition: deparse_utility.h:27

dependency.h

DEPENDENCY_NORMAL

@ DEPENDENCY_NORMAL

Definition: dependency.h:33

errhint

int errhint(const char *fmt,...)

Definition: elog.c:1321

errcode

int errcode(int sqlerrcode)

Definition: elog.c:854

errmsg

int errmsg(const char *fmt,...)

Definition: elog.c:1071

PG_TRY

#define PG_TRY(...)

Definition: elog.h:372

PG_END_TRY

#define PG_END_TRY(...)

Definition: elog.h:397

DEBUG1

#define DEBUG1

Definition: elog.h:30

ERROR

#define ERROR

Definition: elog.h:39

elog

#define elog(elevel,...)

Definition: elog.h:226

PG_FINALLY

#define PG_FINALLY(...)

Definition: elog.h:389

ereport

#define ereport(elevel,...)

Definition: elog.h:150

EventTriggerUndoInhibitCommandCollection

void EventTriggerUndoInhibitCommandCollection(void)

Definition: event_trigger.c:1693

EventTriggerSQLDropAddObject

void EventTriggerSQLDropAddObject(const ObjectAddress *object, bool original, bool normal)

Definition: event_trigger.c:1277

AlterEventTriggerOwner_internal

static void AlterEventTriggerOwner_internal(Relation rel, HeapTuple tup, Oid newOwnerId)

Definition: event_trigger.c:539

EventTriggerAlterTableStart

void EventTriggerAlterTableStart(Node *parsetree)

Definition: event_trigger.c:1753

EventTriggerOnLogin

void EventTriggerOnLogin(void)

Definition: event_trigger.c:897

EventTriggerCollectAlterDefPrivs

void EventTriggerCollectAlterDefPrivs(AlterDefaultPrivilegesStmt *stmt)

Definition: event_trigger.c:2024

trackDroppedObjectsNeeded

bool trackDroppedObjectsNeeded(void)

Definition: event_trigger.c:1245

pg_event_trigger_ddl_commands

Datum pg_event_trigger_ddl_commands(PG_FUNCTION_ARGS)

Definition: event_trigger.c:2052

EventTriggerDDLCommandStart

void EventTriggerDDLCommandStart(Node *parsetree)

Definition: event_trigger.c:725

EventTriggerInhibitCommandCollection

void EventTriggerInhibitCommandCollection(void)

Definition: event_trigger.c:1681

EventTriggerBeginCompleteQuery

bool EventTriggerBeginCompleteQuery(void)

Definition: event_trigger.c:1183

filter_event_trigger

static bool filter_event_trigger(CommandTag tag, EventTriggerCacheItem *item)

Definition: event_trigger.c:598

EventTriggerTableRewrite

void EventTriggerTableRewrite(Node *parsetree, Oid tableOid, int reason)

Definition: event_trigger.c:1003

obtain_object_name_namespace

static bool obtain_object_name_namespace(const ObjectAddress *object, SQLDropObject *obj)

Definition: event_trigger.c:1440

EventTriggerSupportsObject

bool EventTriggerSupportsObject(const ObjectAddress *object)

Definition: event_trigger.c:1157

EventTriggerSupportsObjectType

bool EventTriggerSupportsObjectType(ObjectType obtype)

Definition: event_trigger.c:1133

CreateEventTrigger

Oid CreateEventTrigger(CreateEventTrigStmt *stmt)

Definition: event_trigger.c:124

validate_table_rewrite_tags

static void validate_table_rewrite_tags(const char *filtervar, List *taglist)

Definition: event_trigger.c:243

AlterEventTrigger

Oid AlterEventTrigger(AlterEventTrigStmt *stmt)

Definition: event_trigger.c:427

stringify_adefprivs_objtype

static const char * stringify_adefprivs_objtype(ObjectType objtype)

Definition: event_trigger.c:2333

EventTriggerCollectGrant

void EventTriggerCollectGrant(InternalGrant *istmt)

Definition: event_trigger.c:1878

EventTriggerQueryState

struct EventTriggerQueryState EventTriggerQueryState

pg_event_trigger_table_rewrite_reason

Datum pg_event_trigger_table_rewrite_reason(PG_FUNCTION_ARGS)

Definition: event_trigger.c:1641

EventTriggerSQLDrop

void EventTriggerSQLDrop(Node *parsetree)

Definition: event_trigger.c:824

pg_event_trigger_dropped_objects

Datum pg_event_trigger_dropped_objects(PG_FUNCTION_ARGS)

Definition: event_trigger.c:1524

EventTriggerGetTag

static CommandTag EventTriggerGetTag(Node *parsetree, EventTriggerEvent event)

Definition: event_trigger.c:624

EventTriggerEndCompleteQuery

void EventTriggerEndCompleteQuery(void)

Definition: event_trigger.c:1227

pg_event_trigger_table_rewrite_oid

Datum pg_event_trigger_table_rewrite_oid(PG_FUNCTION_ARGS)

Definition: event_trigger.c:1620

validate_ddl_tags

static void validate_ddl_tags(const char *filtervar, List *taglist)

Definition: event_trigger.c:216

AlterEventTriggerOwner_oid

void AlterEventTriggerOwner_oid(Oid trigOid, Oid newOwnerId)

Definition: event_trigger.c:514

EventTriggerAlterTableRelid

void EventTriggerAlterTableRelid(Oid objectId)

Definition: event_trigger.c:1787

EventTriggerCollectAlterTSConfig

void EventTriggerCollectAlterTSConfig(AlterTSConfigurationStmt *stmt, Oid cfgId, Oid *dictIds, int ndicts)

Definition: event_trigger.c:1989

currentEventTriggerState

static EventTriggerQueryState * currentEventTriggerState

Definition: event_trigger.c:83

SQLDropObject

struct SQLDropObject SQLDropObject

EventTriggerAlterTableEnd

void EventTriggerAlterTableEnd(void)

Definition: event_trigger.c:1840

EventTriggerCollectAlterOpFam

void EventTriggerCollectAlterOpFam(AlterOpFamilyStmt *stmt, Oid opfamoid, List *operators, List *procedures)

Definition: event_trigger.c:1922

event_triggers

bool event_triggers

Definition: event_trigger.c:86

SetDatabaseHasLoginEventTriggers

static void SetDatabaseHasLoginEventTriggers(void)

Definition: event_trigger.c:390

EventTriggerCollectCreateOpClass

void EventTriggerCollectCreateOpClass(CreateOpClassStmt *stmt, Oid opcoid, List *operators, List *procedures)

Definition: event_trigger.c:1955

error_duplicate_filter_variable

static void error_duplicate_filter_variable(const char *defname)

Definition: event_trigger.c:265

EventTriggerCollectSimpleCommand

void EventTriggerCollectSimpleCommand(ObjectAddress address, ObjectAddress secondaryObject, Node *parsetree)

Definition: event_trigger.c:1715

stringify_grant_objtype

static const char * stringify_grant_objtype(ObjectType objtype)

Definition: event_trigger.c:2248

EventTriggerDDLCommandEnd

void EventTriggerDDLCommandEnd(Node *parsetree)

Definition: event_trigger.c:776

insert_event_trigger_tuple

static Oid insert_event_trigger_tuple(const char *trigname, const char *eventname, Oid evtOwner, Oid funcoid, List *taglist)

Definition: event_trigger.c:277

EventTriggerCommonSetup

static List * EventTriggerCommonSetup(Node *parsetree, EventTriggerEvent event, const char *eventstr, EventTriggerData *trigdata, bool unfiltered)

Definition: event_trigger.c:638

EventTriggerCollectAlterTableSubcmd

void EventTriggerCollectAlterTableSubcmd(Node *subcmd, ObjectAddress address)

Definition: event_trigger.c:1805

get_event_trigger_oid

Oid get_event_trigger_oid(const char *trigname, bool missing_ok)

Definition: event_trigger.c:579

AlterEventTriggerOwner

ObjectAddress AlterEventTriggerOwner(const char *name, Oid newOwnerId)

Definition: event_trigger.c:479

EventTriggerInvoke

static void EventTriggerInvoke(List *fn_oid_list, EventTriggerData *trigdata)

Definition: event_trigger.c:1068

filter_list_to_array

static Datum filter_list_to_array(List *filterlist)

Definition: event_trigger.c:360

event_trigger.h

EventCacheLookup

List * EventCacheLookup(EventTriggerEvent event)

Definition: evtcache.c:63

evtcache.h

EventTriggerEvent

Definition: evtcache.h:21

EVT_SQLDrop

@ EVT_SQLDrop

Definition: evtcache.h:24

EVT_Login

@ EVT_Login

Definition: evtcache.h:26

EVT_DDLCommandEnd

@ EVT_DDLCommandEnd

Definition: evtcache.h:23

EVT_DDLCommandStart

@ EVT_DDLCommandStart

Definition: evtcache.h:22

EVT_TableRewrite

@ EVT_TableRewrite

Definition: evtcache.h:25

creating_extension

bool creating_extension

Definition: extension.c:77

extension.h

fmgr_info

void fmgr_info(Oid functionId, FmgrInfo *finfo)

Definition: fmgr.c:128

PG_RETURN_VOID

#define PG_RETURN_VOID()

Definition: fmgr.h:349

InitFunctionCallInfoData

#define InitFunctionCallInfoData(Fcinfo, Flinfo, Nargs, Collation, Context, Resultinfo)

Definition: fmgr.h:150

LOCAL_FCINFO

#define LOCAL_FCINFO(name, nargs)

Definition: fmgr.h:110

FunctionCallInvoke

#define FunctionCallInvoke(fcinfo)

Definition: fmgr.h:172

PG_RETURN_INT32

#define PG_RETURN_INT32(x)

Definition: fmgr.h:354

PG_RETURN_OID

#define PG_RETURN_OID(x)

Definition: fmgr.h:360

PG_FUNCTION_ARGS

#define PG_FUNCTION_ARGS

Definition: fmgr.h:193

InitMaterializedSRF

void InitMaterializedSRF(FunctionCallInfo fcinfo, bits32 flags)

Definition: funcapi.c:76

funcapi.h

systable_endscan

void systable_endscan(SysScanDesc sysscan)

Definition: genam.c:603

systable_inplace_update_cancel

void systable_inplace_update_cancel(void *state)

Definition: genam.c:902

systable_inplace_update_begin

void systable_inplace_update_begin(Relation relation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, const ScanKeyData *key, HeapTuple *oldtupcopy, void **state)

Definition: genam.c:807

systable_inplace_update_finish

void systable_inplace_update_finish(void *state, HeapTuple tuple)

Definition: genam.c:883

systable_getnext

HeapTuple systable_getnext(SysScanDesc sysscan)

Definition: genam.c:514

systable_beginscan

SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)

Definition: genam.c:388

MyDatabaseHasLoginEventTriggers

bool MyDatabaseHasLoginEventTriggers

Definition: globals.c:98

IsUnderPostmaster

bool IsUnderPostmaster

Definition: globals.c:120

MyDatabaseId

Oid MyDatabaseId

Definition: globals.c:94

Assert

Assert(PointerIsAligned(start, uint64))

heapam.h

heap_form_tuple

HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)

Definition: heaptuple.c:1117

heap_freetuple

void heap_freetuple(HeapTuple htup)

Definition: heaptuple.c:1435

HeapTupleIsValid

#define HeapTupleIsValid(tuple)

Definition: htup.h:78

htup_details.h

heap_getattr

static Datum heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)

Definition: htup_details.h:904

GETSTRUCT

static void * GETSTRUCT(const HeapTupleData *tuple)

Definition: htup_details.h:728

ilist.h

slist_init

static void slist_init(slist_head *head)

Definition: ilist.h:986

slist_is_empty

static bool slist_is_empty(const slist_head *head)

Definition: ilist.h:995

slist_push_head

static void slist_push_head(slist_head *head, slist_node *node)

Definition: ilist.h:1006

slist_container

#define slist_container(type, membername, ptr)

Definition: ilist.h:1106

slist_foreach

#define slist_foreach(iter, lhead)

Definition: ilist.h:1132

stmt

#define stmt

Definition: indent_codes.h:59

CatalogTupleUpdate

void CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)

Definition: indexing.c:313

CatalogTupleInsert

void CatalogTupleInsert(Relation heapRel, HeapTuple tup)

Definition: indexing.c:233

indexing.h

value

static struct @169 value

i

int i

Definition: isn.c:77

if

if(TABLE==NULL||TABLE_index==NULL)

Definition: isn.c:81

lappend

List * lappend(List *list, void *datum)

Definition: list.c:339

list_copy

List * list_copy(const List *oldlist)

Definition: list.c:1573

lappend_oid

List * lappend_oid(List *list, Oid datum)

Definition: list.c:375

list_free

void list_free(List *list)

Definition: list.c:1546

UnlockTuple

void UnlockTuple(Relation relation, const ItemPointerData *tid, LOCKMODE lockmode)

Definition: lmgr.c:601

LockSharedObject

void LockSharedObject(Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)

Definition: lmgr.c:1088

ConditionalLockSharedObject

bool ConditionalLockSharedObject(Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)

Definition: lmgr.c:1112

lmgr.h

AccessExclusiveLock

#define AccessExclusiveLock

Definition: lockdefs.h:43

AccessShareLock

#define AccessShareLock

Definition: lockdefs.h:36

InplaceUpdateTupleLock

#define InplaceUpdateTupleLock

Definition: lockdefs.h:48

RowExclusiveLock

#define RowExclusiveLock

Definition: lockdefs.h:38

get_namespace_name_or_temp

char * get_namespace_name_or_temp(Oid nspid)

Definition: lsyscache.c:3557

get_namespace_name

char * get_namespace_name(Oid nspid)

Definition: lsyscache.c:3533

get_func_rettype

Oid get_func_rettype(Oid funcid)

Definition: lsyscache.c:1822

lsyscache.h

MemoryContextAlloc

void * MemoryContextAlloc(MemoryContext context, Size size)

Definition: mcxt.c:1229

MemoryContextReset

void MemoryContextReset(MemoryContext context)

Definition: mcxt.c:400

pstrdup

char * pstrdup(const char *in)

Definition: mcxt.c:1759

pfree

void pfree(void *pointer)

Definition: mcxt.c:1594

palloc0

void * palloc0(Size size)

Definition: mcxt.c:1395

TopMemoryContext

MemoryContext TopMemoryContext

Definition: mcxt.c:166

palloc

void * palloc(Size size)

Definition: mcxt.c:1365

CurrentMemoryContext

MemoryContext CurrentMemoryContext

Definition: mcxt.c:160

MemoryContextDelete

void MemoryContextDelete(MemoryContext context)

Definition: mcxt.c:469

memutils.h

AllocSetContextCreate

#define AllocSetContextCreate

Definition: memutils.h:129

ALLOCSET_DEFAULT_SIZES

#define ALLOCSET_DEFAULT_SIZES

Definition: memutils.h:160

miscadmin.h

GetUserId

Oid GetUserId(void)

Definition: miscinit.c:469

namestrcmp

int namestrcmp(Name name, const char *str)

Definition: name.c:247

namestrcpy

void namestrcpy(Name name, const char *str)

Definition: name.c:233

NameListToString

char * NameListToString(const List *names)

Definition: namespace.c:3664

isTempNamespace

bool isTempNamespace(Oid namespaceId)

Definition: namespace.c:3719

isAnyTempNamespace

bool isAnyTempNamespace(Oid namespaceId)

Definition: namespace.c:3757

sort-test.key

key

Definition: sort-test.py:19

IsA

#define IsA(nodeptr, _type_)

Definition: nodes.h:164

copyObject

#define copyObject(obj)

Definition: nodes.h:232

objectaccess.h

InvokeObjectPostCreateHook

#define InvokeObjectPostCreateHook(classId, objectId, subId)

Definition: objectaccess.h:173

InvokeObjectPostAlterHook

#define InvokeObjectPostAlterHook(classId, objectId, subId)

Definition: objectaccess.h:197

getObjectTypeDescription

char * getObjectTypeDescription(const ObjectAddress *object, bool missing_ok)

Definition: objectaddress.c:4496

strlist_to_textarray

ArrayType * strlist_to_textarray(List *list)

Definition: objectaddress.c:6130

get_object_namensp_unique

bool get_object_namensp_unique(Oid class_id)

Definition: objectaddress.c:2725

get_catalog_object_by_oid

HeapTuple get_catalog_object_by_oid(Relation catalog, AttrNumber oidcol, Oid objectId)

Definition: objectaddress.c:2789

get_object_attnum_oid

AttrNumber get_object_attnum_oid(Oid class_id)

Definition: objectaddress.c:2660

get_object_attnum_namespace

AttrNumber get_object_attnum_namespace(Oid class_id)

Definition: objectaddress.c:2676

getObjectIdentityParts

char * getObjectIdentityParts(const ObjectAddress *object, List **objname, List **objargs, bool missing_ok)

Definition: objectaddress.c:4838

get_object_attnum_name

AttrNumber get_object_attnum_name(Oid class_id)

Definition: objectaddress.c:2668

getObjectIdentity

char * getObjectIdentity(const ObjectAddress *object, bool missing_ok)

Definition: objectaddress.c:4823

is_objectclass_supported

bool is_objectclass_supported(Oid class_id)

Definition: objectaddress.c:2737

ObjectAddressSet

#define ObjectAddressSet(addr, class_id, object_id)

Definition: objectaddress.h:40

MemoryContextSwitchTo

static MemoryContext MemoryContextSwitchTo(MemoryContext context)

Definition: palloc.h:124

LookupFuncName

Oid LookupFuncName(List *funcname, int nargs, const Oid *argtypes, bool missing_ok)

Definition: parse_func.c:2269

parse_func.h

ObjectType

Definition: parsenodes.h:2324

OBJECT_EVENT_TRIGGER

@ OBJECT_EVENT_TRIGGER

Definition: parsenodes.h:2339

OBJECT_FDW

@ OBJECT_FDW

Definition: parsenodes.h:2341

OBJECT_TSPARSER

@ OBJECT_TSPARSER

Definition: parsenodes.h:2372

OBJECT_COLLATION

@ OBJECT_COLLATION

Definition: parsenodes.h:2332

OBJECT_USER_MAPPING

@ OBJECT_USER_MAPPING

Definition: parsenodes.h:2375

OBJECT_ACCESS_METHOD

@ OBJECT_ACCESS_METHOD

Definition: parsenodes.h:2325

OBJECT_OPCLASS

@ OBJECT_OPCLASS

Definition: parsenodes.h:2349

OBJECT_DEFACL

@ OBJECT_DEFACL

Definition: parsenodes.h:2336

OBJECT_AGGREGATE

@ OBJECT_AGGREGATE

Definition: parsenodes.h:2326

OBJECT_MATVIEW

@ OBJECT_MATVIEW

Definition: parsenodes.h:2348

OBJECT_SCHEMA

@ OBJECT_SCHEMA

Definition: parsenodes.h:2361

OBJECT_POLICY

@ OBJECT_POLICY

Definition: parsenodes.h:2353

OBJECT_OPERATOR

@ OBJECT_OPERATOR

Definition: parsenodes.h:2350

OBJECT_FOREIGN_TABLE

@ OBJECT_FOREIGN_TABLE

Definition: parsenodes.h:2343

OBJECT_TSCONFIGURATION

@ OBJECT_TSCONFIGURATION

Definition: parsenodes.h:2370

OBJECT_OPFAMILY

@ OBJECT_OPFAMILY

Definition: parsenodes.h:2351

OBJECT_DOMAIN

@ OBJECT_DOMAIN

Definition: parsenodes.h:2337

OBJECT_COLUMN

@ OBJECT_COLUMN

Definition: parsenodes.h:2331

OBJECT_TABLESPACE

@ OBJECT_TABLESPACE

Definition: parsenodes.h:2367

OBJECT_ROLE

@ OBJECT_ROLE

Definition: parsenodes.h:2358

OBJECT_ROUTINE

@ OBJECT_ROUTINE

Definition: parsenodes.h:2359

OBJECT_LARGEOBJECT

@ OBJECT_LARGEOBJECT

Definition: parsenodes.h:2347

OBJECT_PUBLICATION_NAMESPACE

@ OBJECT_PUBLICATION_NAMESPACE

Definition: parsenodes.h:2356

OBJECT_PROCEDURE

@ OBJECT_PROCEDURE

Definition: parsenodes.h:2354

OBJECT_EXTENSION

@ OBJECT_EXTENSION

Definition: parsenodes.h:2340

OBJECT_INDEX

@ OBJECT_INDEX

Definition: parsenodes.h:2345

OBJECT_DEFAULT

@ OBJECT_DEFAULT

Definition: parsenodes.h:2335

OBJECT_DATABASE

@ OBJECT_DATABASE

Definition: parsenodes.h:2334

OBJECT_SEQUENCE

@ OBJECT_SEQUENCE

Definition: parsenodes.h:2362

OBJECT_TSTEMPLATE

@ OBJECT_TSTEMPLATE

Definition: parsenodes.h:2373

OBJECT_LANGUAGE

@ OBJECT_LANGUAGE

Definition: parsenodes.h:2346

OBJECT_AMOP

@ OBJECT_AMOP

Definition: parsenodes.h:2327

OBJECT_PUBLICATION_REL

@ OBJECT_PUBLICATION_REL

Definition: parsenodes.h:2357

OBJECT_FOREIGN_SERVER

@ OBJECT_FOREIGN_SERVER

Definition: parsenodes.h:2342

OBJECT_TSDICTIONARY

@ OBJECT_TSDICTIONARY

Definition: parsenodes.h:2371

OBJECT_ATTRIBUTE

@ OBJECT_ATTRIBUTE

Definition: parsenodes.h:2329

OBJECT_PUBLICATION

@ OBJECT_PUBLICATION

Definition: parsenodes.h:2355

OBJECT_RULE

@ OBJECT_RULE

Definition: parsenodes.h:2360

OBJECT_CONVERSION

@ OBJECT_CONVERSION

Definition: parsenodes.h:2333

OBJECT_AMPROC

@ OBJECT_AMPROC

Definition: parsenodes.h:2328

OBJECT_TABLE

@ OBJECT_TABLE

Definition: parsenodes.h:2366

OBJECT_VIEW

@ OBJECT_VIEW

Definition: parsenodes.h:2376

OBJECT_PARAMETER_ACL

@ OBJECT_PARAMETER_ACL

Definition: parsenodes.h:2352

OBJECT_TYPE

@ OBJECT_TYPE

Definition: parsenodes.h:2374

OBJECT_FUNCTION

@ OBJECT_FUNCTION

Definition: parsenodes.h:2344

OBJECT_TABCONSTRAINT

@ OBJECT_TABCONSTRAINT

Definition: parsenodes.h:2365

OBJECT_DOMCONSTRAINT

@ OBJECT_DOMCONSTRAINT

Definition: parsenodes.h:2338

OBJECT_SUBSCRIPTION

@ OBJECT_SUBSCRIPTION

Definition: parsenodes.h:2363

OBJECT_STATISTIC_EXT

@ OBJECT_STATISTIC_EXT

Definition: parsenodes.h:2364

OBJECT_CAST

@ OBJECT_CAST

Definition: parsenodes.h:2330

OBJECT_TRIGGER

@ OBJECT_TRIGGER

Definition: parsenodes.h:2369

OBJECT_TRANSFORM

@ OBJECT_TRANSFORM

Definition: parsenodes.h:2368

GetAttrDefaultColumnAddress

ObjectAddress GetAttrDefaultColumnAddress(Oid attrdefoid)

Definition: pg_attrdef.c:321

pg_attrdef.h

attnum

int16 attnum

Definition: pg_attribute.h:74

pg_auth_members.h

pg_authid.h

data

const void * data

Definition: pg_crc32c_sse42.c:27

pg_database.h

Form_pg_database

FormData_pg_database * Form_pg_database

Definition: pg_database.h:96

recordDependencyOn

void recordDependencyOn(const ObjectAddress *depender, const ObjectAddress *referenced, DependencyType behavior)

Definition: pg_depend.c:45

recordDependencyOnCurrentExtension

void recordDependencyOnCurrentExtension(const ObjectAddress *object, bool isReplace)

Definition: pg_depend.c:193

pg_event_trigger.h

Form_pg_event_trigger

FormData_pg_event_trigger * Form_pg_event_trigger

Definition: pg_event_trigger.h:50

lfirst

#define lfirst(lc)

Definition: pg_list.h:172

list_length

static int list_length(const List *l)

Definition: pg_list.h:152

NIL

#define NIL

Definition: pg_list.h:68

lfirst_oid

#define lfirst_oid(lc)

Definition: pg_list.h:174

FormData_pg_policy * Form_pg_policy

Definition: pg_policy.h:51

pg_proc.h

changeDependencyOnOwner

void changeDependencyOnOwner(Oid classId, Oid objectId, Oid newOwnerId)

Definition: pg_shdepend.c:316

recordDependencyOnOwner

void recordDependencyOnOwner(Oid classId, Oid objectId, Oid owner)

Definition: pg_shdepend.c:168

pg_tablespace.h

pg_trigger.h

Form_pg_trigger

FormData_pg_trigger * Form_pg_trigger

Definition: pg_trigger.h:80

pg_ts_config.h

pg_type.h

pgstat.h

pgstat_init_function_usage

void pgstat_init_function_usage(FunctionCallInfo fcinfo, PgStat_FunctionCallUsage *fcu)

Definition: pgstat_function.c:72

pgstat_end_function_usage

void pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, bool finalize)

Definition: pgstat_function.c:146

pg_ascii_toupper

unsigned char pg_ascii_toupper(unsigned char ch)

Definition: pgstrcasecmp.c:135

postgres.h

PointerGetDatum

static Datum PointerGetDatum(const void *X)

Definition: postgres.h:332

DatumGetName

static Name DatumGetName(Datum X)

Definition: postgres.h:370

DatumGetObjectId

static Oid DatumGetObjectId(Datum X)

Definition: postgres.h:252

BoolGetDatum

static Datum BoolGetDatum(bool X)

Definition: postgres.h:112

ObjectIdGetDatum

static Datum ObjectIdGetDatum(Oid X)

Definition: postgres.h:262

NameGetDatum

static Datum NameGetDatum(const NameData *X)

Definition: postgres.h:383

Datum

uint64_t Datum

Definition: postgres.h:70

CStringGetDatum

static Datum CStringGetDatum(const char *X)

Definition: postgres.h:360

Int32GetDatum

static Datum Int32GetDatum(int32 X)

Definition: postgres.h:222

CharGetDatum

static Datum CharGetDatum(char X)

Definition: postgres.h:132

InvalidOid

#define InvalidOid

Definition: postgres_ext.h:37

Oid

unsigned int Oid

Definition: postgres_ext.h:32

newsub

static color newsub(struct colormap *cm, color co)

Definition: regc_color.c:389

rel.h

RelationGetDescr

#define RelationGetDescr(relation)

Definition: rel.h:540

ScanKeyInit

void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)

Definition: scankey.c:76

GetTransactionSnapshot

Snapshot GetTransactionSnapshot(void)

Definition: snapmgr.c:271

PushActiveSnapshot

void PushActiveSnapshot(Snapshot snapshot)

Definition: snapmgr.c:680

PopActiveSnapshot

void PopActiveSnapshot(void)

Definition: snapmgr.c:773

snapmgr.h

check_stack_depth

void check_stack_depth(void)

Definition: stack_depth.c:95

BTEqualStrategyNumber

#define BTEqualStrategyNumber

Definition: stratnum.h:31

ERRCODE_DUPLICATE_OBJECT

#define ERRCODE_DUPLICATE_OBJECT

Definition: streamutil.c:30

AlterDefaultPrivilegesStmt

Definition: parsenodes.h:2656

AlterEventTrigStmt

Definition: parsenodes.h:3148

AlterOpFamilyStmt

Definition: parsenodes.h:3318

AlterTSConfigurationStmt

Definition: parsenodes.h:4252

AlterTableCmd

Definition: parsenodes.h:2486

CollectedATSubcmd

Definition: deparse_utility.h:39

CollectedCommand

Definition: deparse_utility.h:45

CollectedCommand::objectId

Oid objectId

Definition: deparse_utility.h:63

CollectedCommand::createopc

struct CollectedCommand::@131::@136 createopc

CollectedCommand::subcmds

List * subcmds

Definition: deparse_utility.h:65

CollectedCommand::parsetree

Node * parsetree

Definition: deparse_utility.h:49

CollectedCommand::type

CollectedCommandType type

Definition: deparse_utility.h:46

CollectedCommand::classId

Oid classId

Definition: deparse_utility.h:64

CollectedCommand::alterTable

struct CollectedCommand::@131::@133 alterTable

CollectedCommand::procedures

List * procedures

Definition: deparse_utility.h:79

CollectedCommand::istmt

InternalGrant * istmt

Definition: deparse_utility.h:71

CollectedCommand::dictIds

Oid * dictIds

Definition: deparse_utility.h:94

CollectedCommand::ndicts

int ndicts

Definition: deparse_utility.h:95

CollectedCommand::operators

List * operators

Definition: deparse_utility.h:78

CollectedCommand::d

union CollectedCommand::@131 d

CollectedCommand::opfam

struct CollectedCommand::@131::@135 opfam

CollectedCommand::parent

struct CollectedCommand * parent

Definition: deparse_utility.h:105

CollectedCommand::defprivs

struct CollectedCommand::@131::@138 defprivs

CollectedCommand::objtype

ObjectType objtype

Definition: deparse_utility.h:101

CollectedCommand::secondaryObject

ObjectAddress secondaryObject

Definition: deparse_utility.h:57

CollectedCommand::in_extension

bool in_extension

Definition: deparse_utility.h:48

CollectedCommand::address

ObjectAddress address

Definition: deparse_utility.h:56

CollectedCommand::simple

struct CollectedCommand::@131::@132 simple

CollectedCommand::grant

struct CollectedCommand::@131::@134 grant

CollectedCommand::atscfg

struct CollectedCommand::@131::@137 atscfg

CreateEventTrigStmt

Definition: parsenodes.h:3135

CreateOpClassStmt

Definition: parsenodes.h:3275

DefElem

Definition: parsenodes.h:840

DefElem::defname

char * defname

Definition: parsenodes.h:843

DefElem::arg

Node * arg

Definition: parsenodes.h:844

EventTriggerCacheItem

Definition: evtcache.h:30

EventTriggerCacheItem::fnoid

Oid fnoid

Definition: evtcache.h:31

EventTriggerCacheItem::tagset

Bitmapset * tagset

Definition: evtcache.h:33

EventTriggerCacheItem::enabled

char enabled

Definition: evtcache.h:32

EventTriggerData

Definition: event_trigger.h:25

EventTriggerData::type

NodeTag type

Definition: event_trigger.h:26

EventTriggerData::tag

CommandTag tag

Definition: event_trigger.h:29

EventTriggerData::event

const char * event

Definition: event_trigger.h:27

EventTriggerData::parsetree

Node * parsetree

Definition: event_trigger.h:28

EventTriggerQueryState

Definition: event_trigger.c:62

EventTriggerQueryState::table_rewrite_oid

Oid table_rewrite_oid

Definition: event_trigger.c:71

EventTriggerQueryState::previous

struct EventTriggerQueryState * previous

Definition: event_trigger.c:80

EventTriggerQueryState::SQLDropList

slist_head SQLDropList

Definition: event_trigger.c:67

EventTriggerQueryState::in_sql_drop

bool in_sql_drop

Definition: event_trigger.c:68

EventTriggerQueryState::cxt

MemoryContext cxt

Definition: event_trigger.c:64

EventTriggerQueryState::currentCommand

CollectedCommand * currentCommand

Definition: event_trigger.c:77

EventTriggerQueryState::commandList

List * commandList

Definition: event_trigger.c:78

EventTriggerQueryState::table_rewrite_reason

int table_rewrite_reason

Definition: event_trigger.c:73

EventTriggerQueryState::commandCollectionInhibited

bool commandCollectionInhibited

Definition: event_trigger.c:76

FmgrInfo

Definition: fmgr.h:57

HeapTupleData

Definition: htup.h:63

HeapTupleData::t_self

ItemPointerData t_self

Definition: htup.h:65

InternalGrant

Definition: aclchk_internal.h:32

InternalGrant::grantees

List * grantees

Definition: aclchk_internal.h:39

InternalGrant::objects

List * objects

Definition: aclchk_internal.h:35

InternalGrant::is_grant

bool is_grant

Definition: aclchk_internal.h:33

InternalGrant::objtype

ObjectType objtype

Definition: aclchk_internal.h:34

InternalGrant::col_privs

List * col_privs

Definition: aclchk_internal.h:38

ItemPointerData

Definition: itemptr.h:37

List

Definition: pg_list.h:54

MemoryContextData

Definition: memnodes.h:118

Node

Definition: nodes.h:135

ObjectAddress

Definition: objectaddress.h:25

ObjectAddress::objectSubId

int32 objectSubId

Definition: objectaddress.h:28

ObjectAddress::classId

Oid classId

Definition: objectaddress.h:26

ObjectAddress::objectId

Oid objectId

Definition: objectaddress.h:27

PgStat_FunctionCallUsage

Definition: pgstat.h:92

RelationData

Definition: rel.h:56

RelationData::rd_att

TupleDesc rd_att

Definition: rel.h:112

ReturnSetInfo

Definition: execnodes.h:353

ReturnSetInfo::setDesc

TupleDesc setDesc

Definition: execnodes.h:364

ReturnSetInfo::setResult

Tuplestorestate * setResult

Definition: execnodes.h:363

SQLDropObject

Definition: event_trigger.c:90

SQLDropObject::istemp

bool istemp

Definition: event_trigger.c:100

SQLDropObject::address

ObjectAddress address

Definition: event_trigger.c:91

SQLDropObject::schemaname

const char * schemaname

Definition: event_trigger.c:92

SQLDropObject::next

slist_node next

Definition: event_trigger.c:101

SQLDropObject::objidentity

const char * objidentity

Definition: event_trigger.c:94

SQLDropObject::original

bool original

Definition: event_trigger.c:98

SQLDropObject::normal

bool normal

Definition: event_trigger.c:99

SQLDropObject::addrargs

List * addrargs

Definition: event_trigger.c:97

SQLDropObject::objecttype

const char * objecttype

Definition: event_trigger.c:95

SQLDropObject::addrnames

List * addrnames

Definition: event_trigger.c:96

SQLDropObject::objname

const char * objname

Definition: event_trigger.c:93

ScanKeyData

Definition: skey.h:65

SysScanDescData

Definition: relscan.h:208

nameData

Definition: c.h:746

slist_head

Definition: ilist.h:237

slist_iter

Definition: ilist.h:258

slist_node

Definition: ilist.h:225

state

Definition: regguts.h:323

superuser_arg

bool superuser_arg(Oid roleid)

Definition: superuser.c:56

superuser

bool superuser(void)

Definition: superuser.c:46

SearchSysCacheLockedCopy1

HeapTuple SearchSysCacheLockedCopy1(int cacheId, Datum key1)

Definition: syscache.c:399

SearchSysCache1

HeapTuple SearchSysCache1(int cacheId, Datum key1)

Definition: syscache.c:220

syscache.h

SearchSysCacheCopy1

#define SearchSysCacheCopy1(cacheId, key1)

Definition: syscache.h:91

GetSysCacheOid1

#define GetSysCacheOid1(cacheId, oidcol, key1)

Definition: syscache.h:109

table_close

void table_close(Relation relation, LOCKMODE lockmode)

Definition: table.c:126

table_open

Relation table_open(Oid relationId, LOCKMODE lockmode)

Definition: table.c:40

table.h

SessionReplicationRole

int SessionReplicationRole

Definition: trigger.c:63

trigger.h

SESSION_REPLICATION_ROLE_REPLICA

#define SESSION_REPLICATION_ROLE_REPLICA

Definition: trigger.h:141

TRIGGER_FIRES_ON_ORIGIN

#define TRIGGER_FIRES_ON_ORIGIN

Definition: trigger.h:149

TRIGGER_DISABLED

#define TRIGGER_DISABLED

Definition: trigger.h:152

TRIGGER_FIRES_ON_REPLICA

#define TRIGGER_FIRES_ON_REPLICA

Definition: trigger.h:151

tuplestore_putvalues

void tuplestore_putvalues(Tuplestorestate *state, TupleDesc tdesc, const Datum *values, const bool *isnull)

Definition: tuplestore.c:784

ListCell

Definition: pg_list.h:46

CreateCommandTag

CommandTag CreateCommandTag(Node *parsetree)

Definition: utility.c:2354

utility.h

CreateCommandName

static const char * CreateCommandName(Node *parsetree)

Definition: utility.h:103

strVal

#define strVal(v)

Definition: value.h:82

cstring_to_text

text * cstring_to_text(const char *s)

Definition: varlena.c:181

type

const char * type

Definition: wait_event_funcs.c:27

name

const char * name

Definition: wait_event_funcs.c:28

CommandCounterIncrement

void CommandCounterIncrement(void)

Definition: xact.c:1100

StartTransactionCommand

void StartTransactionCommand(void)

Definition: xact.c:3071

CommitTransactionCommand

void CommitTransactionCommand(void)

Definition: xact.c:3169

xact.h

PostgreSQL Source Code: src/backend/commands/event_trigger.c Source File