mirror of
https://github.com/postgres/postgres.git
synced 2025-07-11 10:01:57 +03:00
Make number of args to a function configurable.
This commit is contained in:
Bruce Momjian
@ -1,7 +1,7 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* comment.c
|
||||
*
|
||||
*
|
||||
* PostgreSQL object comments utility code.
|
||||
*
|
||||
* Copyright (c) 1999, PostgreSQL Global Development Group
|
||||
@ -34,10 +34,10 @@
|
||||
|
||||
/*------------------------------------------------------------------
|
||||
* Static Function Prototypes --
|
||||
*
|
||||
* The following protoypes are declared static so as not to conflict
|
||||
* with any other routines outside this module. These routines are
|
||||
* called by the public function CommentObject() routine to create
|
||||
*
|
||||
* The following protoypes are declared static so as not to conflict
|
||||
* with any other routines outside this module. These routines are
|
||||
* called by the public function CommentObject() routine to create
|
||||
* the appropriate comment for the specific object type.
|
||||
*------------------------------------------------------------------
|
||||
*/
|
||||
@ -55,10 +55,10 @@ static void CommentTrigger(char *trigger, char *relation, char *comments);
|
||||
/*------------------------------------------------------------------
|
||||
* CommentObject --
|
||||
*
|
||||
* This routine is used to add the associated comment into
|
||||
* pg_description for the object specified by the paramters handed
|
||||
* to this routine. If the routine cannot determine an Oid to
|
||||
* associated with the parameters handed to this routine, an
|
||||
* This routine is used to add the associated comment into
|
||||
* pg_description for the object specified by the paramters handed
|
||||
* to this routine. If the routine cannot determine an Oid to
|
||||
* associated with the parameters handed to this routine, an
|
||||
* error is thrown. Otherwise the comment is added to pg_description
|
||||
* by calling the CreateComments() routine. If the comments were
|
||||
* empty, CreateComments() will drop any comments associated with
|
||||
@ -66,9 +66,9 @@ static void CommentTrigger(char *trigger, char *relation, char *comments);
|
||||
*------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
void CommentObject(int objtype, char *objname, char *objproperty,
|
||||
void CommentObject(int objtype, char *objname, char *objproperty,
|
||||
List *objlist, char *comment) {
|
||||
|
||||
|
||||
switch (objtype) {
|
||||
case (INDEX):
|
||||
case (SEQUENCE):
|
||||
@ -102,18 +102,18 @@ void CommentObject(int objtype, char *objname, char *objproperty,
|
||||
break;
|
||||
default:
|
||||
elog(ERROR, "An attempt was made to comment on a unkown type: %i",
|
||||
objtype);
|
||||
objtype);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------
|
||||
* CreateComments --
|
||||
*
|
||||
*
|
||||
* This routine is handed the oid and the command associated
|
||||
* with that id and will insert, update, or delete (if the
|
||||
* with that id and will insert, update, or delete (if the
|
||||
* comment is an empty string or a NULL pointer) the associated
|
||||
* comment from the system cataloge, pg_description.
|
||||
* comment from the system cataloge, pg_description.
|
||||
*
|
||||
*------------------------------------------------------------------
|
||||
*/
|
||||
@ -147,7 +147,7 @@ void CreateComments(Oid oid, char *comment) {
|
||||
}
|
||||
|
||||
/*** Now, open pg_description and attempt to find the old tuple ***/
|
||||
|
||||
|
||||
ScanKeyEntryInitialize(&entry, 0x0, Anum_pg_description_objoid, F_OIDEQ,
|
||||
ObjectIdGetDatum(oid));
|
||||
scan = heap_beginscan(description, false, SnapshotNow, 1, &entry);
|
||||
@ -156,21 +156,21 @@ void CreateComments(Oid oid, char *comment) {
|
||||
/*** If a previous tuple exists, either delete or prep replacement ***/
|
||||
|
||||
if (HeapTupleIsValid(searchtuple)) {
|
||||
|
||||
|
||||
/*** If the comment is blank, call heap_delete, else heap_update ***/
|
||||
|
||||
if ((comment == NULL) || (strlen(comment) == 0)) {
|
||||
heap_delete(description, &searchtuple->t_self, NULL);
|
||||
} else {
|
||||
desctuple = heap_modifytuple(searchtuple, description, values,
|
||||
nulls, replaces);
|
||||
desctuple = heap_modifytuple(searchtuple, description, values,
|
||||
nulls, replaces);
|
||||
setheapoverride(true);
|
||||
heap_update(description, &searchtuple->t_self, desctuple, NULL);
|
||||
setheapoverride(false);
|
||||
modified = TRUE;
|
||||
}
|
||||
|
||||
} else {
|
||||
} else {
|
||||
desctuple = heap_formtuple(tupDesc, values, nulls);
|
||||
heap_insert(description, desctuple);
|
||||
modified = TRUE;
|
||||
@ -179,14 +179,14 @@ void CreateComments(Oid oid, char *comment) {
|
||||
/*** Complete the scan, update indices, if necessary ***/
|
||||
|
||||
heap_endscan(scan);
|
||||
|
||||
|
||||
if (modified) {
|
||||
if (RelationGetForm(description)->relhasindex) {
|
||||
Relation idescs[Num_pg_description_indices];
|
||||
|
||||
CatalogOpenIndices(Num_pg_description_indices,
|
||||
|
||||
CatalogOpenIndices(Num_pg_description_indices,
|
||||
Name_pg_description_indices, idescs);
|
||||
CatalogIndexInsert(idescs, Num_pg_description_indices, description,
|
||||
CatalogIndexInsert(idescs, Num_pg_description_indices, description,
|
||||
desctuple);
|
||||
CatalogCloseIndices(Num_pg_description_indices, idescs);
|
||||
}
|
||||
@ -198,10 +198,10 @@ void CreateComments(Oid oid, char *comment) {
|
||||
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------
|
||||
/*------------------------------------------------------------------
|
||||
* DeleteComments --
|
||||
*
|
||||
* This routine is used to purge any comments
|
||||
* This routine is used to purge any comments
|
||||
* associated with the Oid handed to this routine,
|
||||
* regardless of the actual object type. It is
|
||||
* called, for example, when a relation is destroyed.
|
||||
@ -220,7 +220,7 @@ void DeleteComments(Oid oid) {
|
||||
tupDesc = description->rd_att;
|
||||
|
||||
/*** Now, open pg_description and attempt to find the old tuple ***/
|
||||
|
||||
|
||||
ScanKeyEntryInitialize(&entry, 0x0, Anum_pg_description_objoid, F_OIDEQ,
|
||||
ObjectIdGetDatum(oid));
|
||||
scan = heap_beginscan(description, false, SnapshotNow, 1, &entry);
|
||||
@ -228,24 +228,24 @@ void DeleteComments(Oid oid) {
|
||||
|
||||
/*** If a previous tuple exists, delete it ***/
|
||||
|
||||
if (HeapTupleIsValid(searchtuple)) {
|
||||
if (HeapTupleIsValid(searchtuple)) {
|
||||
heap_delete(description, &searchtuple->t_self, NULL);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/*** Complete the scan, update indices, if necessary ***/
|
||||
|
||||
heap_endscan(scan);
|
||||
heap_close(description, RowExclusiveLock);
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*------------------------------------------------------------------
|
||||
* CommentRelation --
|
||||
*
|
||||
* This routine is used to add/drop a comment from a relation, where
|
||||
* This routine is used to add/drop a comment from a relation, where
|
||||
* a relation is a TABLE, SEQUENCE, VIEW or INDEX. The routine simply
|
||||
* finds the relation name by searching the system cache, locating
|
||||
* the appropriate tuple, and inserting a comment using that
|
||||
* finds the relation name by searching the system cache, locating
|
||||
* the appropriate tuple, and inserting a comment using that
|
||||
* tuple's oid. Its parameters are the relation name and comments.
|
||||
*------------------------------------------------------------------
|
||||
*/
|
||||
@ -300,10 +300,10 @@ void CommentRelation(int reltype, char *relname, char *comment) {
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
/*** Create the comments using the tuple's oid ***/
|
||||
|
||||
CreateComments(oid, comment);
|
||||
CreateComments(oid, comment);
|
||||
|
||||
}
|
||||
|
||||
@ -311,11 +311,11 @@ void CommentRelation(int reltype, char *relname, char *comment) {
|
||||
* CommentAttribute --
|
||||
*
|
||||
* This routine is used to add/drop a comment from an attribute
|
||||
* such as a table's column. The routine will check security
|
||||
* such as a table's column. The routine will check security
|
||||
* restrictions and then attempt to fetch the oid of the associated
|
||||
* attribute. If successful, a comment is added/dropped, else an
|
||||
* elog() exception is thrown. The parameters are the relation
|
||||
* and attribute names, and the comments
|
||||
* and attribute names, and the comments
|
||||
*------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
@ -332,10 +332,10 @@ void CommentAttribute(char *relname, char *attrname, char *comment) {
|
||||
elog(ERROR, "you are not permitted to comment on class '%s\'", relname);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/*** Now, fetch the attribute oid from the system cache ***/
|
||||
|
||||
relation = heap_openr(relname, AccessShareLock);
|
||||
relation = heap_openr(relname, AccessShareLock);
|
||||
attrtuple = SearchSysCacheTuple(ATTNAME, ObjectIdGetDatum(relation->rd_id),
|
||||
PointerGetDatum(attrname), 0, 0);
|
||||
if (!HeapTupleIsValid(attrtuple)) {
|
||||
@ -343,14 +343,14 @@ void CommentAttribute(char *relname, char *attrname, char *comment) {
|
||||
attrname, relname);
|
||||
}
|
||||
oid = attrtuple->t_data->t_oid;
|
||||
|
||||
|
||||
/*** Call CreateComments() to create/drop the comments ***/
|
||||
|
||||
CreateComments(oid, comment);
|
||||
|
||||
/*** Now, close the heap relation and return ***/
|
||||
|
||||
heap_close(relation, AccessShareLock);
|
||||
heap_close(relation, AccessShareLock);
|
||||
|
||||
}
|
||||
|
||||
@ -358,10 +358,10 @@ void CommentAttribute(char *relname, char *attrname, char *comment) {
|
||||
* CommentDatabase --
|
||||
*
|
||||
* This routine is used to add/drop any user-comments a user might
|
||||
* have regarding the specified database. The routine will check
|
||||
* security for owner permissions, and, if succesful, will then
|
||||
* attempt to find the oid of the database specified. Once found,
|
||||
* a comment is added/dropped using the CreateComments() routine.
|
||||
* have regarding the specified database. The routine will check
|
||||
* security for owner permissions, and, if succesful, will then
|
||||
* attempt to find the oid of the database specified. Once found,
|
||||
* a comment is added/dropped using the CreateComments() routine.
|
||||
*------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
@ -374,7 +374,7 @@ void CommentDatabase(char *database, char *comment) {
|
||||
Oid oid;
|
||||
bool superuser;
|
||||
int4 dba, userid;
|
||||
char *username;
|
||||
char *username;
|
||||
|
||||
/*** First find the tuple in pg_database for the database ***/
|
||||
|
||||
@ -383,7 +383,7 @@ void CommentDatabase(char *database, char *comment) {
|
||||
F_NAMEEQ, NameGetDatum(database));
|
||||
scan = heap_beginscan(pg_database, 0, SnapshotNow, 1, &entry);
|
||||
dbtuple = heap_getnext(scan, 0);
|
||||
|
||||
|
||||
/*** Validate database exists, and fetch the dba id and oid ***/
|
||||
|
||||
if (!HeapTupleIsValid(dbtuple)) {
|
||||
@ -391,9 +391,9 @@ void CommentDatabase(char *database, char *comment) {
|
||||
}
|
||||
dba = ((Form_pg_database) GETSTRUCT(dbtuple))->datdba;
|
||||
oid = dbtuple->t_data->t_oid;
|
||||
|
||||
|
||||
/*** Now, fetch user information ***/
|
||||
|
||||
|
||||
username = GetPgUserName();
|
||||
usertuple = SearchSysCacheTuple(SHADOWNAME, PointerGetDatum(username),
|
||||
0, 0, 0);
|
||||
@ -402,9 +402,9 @@ void CommentDatabase(char *database, char *comment) {
|
||||
}
|
||||
userid = ((Form_pg_shadow) GETSTRUCT(usertuple))->usesysid;
|
||||
superuser = ((Form_pg_shadow) GETSTRUCT(usertuple))->usesuper;
|
||||
|
||||
|
||||
/*** Allow if the userid matches the database dba or is a superuser ***/
|
||||
|
||||
|
||||
#ifndef NO_SECURITY
|
||||
if (!(superuser || (userid == dba))) {
|
||||
elog(ERROR, "you are not permitted to comment on database '%s'",
|
||||
@ -413,11 +413,11 @@ void CommentDatabase(char *database, char *comment) {
|
||||
#endif
|
||||
|
||||
/*** Create the comments with the pg_database oid ***/
|
||||
|
||||
|
||||
CreateComments(oid, comment);
|
||||
|
||||
|
||||
/*** Complete the scan and close any opened relations ***/
|
||||
|
||||
|
||||
heap_endscan(scan);
|
||||
heap_close(pg_database, AccessShareLock);
|
||||
|
||||
@ -428,7 +428,7 @@ void CommentDatabase(char *database, char *comment) {
|
||||
*
|
||||
* This routine is used to add/drop any user-comments a user might
|
||||
* have regarding a specified RULE. The rule is specified by name
|
||||
* and, if found, and the user has appropriate permissions, a
|
||||
* and, if found, and the user has appropriate permissions, a
|
||||
* comment will be added/dropped using the CreateComments() routine.
|
||||
*------------------------------------------------------------------
|
||||
*/
|
||||
@ -441,8 +441,8 @@ void CommentRewrite(char *rule, char *comment) {
|
||||
int aclcheck;
|
||||
|
||||
/*** First, validate user ***/
|
||||
|
||||
#ifndef NO_SECURITY
|
||||
|
||||
#ifndef NO_SECURITY
|
||||
user = GetPgUserName();
|
||||
relation = RewriteGetRuleEventRel(rule);
|
||||
aclcheck = pg_aclcheck(relation, user, ACL_RU);
|
||||
@ -453,7 +453,7 @@ void CommentRewrite(char *rule, char *comment) {
|
||||
#endif
|
||||
|
||||
/*** Next, find the rule's oid ***/
|
||||
|
||||
|
||||
rewritetuple = SearchSysCacheTuple(RULENAME, PointerGetDatum(rule),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(rewritetuple)) {
|
||||
@ -461,7 +461,7 @@ void CommentRewrite(char *rule, char *comment) {
|
||||
}
|
||||
|
||||
oid = rewritetuple->t_data->t_oid;
|
||||
|
||||
|
||||
/*** Call CreateComments() to create/drop the comments ***/
|
||||
|
||||
CreateComments(oid, comment);
|
||||
@ -473,7 +473,7 @@ void CommentRewrite(char *rule, char *comment) {
|
||||
*
|
||||
* This routine is used to add/drop any user-comments a user might
|
||||
* have regarding a TYPE. The type is specified by name
|
||||
* and, if found, and the user has appropriate permissions, a
|
||||
* and, if found, and the user has appropriate permissions, a
|
||||
* comment will be added/dropped using the CreateComments() routine.
|
||||
* The type's name and the comments are the paramters to this routine.
|
||||
*------------------------------------------------------------------
|
||||
@ -486,17 +486,17 @@ void CommentType(char *type, char *comment) {
|
||||
char *user;
|
||||
|
||||
/*** First, validate user ***/
|
||||
|
||||
#ifndef NO_SECURITY
|
||||
|
||||
#ifndef NO_SECURITY
|
||||
user = GetPgUserName();
|
||||
if (!pg_ownercheck(user, type, TYPENAME)) {
|
||||
if (!pg_ownercheck(user, type, TYPENAME)) {
|
||||
elog(ERROR, "you are not permitted to comment on type '%s'",
|
||||
type);
|
||||
}
|
||||
#endif
|
||||
|
||||
/*** Next, find the type's oid ***/
|
||||
|
||||
|
||||
typetuple = SearchSysCacheTuple(TYPENAME, PointerGetDatum(type),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(typetuple)) {
|
||||
@ -504,7 +504,7 @@ void CommentType(char *type, char *comment) {
|
||||
}
|
||||
|
||||
oid = typetuple->t_data->t_oid;
|
||||
|
||||
|
||||
/*** Call CreateComments() to create/drop the comments ***/
|
||||
|
||||
CreateComments(oid, comment);
|
||||
@ -514,20 +514,20 @@ void CommentType(char *type, char *comment) {
|
||||
/*------------------------------------------------------------------
|
||||
* CommentAggregate --
|
||||
*
|
||||
* This routine is used to allow a user to provide comments on an
|
||||
* This routine is used to allow a user to provide comments on an
|
||||
* aggregate function. The aggregate function is determined by both
|
||||
* its name and its argument type, which, with the comments are
|
||||
* its name and its argument type, which, with the comments are
|
||||
* the three parameters handed to this routine.
|
||||
*------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
void CommentAggregate(char *aggregate, char *argument, char *comment) {
|
||||
|
||||
|
||||
HeapTuple aggtuple;
|
||||
Oid baseoid, oid;
|
||||
bool defined;
|
||||
char *user;
|
||||
|
||||
|
||||
/*** First, attempt to determine the base aggregate oid ***/
|
||||
|
||||
if (argument) {
|
||||
@ -538,7 +538,7 @@ void CommentAggregate(char *aggregate, char *argument, char *comment) {
|
||||
} else {
|
||||
baseoid = 0;
|
||||
}
|
||||
|
||||
|
||||
/*** Next, validate the user's attempt to comment ***/
|
||||
|
||||
#ifndef NO_SECURITY
|
||||
@ -566,9 +566,9 @@ void CommentAggregate(char *aggregate, char *argument, char *comment) {
|
||||
elog(ERROR, "aggregate '%s' does not exist", aggregate);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
oid = aggtuple->t_data->t_oid;
|
||||
|
||||
|
||||
/*** Call CreateComments() to create/drop the comments ***/
|
||||
|
||||
CreateComments(oid, comment);
|
||||
@ -578,9 +578,9 @@ void CommentAggregate(char *aggregate, char *argument, char *comment) {
|
||||
/*------------------------------------------------------------------
|
||||
* CommentProc --
|
||||
*
|
||||
* This routine is used to allow a user to provide comments on an
|
||||
* This routine is used to allow a user to provide comments on an
|
||||
* procedure (function). The procedure is determined by both
|
||||
* its name and its argument list. The argument list is expected to
|
||||
* its name and its argument list. The argument list is expected to
|
||||
* be a series of parsed nodes pointed to by a List object. If the
|
||||
* comments string is empty, the associated comment is dropped.
|
||||
*------------------------------------------------------------------
|
||||
@ -589,7 +589,7 @@ void CommentAggregate(char *aggregate, char *argument, char *comment) {
|
||||
void CommentProc(char *function, List *arguments, char *comment) {
|
||||
|
||||
HeapTuple argtuple, functuple;
|
||||
Oid oid, argoids[8];
|
||||
Oid oid, argoids[FUNC_MAX_ARGS];
|
||||
char *user, *argument;
|
||||
int i, argcount;
|
||||
|
||||
@ -597,7 +597,7 @@ void CommentProc(char *function, List *arguments, char *comment) {
|
||||
|
||||
argcount = length(arguments);
|
||||
if (argcount > 0) {
|
||||
MemSet(argoids, 0, 8 * sizeof(Oid));
|
||||
MemSet(argoids, 0, FUNC_MAX_ARGS * sizeof(Oid));
|
||||
for (i = 0; i < argcount; i++) {
|
||||
argument = strVal(lfirst(arguments));
|
||||
arguments = lnext(arguments);
|
||||
@ -632,29 +632,29 @@ void CommentProc(char *function, List *arguments, char *comment) {
|
||||
PointerGetDatum(argoids), 0);
|
||||
|
||||
/*** Deallocate our argument oids and check the function tuple ***/
|
||||
|
||||
|
||||
if (!HeapTupleIsValid(functuple)) {
|
||||
elog(ERROR, "function '%s' with the supplied %s does not exist",
|
||||
function, "argument list");
|
||||
}
|
||||
|
||||
|
||||
oid = functuple->t_data->t_oid;
|
||||
|
||||
|
||||
/*** Call CreateComments() to create/drop the comments ***/
|
||||
|
||||
CreateComments(oid, comment);
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*------------------------------------------------------------------
|
||||
* CommentOperator --
|
||||
*
|
||||
* This routine is used to allow a user to provide comments on an
|
||||
* This routine is used to allow a user to provide comments on an
|
||||
* operator. The operator for commenting is determined by both
|
||||
* its name and its argument list which defines the left and right
|
||||
* hand types the operator will operate on. The argument list is
|
||||
* expected to be a couple of parse nodes pointed to be a List
|
||||
* object. If the comments string is empty, the associated comment
|
||||
* hand types the operator will operate on. The argument list is
|
||||
* expected to be a couple of parse nodes pointed to be a List
|
||||
* object. If the comments string is empty, the associated comment
|
||||
* is dropped.
|
||||
*------------------------------------------------------------------
|
||||
*/
|
||||
@ -670,7 +670,7 @@ void CommentOperator(char *opername, List *arguments, char *comment) {
|
||||
|
||||
if (lfirst(arguments) != NULL) {
|
||||
lefttype = strVal(lfirst(arguments));
|
||||
}
|
||||
}
|
||||
if (lsecond(arguments) != NULL) {
|
||||
righttype = strVal(lsecond(arguments));
|
||||
}
|
||||
@ -683,9 +683,9 @@ void CommentOperator(char *opername, List *arguments, char *comment) {
|
||||
elog(ERROR, "left type '%s' does not exist", lefttype);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*** Attempt to fetch the right oid, if specified ***/
|
||||
|
||||
|
||||
if (righttype != NULL) {
|
||||
rightoid = TypeGet(righttype, &defined);
|
||||
if (!OidIsValid(rightoid)) {
|
||||
@ -699,7 +699,7 @@ void CommentOperator(char *opername, List *arguments, char *comment) {
|
||||
else if (OidIsValid(leftoid)) oprtype = 'l';
|
||||
else if (OidIsValid(rightoid)) oprtype = 'r';
|
||||
else elog(ERROR, "operator '%s' is of an illegal type'", opername);
|
||||
|
||||
|
||||
/*** Attempt to fetch the operator oid ***/
|
||||
|
||||
optuple = SearchSysCacheTupleCopy(OPERNAME, PointerGetDatum(opername),
|
||||
@ -710,8 +710,8 @@ void CommentOperator(char *opername, List *arguments, char *comment) {
|
||||
elog(ERROR, "operator '%s' does not exist", opername);
|
||||
}
|
||||
|
||||
oid = optuple->t_data->t_oid;
|
||||
|
||||
oid = optuple->t_data->t_oid;
|
||||
|
||||
/*** Valid user's ability to comment on this operator ***/
|
||||
|
||||
#ifndef NO_SECURITY
|
||||
@ -748,8 +748,8 @@ void CommentTrigger(char *trigger, char *relname, char *comment) {
|
||||
ScanKeyData entry;
|
||||
Oid oid = InvalidOid;
|
||||
char *user;
|
||||
|
||||
/*** First, validate the user's action ***/
|
||||
|
||||
/*** First, validate the user's action ***/
|
||||
|
||||
#ifndef NO_SECURITY
|
||||
user = GetPgUserName();
|
||||
@ -761,10 +761,10 @@ void CommentTrigger(char *trigger, char *relname, char *comment) {
|
||||
|
||||
/*** Now, fetch the trigger oid from pg_trigger ***/
|
||||
|
||||
relation = heap_openr(relname, AccessShareLock);
|
||||
relation = heap_openr(relname, AccessShareLock);
|
||||
pg_trigger = heap_openr(TriggerRelationName, AccessShareLock);
|
||||
ScanKeyEntryInitialize(&entry, 0, Anum_pg_trigger_tgrelid,
|
||||
F_OIDEQ, RelationGetRelid(relation));
|
||||
F_OIDEQ, RelationGetRelid(relation));
|
||||
scan = heap_beginscan(pg_trigger, 0, SnapshotNow, 1, &entry);
|
||||
triggertuple = heap_getnext(scan, 0);
|
||||
while (HeapTupleIsValid(triggertuple)) {
|
||||
@ -784,11 +784,11 @@ void CommentTrigger(char *trigger, char *relname, char *comment) {
|
||||
}
|
||||
|
||||
/*** Create the comments with the pg_trigger oid ***/
|
||||
|
||||
|
||||
CreateComments(oid, comment);
|
||||
|
||||
|
||||
/*** Complete the scan and close any opened relations ***/
|
||||
|
||||
|
||||
heap_endscan(scan);
|
||||
heap_close(pg_trigger, AccessShareLock);
|
||||
heap_close(relation, AccessShareLock);
|
||||
|
||||
Reference in New Issue
Block a user