mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-10-01 09:51:18 +02:00
1823 lines
50 KiB
C
1823 lines
50 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* dependency.c
|
|
* Routines to support inter-object dependencies.
|
|
*
|
|
*
|
|
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
* IDENTIFICATION
|
|
* $PostgreSQL: pgsql/src/backend/catalog/dependency.c,v 1.34 2003/11/29 19:51:42 pgsql Exp $
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#include "postgres.h"
|
|
|
|
#include "access/genam.h"
|
|
#include "access/heapam.h"
|
|
#include "catalog/catname.h"
|
|
#include "catalog/dependency.h"
|
|
#include "catalog/heap.h"
|
|
#include "catalog/index.h"
|
|
#include "catalog/indexing.h"
|
|
#include "catalog/namespace.h"
|
|
#include "catalog/pg_attrdef.h"
|
|
#include "catalog/pg_cast.h"
|
|
#include "catalog/pg_constraint.h"
|
|
#include "catalog/pg_conversion.h"
|
|
#include "catalog/pg_depend.h"
|
|
#include "catalog/pg_language.h"
|
|
#include "catalog/pg_opclass.h"
|
|
#include "catalog/pg_rewrite.h"
|
|
#include "catalog/pg_trigger.h"
|
|
#include "commands/comment.h"
|
|
#include "commands/defrem.h"
|
|
#include "commands/proclang.h"
|
|
#include "commands/schemacmds.h"
|
|
#include "commands/trigger.h"
|
|
#include "commands/typecmds.h"
|
|
#include "lib/stringinfo.h"
|
|
#include "miscadmin.h"
|
|
#include "optimizer/clauses.h"
|
|
#include "parser/parsetree.h"
|
|
#include "rewrite/rewriteRemove.h"
|
|
#include "utils/builtins.h"
|
|
#include "utils/fmgroids.h"
|
|
#include "utils/lsyscache.h"
|
|
#include "utils/syscache.h"
|
|
|
|
|
|
/* This enum covers all system catalogs whose OIDs can appear in classid. */
|
|
typedef enum ObjectClasses
|
|
{
|
|
OCLASS_CLASS, /* pg_class */
|
|
OCLASS_PROC, /* pg_proc */
|
|
OCLASS_TYPE, /* pg_type */
|
|
OCLASS_CAST, /* pg_cast */
|
|
OCLASS_CONSTRAINT, /* pg_constraint */
|
|
OCLASS_CONVERSION, /* pg_conversion */
|
|
OCLASS_DEFAULT, /* pg_attrdef */
|
|
OCLASS_LANGUAGE, /* pg_language */
|
|
OCLASS_OPERATOR, /* pg_operator */
|
|
OCLASS_OPCLASS, /* pg_opclass */
|
|
OCLASS_REWRITE, /* pg_rewrite */
|
|
OCLASS_TRIGGER, /* pg_trigger */
|
|
OCLASS_SCHEMA, /* pg_namespace */
|
|
MAX_OCLASS /* MUST BE LAST */
|
|
} ObjectClasses;
|
|
|
|
/* expansible list of ObjectAddresses */
|
|
typedef struct
|
|
{
|
|
ObjectAddress *refs; /* => palloc'd array */
|
|
int numrefs; /* current number of references */
|
|
int maxrefs; /* current size of palloc'd array */
|
|
} ObjectAddresses;
|
|
|
|
/* for find_expr_references_walker */
|
|
typedef struct
|
|
{
|
|
ObjectAddresses addrs; /* addresses being accumulated */
|
|
List *rtables; /* list of rangetables to resolve Vars */
|
|
} find_expr_references_context;
|
|
|
|
|
|
/*
|
|
* Because not all system catalogs have predetermined OIDs, we build a table
|
|
* mapping between ObjectClasses and OIDs. This is done at most once per
|
|
* backend run, to minimize lookup overhead.
|
|
*/
|
|
static bool object_classes_initialized = false;
|
|
static Oid object_classes[MAX_OCLASS];
|
|
|
|
|
|
static void findAutoDeletableObjects(const ObjectAddress *object,
|
|
ObjectAddresses *oktodelete,
|
|
Relation depRel);
|
|
static bool recursiveDeletion(const ObjectAddress *object,
|
|
DropBehavior behavior,
|
|
int msglevel,
|
|
const ObjectAddress *callingObject,
|
|
ObjectAddresses *oktodelete,
|
|
Relation depRel);
|
|
static bool deleteDependentObjects(const ObjectAddress *object,
|
|
const char *objDescription,
|
|
DropBehavior behavior,
|
|
int msglevel,
|
|
ObjectAddresses *oktodelete,
|
|
Relation depRel);
|
|
static void doDeletion(const ObjectAddress *object);
|
|
static bool find_expr_references_walker(Node *node,
|
|
find_expr_references_context *context);
|
|
static void eliminate_duplicate_dependencies(ObjectAddresses *addrs);
|
|
static int object_address_comparator(const void *a, const void *b);
|
|
static void init_object_addresses(ObjectAddresses *addrs);
|
|
static void add_object_address(ObjectClasses oclass, Oid objectId, int32 subId,
|
|
ObjectAddresses *addrs);
|
|
static void add_exact_object_address(const ObjectAddress *object,
|
|
ObjectAddresses *addrs);
|
|
static bool object_address_present(const ObjectAddress *object,
|
|
ObjectAddresses *addrs);
|
|
static void term_object_addresses(ObjectAddresses *addrs);
|
|
static void init_object_classes(void);
|
|
static ObjectClasses getObjectClass(const ObjectAddress *object);
|
|
static char *getObjectDescription(const ObjectAddress *object);
|
|
static void getRelationDescription(StringInfo buffer, Oid relid);
|
|
|
|
|
|
/*
|
|
* performDeletion: attempt to drop the specified object. If CASCADE
|
|
* behavior is specified, also drop any dependent objects (recursively).
|
|
* If RESTRICT behavior is specified, error out if there are any dependent
|
|
* objects, except for those that should be implicitly dropped anyway
|
|
* according to the dependency type.
|
|
*
|
|
* This is the outer control routine for all forms of DROP that drop objects
|
|
* that can participate in dependencies.
|
|
*/
|
|
void
|
|
performDeletion(const ObjectAddress *object,
|
|
DropBehavior behavior)
|
|
{
|
|
char *objDescription;
|
|
Relation depRel;
|
|
ObjectAddresses oktodelete;
|
|
|
|
/*
|
|
* Get object description for possible use in failure message. Must do
|
|
* this before deleting it ...
|
|
*/
|
|
objDescription = getObjectDescription(object);
|
|
|
|
/*
|
|
* We save some cycles by opening pg_depend just once and passing the
|
|
* Relation pointer down to all the recursive deletion steps.
|
|
*/
|
|
depRel = heap_openr(DependRelationName, RowExclusiveLock);
|
|
|
|
/*
|
|
* Construct a list of objects that are reachable by AUTO or INTERNAL
|
|
* dependencies from the target object. These should be deleted
|
|
* silently, even if the actual deletion pass first reaches one of
|
|
* them via a non-auto dependency.
|
|
*/
|
|
init_object_addresses(&oktodelete);
|
|
|
|
findAutoDeletableObjects(object, &oktodelete, depRel);
|
|
|
|
if (!recursiveDeletion(object, behavior, NOTICE,
|
|
NULL, &oktodelete, depRel))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
|
|
errmsg("cannot drop %s because other objects depend on it",
|
|
objDescription),
|
|
errhint("Use DROP ... CASCADE to drop the dependent objects too.")));
|
|
|
|
term_object_addresses(&oktodelete);
|
|
|
|
heap_close(depRel, RowExclusiveLock);
|
|
|
|
pfree(objDescription);
|
|
}
|
|
|
|
|
|
/*
|
|
* deleteWhatDependsOn: attempt to drop everything that depends on the
|
|
* specified object, though not the object itself. Behavior is always
|
|
* CASCADE.
|
|
*
|
|
* This is currently used only to clean out the contents of a schema
|
|
* (namespace): the passed object is a namespace. We normally want this
|
|
* to be done silently, so there's an option to suppress NOTICE messages.
|
|
*/
|
|
void
|
|
deleteWhatDependsOn(const ObjectAddress *object,
|
|
bool showNotices)
|
|
{
|
|
char *objDescription;
|
|
Relation depRel;
|
|
ObjectAddresses oktodelete;
|
|
|
|
/*
|
|
* Get object description for possible use in failure messages
|
|
*/
|
|
objDescription = getObjectDescription(object);
|
|
|
|
/*
|
|
* We save some cycles by opening pg_depend just once and passing the
|
|
* Relation pointer down to all the recursive deletion steps.
|
|
*/
|
|
depRel = heap_openr(DependRelationName, RowExclusiveLock);
|
|
|
|
/*
|
|
* Construct a list of objects that are reachable by AUTO or INTERNAL
|
|
* dependencies from the target object. These should be deleted
|
|
* silently, even if the actual deletion pass first reaches one of
|
|
* them via a non-auto dependency.
|
|
*/
|
|
init_object_addresses(&oktodelete);
|
|
|
|
findAutoDeletableObjects(object, &oktodelete, depRel);
|
|
|
|
/*
|
|
* Now invoke only step 2 of recursiveDeletion: just recurse to the
|
|
* stuff dependent on the given object.
|
|
*/
|
|
if (!deleteDependentObjects(object, objDescription,
|
|
DROP_CASCADE,
|
|
showNotices ? NOTICE : DEBUG2,
|
|
&oktodelete, depRel))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
|
|
errmsg("failed to drop all objects depending on %s",
|
|
objDescription)));
|
|
|
|
/*
|
|
* We do not need CommandCounterIncrement here, since if step 2 did
|
|
* anything then each recursive call will have ended with one.
|
|
*/
|
|
|
|
term_object_addresses(&oktodelete);
|
|
|
|
heap_close(depRel, RowExclusiveLock);
|
|
|
|
pfree(objDescription);
|
|
}
|
|
|
|
|
|
/*
|
|
* findAutoDeletableObjects: find all objects that are reachable by AUTO or
|
|
* INTERNAL dependency paths from the given object. Add them all to the
|
|
* oktodelete list. Note that the originally given object will also be
|
|
* added to the list.
|
|
*
|
|
* depRel is the already-open pg_depend relation.
|
|
*/
|
|
static void
|
|
findAutoDeletableObjects(const ObjectAddress *object,
|
|
ObjectAddresses *oktodelete,
|
|
Relation depRel)
|
|
{
|
|
ScanKeyData key[3];
|
|
int nkeys;
|
|
SysScanDesc scan;
|
|
HeapTuple tup;
|
|
ObjectAddress otherObject;
|
|
|
|
/*
|
|
* If this object is already in oktodelete, then we already visited
|
|
* it; don't do so again (this prevents infinite recursion if there's
|
|
* a loop in pg_depend). Otherwise, add it.
|
|
*/
|
|
if (object_address_present(object, oktodelete))
|
|
return;
|
|
add_exact_object_address(object, oktodelete);
|
|
|
|
/*
|
|
* Scan pg_depend records that link to this object, showing the things
|
|
* that depend on it. For each one that is AUTO or INTERNAL, visit
|
|
* the referencing object.
|
|
*
|
|
* When dropping a whole object (subId = 0), find pg_depend records for
|
|
* its sub-objects too.
|
|
*/
|
|
ScanKeyInit(&key[0],
|
|
Anum_pg_depend_refclassid,
|
|
BTEqualStrategyNumber, F_OIDEQ,
|
|
ObjectIdGetDatum(object->classId));
|
|
ScanKeyInit(&key[1],
|
|
Anum_pg_depend_refobjid,
|
|
BTEqualStrategyNumber, F_OIDEQ,
|
|
ObjectIdGetDatum(object->objectId));
|
|
if (object->objectSubId != 0)
|
|
{
|
|
ScanKeyInit(&key[2],
|
|
Anum_pg_depend_refobjsubid,
|
|
BTEqualStrategyNumber, F_INT4EQ,
|
|
Int32GetDatum(object->objectSubId));
|
|
nkeys = 3;
|
|
}
|
|
else
|
|
nkeys = 2;
|
|
|
|
scan = systable_beginscan(depRel, DependReferenceIndex, true,
|
|
SnapshotNow, nkeys, key);
|
|
|
|
while (HeapTupleIsValid(tup = systable_getnext(scan)))
|
|
{
|
|
Form_pg_depend foundDep = (Form_pg_depend) GETSTRUCT(tup);
|
|
|
|
switch (foundDep->deptype)
|
|
{
|
|
case DEPENDENCY_NORMAL:
|
|
/* ignore */
|
|
break;
|
|
case DEPENDENCY_AUTO:
|
|
case DEPENDENCY_INTERNAL:
|
|
/* recurse */
|
|
otherObject.classId = foundDep->classid;
|
|
otherObject.objectId = foundDep->objid;
|
|
otherObject.objectSubId = foundDep->objsubid;
|
|
findAutoDeletableObjects(&otherObject, oktodelete, depRel);
|
|
break;
|
|
case DEPENDENCY_PIN:
|
|
|
|
/*
|
|
* For a PIN dependency we just ereport immediately; there
|
|
* won't be any others to examine, and we aren't ever
|
|
* going to let the user delete it.
|
|
*/
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
|
|
errmsg("cannot drop %s because it is required by the database system",
|
|
getObjectDescription(object))));
|
|
break;
|
|
default:
|
|
elog(ERROR, "unrecognized dependency type '%c' for %s",
|
|
foundDep->deptype, getObjectDescription(object));
|
|
break;
|
|
}
|
|
}
|
|
|
|
systable_endscan(scan);
|
|
}
|
|
|
|
|
|
/*
|
|
* recursiveDeletion: delete a single object for performDeletion, plus
|
|
* (recursively) anything that depends on it.
|
|
*
|
|
* Returns TRUE if successful, FALSE if not.
|
|
*
|
|
* callingObject is NULL at the outer level, else identifies the object that
|
|
* we recursed from (the reference object that someone else needs to delete).
|
|
*
|
|
* oktodelete is a list of objects verified deletable (ie, reachable by one
|
|
* or more AUTO or INTERNAL dependencies from the original target).
|
|
*
|
|
* depRel is the already-open pg_depend relation.
|
|
*
|
|
*
|
|
* In RESTRICT mode, we perform all the deletions anyway, but ereport a message
|
|
* and return FALSE if we find a restriction violation. performDeletion
|
|
* will then abort the transaction to nullify the deletions. We have to
|
|
* do it this way to (a) report all the direct and indirect dependencies
|
|
* while (b) not going into infinite recursion if there's a cycle.
|
|
*
|
|
* This is even more complex than one could wish, because it is possible for
|
|
* the same pair of objects to be related by both NORMAL and AUTO/INTERNAL
|
|
* dependencies. Also, we might have a situation where we've been asked to
|
|
* delete object A, and objects B and C both have AUTO dependencies on A,
|
|
* but B also has a NORMAL dependency on C. (Since any of these paths might
|
|
* be indirect, we can't prevent these scenarios, but must cope instead.)
|
|
* If we visit C before B then we would mistakenly decide that the B->C link
|
|
* should prevent the restricted drop from occurring. To handle this, we make
|
|
* a pre-scan to find all the objects that are auto-deletable from A. If we
|
|
* visit C first, but B is present in the oktodelete list, then we make no
|
|
* complaint but recurse to delete B anyway. (Note that in general we must
|
|
* delete B before deleting C; the drop routine for B may try to access C.)
|
|
*
|
|
* Note: in the case where the path to B is traversed first, we will not
|
|
* see the NORMAL dependency when we reach C, because of the pg_depend
|
|
* removals done in step 1. The oktodelete list is necessary just
|
|
* to make the behavior independent of the order in which pg_depend
|
|
* entries are visited.
|
|
*/
|
|
static bool
|
|
recursiveDeletion(const ObjectAddress *object,
|
|
DropBehavior behavior,
|
|
int msglevel,
|
|
const ObjectAddress *callingObject,
|
|
ObjectAddresses *oktodelete,
|
|
Relation depRel)
|
|
{
|
|
bool ok = true;
|
|
char *objDescription;
|
|
ScanKeyData key[3];
|
|
int nkeys;
|
|
SysScanDesc scan;
|
|
HeapTuple tup;
|
|
ObjectAddress otherObject;
|
|
ObjectAddress owningObject;
|
|
bool amOwned = false;
|
|
|
|
/*
|
|
* Get object description for possible use in messages. Must do this
|
|
* before deleting it ...
|
|
*/
|
|
objDescription = getObjectDescription(object);
|
|
|
|
/*
|
|
* Step 1: find and remove pg_depend records that link from this
|
|
* object to others. We have to do this anyway, and doing it first
|
|
* ensures that we avoid infinite recursion in the case of cycles.
|
|
* Also, some dependency types require extra processing here.
|
|
*
|
|
* When dropping a whole object (subId = 0), remove all pg_depend records
|
|
* for its sub-objects too.
|
|
*/
|
|
ScanKeyInit(&key[0],
|
|
Anum_pg_depend_classid,
|
|
BTEqualStrategyNumber, F_OIDEQ,
|
|
ObjectIdGetDatum(object->classId));
|
|
ScanKeyInit(&key[1],
|
|
Anum_pg_depend_objid,
|
|
BTEqualStrategyNumber, F_OIDEQ,
|
|
ObjectIdGetDatum(object->objectId));
|
|
if (object->objectSubId != 0)
|
|
{
|
|
ScanKeyInit(&key[2],
|
|
Anum_pg_depend_objsubid,
|
|
BTEqualStrategyNumber, F_INT4EQ,
|
|
Int32GetDatum(object->objectSubId));
|
|
nkeys = 3;
|
|
}
|
|
else
|
|
nkeys = 2;
|
|
|
|
scan = systable_beginscan(depRel, DependDependerIndex, true,
|
|
SnapshotNow, nkeys, key);
|
|
|
|
while (HeapTupleIsValid(tup = systable_getnext(scan)))
|
|
{
|
|
Form_pg_depend foundDep = (Form_pg_depend) GETSTRUCT(tup);
|
|
|
|
otherObject.classId = foundDep->refclassid;
|
|
otherObject.objectId = foundDep->refobjid;
|
|
otherObject.objectSubId = foundDep->refobjsubid;
|
|
|
|
switch (foundDep->deptype)
|
|
{
|
|
case DEPENDENCY_NORMAL:
|
|
case DEPENDENCY_AUTO:
|
|
/* no problem */
|
|
break;
|
|
case DEPENDENCY_INTERNAL:
|
|
|
|
/*
|
|
* This object is part of the internal implementation of
|
|
* another object. We have three cases:
|
|
*
|
|
* 1. At the outermost recursion level, disallow the DROP.
|
|
* (We just ereport here, rather than proceeding, since no
|
|
* other dependencies are likely to be interesting.)
|
|
*/
|
|
if (callingObject == NULL)
|
|
{
|
|
char *otherObjDesc = getObjectDescription(&otherObject);
|
|
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
|
|
errmsg("cannot drop %s because %s requires it",
|
|
objDescription, otherObjDesc),
|
|
errhint("You may drop %s instead.",
|
|
otherObjDesc)));
|
|
}
|
|
|
|
/*
|
|
* 2. When recursing from the other end of this
|
|
* dependency, it's okay to continue with the deletion.
|
|
* This holds when recursing from a whole object that
|
|
* includes the nominal other end as a component, too.
|
|
*/
|
|
if (callingObject->classId == otherObject.classId &&
|
|
callingObject->objectId == otherObject.objectId &&
|
|
(callingObject->objectSubId == otherObject.objectSubId ||
|
|
callingObject->objectSubId == 0))
|
|
break;
|
|
|
|
/*
|
|
* 3. When recursing from anyplace else, transform this
|
|
* deletion request into a delete of the other object.
|
|
* (This will be an error condition iff RESTRICT mode.) In
|
|
* this case we finish deleting my dependencies except for
|
|
* the INTERNAL link, which will be needed to cause the
|
|
* owning object to recurse back to me.
|
|
*/
|
|
if (amOwned) /* shouldn't happen */
|
|
elog(ERROR, "multiple INTERNAL dependencies for %s",
|
|
objDescription);
|
|
owningObject = otherObject;
|
|
amOwned = true;
|
|
/* "continue" bypasses the simple_heap_delete call below */
|
|
continue;
|
|
case DEPENDENCY_PIN:
|
|
|
|
/*
|
|
* Should not happen; PIN dependencies should have zeroes
|
|
* in the depender fields...
|
|
*/
|
|
elog(ERROR, "incorrect use of PIN dependency with %s",
|
|
objDescription);
|
|
break;
|
|
default:
|
|
elog(ERROR, "unrecognized dependency type '%c' for %s",
|
|
foundDep->deptype, objDescription);
|
|
break;
|
|
}
|
|
|
|
simple_heap_delete(depRel, &tup->t_self);
|
|
}
|
|
|
|
systable_endscan(scan);
|
|
|
|
/*
|
|
* CommandCounterIncrement here to ensure that preceding changes are
|
|
* all visible; in particular, that the above deletions of pg_depend
|
|
* entries are visible. That prevents infinite recursion in case of a
|
|
* dependency loop (which is perfectly legal).
|
|
*/
|
|
CommandCounterIncrement();
|
|
|
|
/*
|
|
* If we found we are owned by another object, ask it to delete itself
|
|
* instead of proceeding. Complain if RESTRICT mode, unless the other
|
|
* object is in oktodelete.
|
|
*/
|
|
if (amOwned)
|
|
{
|
|
if (object_address_present(&owningObject, oktodelete))
|
|
ereport(DEBUG2,
|
|
(errmsg("drop auto-cascades to %s",
|
|
getObjectDescription(&owningObject))));
|
|
else if (behavior == DROP_RESTRICT)
|
|
{
|
|
ereport(msglevel,
|
|
(errmsg("%s depends on %s",
|
|
getObjectDescription(&owningObject),
|
|
objDescription)));
|
|
ok = false;
|
|
}
|
|
else
|
|
ereport(msglevel,
|
|
(errmsg("drop cascades to %s",
|
|
getObjectDescription(&owningObject))));
|
|
|
|
if (!recursiveDeletion(&owningObject, behavior, msglevel,
|
|
object, oktodelete, depRel))
|
|
ok = false;
|
|
|
|
pfree(objDescription);
|
|
|
|
return ok;
|
|
}
|
|
|
|
/*
|
|
* Step 2: scan pg_depend records that link to this object, showing
|
|
* the things that depend on it. Recursively delete those things.
|
|
* Note it's important to delete the dependent objects before the
|
|
* referenced one, since the deletion routines might do things like
|
|
* try to update the pg_class record when deleting a check constraint.
|
|
*/
|
|
if (!deleteDependentObjects(object, objDescription,
|
|
behavior, msglevel,
|
|
oktodelete, depRel))
|
|
ok = false;
|
|
|
|
/*
|
|
* We do not need CommandCounterIncrement here, since if step 2 did
|
|
* anything then each recursive call will have ended with one.
|
|
*/
|
|
|
|
/*
|
|
* Step 3: delete the object itself.
|
|
*/
|
|
doDeletion(object);
|
|
|
|
/*
|
|
* Delete any comments associated with this object. (This is a
|
|
* convenient place to do it instead of having every object type know
|
|
* to do it.)
|
|
*/
|
|
DeleteComments(object->objectId, object->classId, object->objectSubId);
|
|
|
|
/*
|
|
* CommandCounterIncrement here to ensure that preceding changes are
|
|
* all visible.
|
|
*/
|
|
CommandCounterIncrement();
|
|
|
|
/*
|
|
* And we're done!
|
|
*/
|
|
pfree(objDescription);
|
|
|
|
return ok;
|
|
}
|
|
|
|
|
|
/*
|
|
* deleteDependentObjects - find and delete objects that depend on 'object'
|
|
*
|
|
* Scan pg_depend records that link to the given object, showing
|
|
* the things that depend on it. Recursively delete those things. (We
|
|
* don't delete the pg_depend records here, as the recursive call will
|
|
* do that.) Note it's important to delete the dependent objects
|
|
* before the referenced one, since the deletion routines might do
|
|
* things like try to update the pg_class record when deleting a check
|
|
* constraint.
|
|
*
|
|
* When dropping a whole object (subId = 0), find pg_depend records for
|
|
* its sub-objects too.
|
|
*
|
|
* object: the object to find dependencies on
|
|
* objDescription: description of object (only used for error messages)
|
|
* behavior: desired drop behavior
|
|
* oktodelete: stuff that's AUTO-deletable
|
|
* depRel: already opened pg_depend relation
|
|
*
|
|
* Returns TRUE if all is well, false if any problem found.
|
|
*
|
|
* NOTE: because we are using SnapshotNow, if a recursive call deletes
|
|
* any pg_depend tuples that our scan hasn't yet visited, we will not
|
|
* see them as good when we do visit them. This is essential for
|
|
* correct behavior if there are multiple dependency paths between two
|
|
* objects --- else we might try to delete an already-deleted object.
|
|
*/
|
|
static bool
|
|
deleteDependentObjects(const ObjectAddress *object,
|
|
const char *objDescription,
|
|
DropBehavior behavior,
|
|
int msglevel,
|
|
ObjectAddresses *oktodelete,
|
|
Relation depRel)
|
|
{
|
|
bool ok = true;
|
|
ScanKeyData key[3];
|
|
int nkeys;
|
|
SysScanDesc scan;
|
|
HeapTuple tup;
|
|
ObjectAddress otherObject;
|
|
|
|
ScanKeyInit(&key[0],
|
|
Anum_pg_depend_refclassid,
|
|
BTEqualStrategyNumber, F_OIDEQ,
|
|
ObjectIdGetDatum(object->classId));
|
|
ScanKeyInit(&key[1],
|
|
Anum_pg_depend_refobjid,
|
|
BTEqualStrategyNumber, F_OIDEQ,
|
|
ObjectIdGetDatum(object->objectId));
|
|
if (object->objectSubId != 0)
|
|
{
|
|
ScanKeyInit(&key[2],
|
|
Anum_pg_depend_refobjsubid,
|
|
BTEqualStrategyNumber, F_INT4EQ,
|
|
Int32GetDatum(object->objectSubId));
|
|
nkeys = 3;
|
|
}
|
|
else
|
|
nkeys = 2;
|
|
|
|
scan = systable_beginscan(depRel, DependReferenceIndex, true,
|
|
SnapshotNow, nkeys, key);
|
|
|
|
while (HeapTupleIsValid(tup = systable_getnext(scan)))
|
|
{
|
|
Form_pg_depend foundDep = (Form_pg_depend) GETSTRUCT(tup);
|
|
|
|
otherObject.classId = foundDep->classid;
|
|
otherObject.objectId = foundDep->objid;
|
|
otherObject.objectSubId = foundDep->objsubid;
|
|
|
|
switch (foundDep->deptype)
|
|
{
|
|
case DEPENDENCY_NORMAL:
|
|
|
|
/*
|
|
* Perhaps there was another dependency path that would
|
|
* have allowed silent deletion of the otherObject, had we
|
|
* only taken that path first. In that case, act like this
|
|
* link is AUTO, too.
|
|
*/
|
|
if (object_address_present(&otherObject, oktodelete))
|
|
ereport(DEBUG2,
|
|
(errmsg("drop auto-cascades to %s",
|
|
getObjectDescription(&otherObject))));
|
|
else if (behavior == DROP_RESTRICT)
|
|
{
|
|
ereport(msglevel,
|
|
(errmsg("%s depends on %s",
|
|
getObjectDescription(&otherObject),
|
|
objDescription)));
|
|
ok = false;
|
|
}
|
|
else
|
|
ereport(msglevel,
|
|
(errmsg("drop cascades to %s",
|
|
getObjectDescription(&otherObject))));
|
|
|
|
if (!recursiveDeletion(&otherObject, behavior, msglevel,
|
|
object, oktodelete, depRel))
|
|
ok = false;
|
|
break;
|
|
case DEPENDENCY_AUTO:
|
|
case DEPENDENCY_INTERNAL:
|
|
|
|
/*
|
|
* We propagate the DROP without complaint even in the
|
|
* RESTRICT case. (However, normal dependencies on the
|
|
* component object could still cause failure.)
|
|
*/
|
|
ereport(DEBUG2,
|
|
(errmsg("drop auto-cascades to %s",
|
|
getObjectDescription(&otherObject))));
|
|
|
|
if (!recursiveDeletion(&otherObject, behavior, msglevel,
|
|
object, oktodelete, depRel))
|
|
ok = false;
|
|
break;
|
|
case DEPENDENCY_PIN:
|
|
|
|
/*
|
|
* For a PIN dependency we just ereport immediately; there
|
|
* won't be any others to report.
|
|
*/
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
|
|
errmsg("cannot drop %s because it is required by the database system",
|
|
objDescription)));
|
|
break;
|
|
default:
|
|
elog(ERROR, "unrecognized dependency type '%c' for %s",
|
|
foundDep->deptype, objDescription);
|
|
break;
|
|
}
|
|
}
|
|
|
|
systable_endscan(scan);
|
|
|
|
return ok;
|
|
}
|
|
|
|
|
|
/*
|
|
* doDeletion: actually delete a single object
|
|
*/
|
|
static void
|
|
doDeletion(const ObjectAddress *object)
|
|
{
|
|
switch (getObjectClass(object))
|
|
{
|
|
case OCLASS_CLASS:
|
|
{
|
|
char relKind = get_rel_relkind(object->objectId);
|
|
|
|
if (relKind == RELKIND_INDEX)
|
|
{
|
|
Assert(object->objectSubId == 0);
|
|
index_drop(object->objectId);
|
|
}
|
|
else
|
|
{
|
|
if (object->objectSubId != 0)
|
|
RemoveAttributeById(object->objectId,
|
|
object->objectSubId);
|
|
else
|
|
heap_drop_with_catalog(object->objectId);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OCLASS_PROC:
|
|
RemoveFunctionById(object->objectId);
|
|
break;
|
|
|
|
case OCLASS_TYPE:
|
|
RemoveTypeById(object->objectId);
|
|
break;
|
|
|
|
case OCLASS_CAST:
|
|
DropCastById(object->objectId);
|
|
break;
|
|
|
|
case OCLASS_CONSTRAINT:
|
|
RemoveConstraintById(object->objectId);
|
|
break;
|
|
|
|
case OCLASS_CONVERSION:
|
|
RemoveConversionById(object->objectId);
|
|
break;
|
|
|
|
case OCLASS_DEFAULT:
|
|
RemoveAttrDefaultById(object->objectId);
|
|
break;
|
|
|
|
case OCLASS_LANGUAGE:
|
|
DropProceduralLanguageById(object->objectId);
|
|
break;
|
|
|
|
case OCLASS_OPERATOR:
|
|
RemoveOperatorById(object->objectId);
|
|
break;
|
|
|
|
case OCLASS_OPCLASS:
|
|
RemoveOpClassById(object->objectId);
|
|
break;
|
|
|
|
case OCLASS_REWRITE:
|
|
RemoveRewriteRuleById(object->objectId);
|
|
break;
|
|
|
|
case OCLASS_TRIGGER:
|
|
RemoveTriggerById(object->objectId);
|
|
break;
|
|
|
|
case OCLASS_SCHEMA:
|
|
RemoveSchemaById(object->objectId);
|
|
break;
|
|
|
|
default:
|
|
elog(ERROR, "unrecognized object class: %u",
|
|
object->classId);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* recordDependencyOnExpr - find expression dependencies
|
|
*
|
|
* This is used to find the dependencies of rules, constraint expressions,
|
|
* etc.
|
|
*
|
|
* Given an expression or query in node-tree form, find all the objects
|
|
* it refers to (tables, columns, operators, functions, etc). Record
|
|
* a dependency of the specified type from the given depender object
|
|
* to each object mentioned in the expression.
|
|
*
|
|
* rtable is the rangetable to be used to interpret Vars with varlevelsup=0.
|
|
* It can be NIL if no such variables are expected.
|
|
*
|
|
* XXX is it important to create dependencies on the datatypes mentioned in
|
|
* the expression? In most cases this would be redundant (eg, a ref to an
|
|
* operator indirectly references its input and output datatypes), but I'm
|
|
* not quite convinced there are no cases where we need it.
|
|
*/
|
|
void
|
|
recordDependencyOnExpr(const ObjectAddress *depender,
|
|
Node *expr, List *rtable,
|
|
DependencyType behavior)
|
|
{
|
|
find_expr_references_context context;
|
|
|
|
init_object_addresses(&context.addrs);
|
|
|
|
/* Set up interpretation for Vars at varlevelsup = 0 */
|
|
context.rtables = makeList1(rtable);
|
|
|
|
/* Scan the expression tree for referenceable objects */
|
|
find_expr_references_walker(expr, &context);
|
|
|
|
/* Remove any duplicates */
|
|
eliminate_duplicate_dependencies(&context.addrs);
|
|
|
|
/* And record 'em */
|
|
recordMultipleDependencies(depender,
|
|
context.addrs.refs, context.addrs.numrefs,
|
|
behavior);
|
|
|
|
term_object_addresses(&context.addrs);
|
|
}
|
|
|
|
/*
|
|
* recordDependencyOnSingleRelExpr - find expression dependencies
|
|
*
|
|
* As above, but only one relation is expected to be referenced (with
|
|
* varno = 1 and varlevelsup = 0). Pass the relation OID instead of a
|
|
* range table. An additional frammish is that dependencies on that
|
|
* relation (or its component columns) will be marked with 'self_behavior',
|
|
* whereas 'behavior' is used for everything else.
|
|
*/
|
|
void
|
|
recordDependencyOnSingleRelExpr(const ObjectAddress *depender,
|
|
Node *expr, Oid relId,
|
|
DependencyType behavior,
|
|
DependencyType self_behavior)
|
|
{
|
|
find_expr_references_context context;
|
|
RangeTblEntry rte;
|
|
|
|
init_object_addresses(&context.addrs);
|
|
|
|
/* We gin up a rather bogus rangetable list to handle Vars */
|
|
MemSet(&rte, 0, sizeof(rte));
|
|
rte.type = T_RangeTblEntry;
|
|
rte.rtekind = RTE_RELATION;
|
|
rte.relid = relId;
|
|
|
|
context.rtables = makeList1(makeList1(&rte));
|
|
|
|
/* Scan the expression tree for referenceable objects */
|
|
find_expr_references_walker(expr, &context);
|
|
|
|
/* Remove any duplicates */
|
|
eliminate_duplicate_dependencies(&context.addrs);
|
|
|
|
/* Separate self-dependencies if necessary */
|
|
if (behavior != self_behavior && context.addrs.numrefs > 0)
|
|
{
|
|
ObjectAddresses self_addrs;
|
|
ObjectAddress *outobj;
|
|
int oldref,
|
|
outrefs;
|
|
|
|
init_object_addresses(&self_addrs);
|
|
|
|
outobj = context.addrs.refs;
|
|
outrefs = 0;
|
|
for (oldref = 0; oldref < context.addrs.numrefs; oldref++)
|
|
{
|
|
ObjectAddress *thisobj = context.addrs.refs + oldref;
|
|
|
|
if (thisobj->classId == RelOid_pg_class &&
|
|
thisobj->objectId == relId)
|
|
{
|
|
/* Move this ref into self_addrs */
|
|
add_object_address(OCLASS_CLASS, relId, thisobj->objectSubId,
|
|
&self_addrs);
|
|
}
|
|
else
|
|
{
|
|
/* Keep it in context.addrs */
|
|
outobj->classId = thisobj->classId;
|
|
outobj->objectId = thisobj->objectId;
|
|
outobj->objectSubId = thisobj->objectSubId;
|
|
outobj++;
|
|
outrefs++;
|
|
}
|
|
}
|
|
context.addrs.numrefs = outrefs;
|
|
|
|
/* Record the self-dependencies */
|
|
recordMultipleDependencies(depender,
|
|
self_addrs.refs, self_addrs.numrefs,
|
|
self_behavior);
|
|
|
|
term_object_addresses(&self_addrs);
|
|
}
|
|
|
|
/* Record the external dependencies */
|
|
recordMultipleDependencies(depender,
|
|
context.addrs.refs, context.addrs.numrefs,
|
|
behavior);
|
|
|
|
term_object_addresses(&context.addrs);
|
|
}
|
|
|
|
/*
|
|
* Recursively search an expression tree for object references.
|
|
*
|
|
* Note: we avoid creating references to columns of tables that participate
|
|
* in an SQL JOIN construct, but are not actually used anywhere in the query.
|
|
* To do so, we do not scan the joinaliasvars list of a join RTE while
|
|
* scanning the query rangetable, but instead scan each individual entry
|
|
* of the alias list when we find a reference to it.
|
|
*/
|
|
static bool
|
|
find_expr_references_walker(Node *node,
|
|
find_expr_references_context *context)
|
|
{
|
|
if (node == NULL)
|
|
return false;
|
|
if (IsA(node, Var))
|
|
{
|
|
Var *var = (Var *) node;
|
|
int levelsup;
|
|
List *rtable,
|
|
*rtables;
|
|
RangeTblEntry *rte;
|
|
|
|
/* Find matching rtable entry, or complain if not found */
|
|
levelsup = var->varlevelsup;
|
|
rtables = context->rtables;
|
|
while (levelsup--)
|
|
{
|
|
if (rtables == NIL)
|
|
break;
|
|
rtables = lnext(rtables);
|
|
}
|
|
if (rtables == NIL)
|
|
elog(ERROR, "invalid varlevelsup %d", var->varlevelsup);
|
|
rtable = lfirst(rtables);
|
|
if (var->varno <= 0 || var->varno > length(rtable))
|
|
elog(ERROR, "invalid varno %d", var->varno);
|
|
rte = rt_fetch(var->varno, rtable);
|
|
if (rte->rtekind == RTE_RELATION)
|
|
{
|
|
/* If it's a plain relation, reference this column */
|
|
/* NB: this code works for whole-row Var with attno 0, too */
|
|
add_object_address(OCLASS_CLASS, rte->relid, var->varattno,
|
|
&context->addrs);
|
|
}
|
|
else if (rte->rtekind == RTE_JOIN)
|
|
{
|
|
/* Scan join output column to add references to join inputs */
|
|
List *save_rtables;
|
|
|
|
/* We must make the context appropriate for join's level */
|
|
save_rtables = context->rtables;
|
|
context->rtables = rtables;
|
|
if (var->varattno <= 0 ||
|
|
var->varattno > length(rte->joinaliasvars))
|
|
elog(ERROR, "invalid varattno %d", var->varattno);
|
|
find_expr_references_walker((Node *) nth(var->varattno - 1,
|
|
rte->joinaliasvars),
|
|
context);
|
|
context->rtables = save_rtables;
|
|
}
|
|
return false;
|
|
}
|
|
if (IsA(node, FuncExpr))
|
|
{
|
|
FuncExpr *funcexpr = (FuncExpr *) node;
|
|
|
|
add_object_address(OCLASS_PROC, funcexpr->funcid, 0,
|
|
&context->addrs);
|
|
/* fall through to examine arguments */
|
|
}
|
|
if (IsA(node, OpExpr))
|
|
{
|
|
OpExpr *opexpr = (OpExpr *) node;
|
|
|
|
add_object_address(OCLASS_OPERATOR, opexpr->opno, 0,
|
|
&context->addrs);
|
|
/* fall through to examine arguments */
|
|
}
|
|
if (IsA(node, DistinctExpr))
|
|
{
|
|
DistinctExpr *distinctexpr = (DistinctExpr *) node;
|
|
|
|
add_object_address(OCLASS_OPERATOR, distinctexpr->opno, 0,
|
|
&context->addrs);
|
|
/* fall through to examine arguments */
|
|
}
|
|
if (IsA(node, ScalarArrayOpExpr))
|
|
{
|
|
ScalarArrayOpExpr *opexpr = (ScalarArrayOpExpr *) node;
|
|
|
|
add_object_address(OCLASS_OPERATOR, opexpr->opno, 0,
|
|
&context->addrs);
|
|
/* fall through to examine arguments */
|
|
}
|
|
if (IsA(node, NullIfExpr))
|
|
{
|
|
NullIfExpr *nullifexpr = (NullIfExpr *) node;
|
|
|
|
add_object_address(OCLASS_OPERATOR, nullifexpr->opno, 0,
|
|
&context->addrs);
|
|
/* fall through to examine arguments */
|
|
}
|
|
if (IsA(node, Aggref))
|
|
{
|
|
Aggref *aggref = (Aggref *) node;
|
|
|
|
add_object_address(OCLASS_PROC, aggref->aggfnoid, 0,
|
|
&context->addrs);
|
|
/* fall through to examine arguments */
|
|
}
|
|
if (IsA(node, SubLink))
|
|
{
|
|
SubLink *sublink = (SubLink *) node;
|
|
List *opid;
|
|
|
|
foreach(opid, sublink->operOids)
|
|
{
|
|
add_object_address(OCLASS_OPERATOR, lfirsto(opid), 0,
|
|
&context->addrs);
|
|
}
|
|
/* fall through to examine arguments */
|
|
}
|
|
if (is_subplan(node))
|
|
{
|
|
/* Extra work needed here if we ever need this case */
|
|
elog(ERROR, "already-planned subqueries not supported");
|
|
}
|
|
if (IsA(node, Query))
|
|
{
|
|
/* Recurse into RTE subquery or not-yet-planned sublink subquery */
|
|
Query *query = (Query *) node;
|
|
List *rtable;
|
|
bool result;
|
|
|
|
/*
|
|
* Add whole-relation refs for each plain relation mentioned in
|
|
* the subquery's rtable. (Note: query_tree_walker takes care of
|
|
* recursing into RTE_FUNCTION and RTE_SUBQUERY RTEs, so no need
|
|
* to do that here. But keep it from looking at join alias
|
|
* lists.)
|
|
*/
|
|
foreach(rtable, query->rtable)
|
|
{
|
|
RangeTblEntry *rte = (RangeTblEntry *) lfirst(rtable);
|
|
|
|
if (rte->rtekind == RTE_RELATION)
|
|
add_object_address(OCLASS_CLASS, rte->relid, 0,
|
|
&context->addrs);
|
|
}
|
|
|
|
/* Examine substructure of query */
|
|
context->rtables = lcons(query->rtable, context->rtables);
|
|
result = query_tree_walker(query,
|
|
find_expr_references_walker,
|
|
(void *) context,
|
|
QTW_IGNORE_JOINALIASES);
|
|
context->rtables = lnext(context->rtables);
|
|
return result;
|
|
}
|
|
return expression_tree_walker(node, find_expr_references_walker,
|
|
(void *) context);
|
|
}
|
|
|
|
/*
|
|
* Given an array of dependency references, eliminate any duplicates.
|
|
*/
|
|
static void
|
|
eliminate_duplicate_dependencies(ObjectAddresses *addrs)
|
|
{
|
|
ObjectAddress *priorobj;
|
|
int oldref,
|
|
newrefs;
|
|
|
|
if (addrs->numrefs <= 1)
|
|
return; /* nothing to do */
|
|
|
|
/* Sort the refs so that duplicates are adjacent */
|
|
qsort((void *) addrs->refs, addrs->numrefs, sizeof(ObjectAddress),
|
|
object_address_comparator);
|
|
|
|
/* Remove dups */
|
|
priorobj = addrs->refs;
|
|
newrefs = 1;
|
|
for (oldref = 1; oldref < addrs->numrefs; oldref++)
|
|
{
|
|
ObjectAddress *thisobj = addrs->refs + oldref;
|
|
|
|
if (priorobj->classId == thisobj->classId &&
|
|
priorobj->objectId == thisobj->objectId)
|
|
{
|
|
if (priorobj->objectSubId == thisobj->objectSubId)
|
|
continue; /* identical, so drop thisobj */
|
|
|
|
/*
|
|
* If we have a whole-object reference and a reference to a
|
|
* part of the same object, we don't need the whole-object
|
|
* reference (for example, we don't need to reference both
|
|
* table foo and column foo.bar). The whole-object reference
|
|
* will always appear first in the sorted list.
|
|
*/
|
|
if (priorobj->objectSubId == 0)
|
|
{
|
|
/* replace whole ref with partial */
|
|
priorobj->objectSubId = thisobj->objectSubId;
|
|
continue;
|
|
}
|
|
}
|
|
/* Not identical, so add thisobj to output set */
|
|
priorobj++;
|
|
priorobj->classId = thisobj->classId;
|
|
priorobj->objectId = thisobj->objectId;
|
|
priorobj->objectSubId = thisobj->objectSubId;
|
|
newrefs++;
|
|
}
|
|
|
|
addrs->numrefs = newrefs;
|
|
}
|
|
|
|
/*
|
|
* qsort comparator for ObjectAddress items
|
|
*/
|
|
static int
|
|
object_address_comparator(const void *a, const void *b)
|
|
{
|
|
const ObjectAddress *obja = (const ObjectAddress *) a;
|
|
const ObjectAddress *objb = (const ObjectAddress *) b;
|
|
|
|
if (obja->classId < objb->classId)
|
|
return -1;
|
|
if (obja->classId > objb->classId)
|
|
return 1;
|
|
if (obja->objectId < objb->objectId)
|
|
return -1;
|
|
if (obja->objectId > objb->objectId)
|
|
return 1;
|
|
|
|
/*
|
|
* We sort the subId as an unsigned int so that 0 will come first. See
|
|
* logic in eliminate_duplicate_dependencies.
|
|
*/
|
|
if ((unsigned int) obja->objectSubId < (unsigned int) objb->objectSubId)
|
|
return -1;
|
|
if ((unsigned int) obja->objectSubId > (unsigned int) objb->objectSubId)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Routines for handling an expansible array of ObjectAddress items.
|
|
*
|
|
* init_object_addresses: initialize an ObjectAddresses array.
|
|
*/
|
|
static void
|
|
init_object_addresses(ObjectAddresses *addrs)
|
|
{
|
|
/* Initialize array to empty */
|
|
addrs->numrefs = 0;
|
|
addrs->maxrefs = 32; /* arbitrary initial array size */
|
|
addrs->refs = (ObjectAddress *)
|
|
palloc(addrs->maxrefs * sizeof(ObjectAddress));
|
|
|
|
/* Initialize object_classes[] if not done yet */
|
|
/* This will be needed by add_object_address() */
|
|
if (!object_classes_initialized)
|
|
init_object_classes();
|
|
}
|
|
|
|
/*
|
|
* Add an entry to an ObjectAddresses array.
|
|
*
|
|
* It is convenient to specify the class by ObjectClass rather than directly
|
|
* by catalog OID.
|
|
*/
|
|
static void
|
|
add_object_address(ObjectClasses oclass, Oid objectId, int32 subId,
|
|
ObjectAddresses *addrs)
|
|
{
|
|
ObjectAddress *item;
|
|
|
|
/* enlarge array if needed */
|
|
if (addrs->numrefs >= addrs->maxrefs)
|
|
{
|
|
addrs->maxrefs *= 2;
|
|
addrs->refs = (ObjectAddress *)
|
|
repalloc(addrs->refs, addrs->maxrefs * sizeof(ObjectAddress));
|
|
}
|
|
/* record this item */
|
|
item = addrs->refs + addrs->numrefs;
|
|
item->classId = object_classes[oclass];
|
|
item->objectId = objectId;
|
|
item->objectSubId = subId;
|
|
addrs->numrefs++;
|
|
}
|
|
|
|
/*
|
|
* Add an entry to an ObjectAddresses array.
|
|
*
|
|
* As above, but specify entry exactly.
|
|
*/
|
|
static void
|
|
add_exact_object_address(const ObjectAddress *object,
|
|
ObjectAddresses *addrs)
|
|
{
|
|
ObjectAddress *item;
|
|
|
|
/* enlarge array if needed */
|
|
if (addrs->numrefs >= addrs->maxrefs)
|
|
{
|
|
addrs->maxrefs *= 2;
|
|
addrs->refs = (ObjectAddress *)
|
|
repalloc(addrs->refs, addrs->maxrefs * sizeof(ObjectAddress));
|
|
}
|
|
/* record this item */
|
|
item = addrs->refs + addrs->numrefs;
|
|
*item = *object;
|
|
addrs->numrefs++;
|
|
}
|
|
|
|
/*
|
|
* Test whether an object is present in an ObjectAddresses array.
|
|
*
|
|
* We return "true" if object is a subobject of something in the array, too.
|
|
*/
|
|
static bool
|
|
object_address_present(const ObjectAddress *object,
|
|
ObjectAddresses *addrs)
|
|
{
|
|
int i;
|
|
|
|
for (i = addrs->numrefs - 1; i >= 0; i--)
|
|
{
|
|
ObjectAddress *thisobj = addrs->refs + i;
|
|
|
|
if (object->classId == thisobj->classId &&
|
|
object->objectId == thisobj->objectId)
|
|
{
|
|
if (object->objectSubId == thisobj->objectSubId ||
|
|
thisobj->objectSubId == 0)
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* Clean up when done with an ObjectAddresses array.
|
|
*/
|
|
static void
|
|
term_object_addresses(ObjectAddresses *addrs)
|
|
{
|
|
pfree(addrs->refs);
|
|
}
|
|
|
|
/*
|
|
* Initialize the object_classes[] table.
|
|
*
|
|
* Although some of these OIDs aren't compile-time constants, they surely
|
|
* shouldn't change during a backend's run. So, we look them up the
|
|
* first time through and then cache them.
|
|
*/
|
|
static void
|
|
init_object_classes(void)
|
|
{
|
|
object_classes[OCLASS_CLASS] = RelOid_pg_class;
|
|
object_classes[OCLASS_PROC] = RelOid_pg_proc;
|
|
object_classes[OCLASS_TYPE] = RelOid_pg_type;
|
|
object_classes[OCLASS_CAST] = get_system_catalog_relid(CastRelationName);
|
|
object_classes[OCLASS_CONSTRAINT] = get_system_catalog_relid(ConstraintRelationName);
|
|
object_classes[OCLASS_CONVERSION] = get_system_catalog_relid(ConversionRelationName);
|
|
object_classes[OCLASS_DEFAULT] = get_system_catalog_relid(AttrDefaultRelationName);
|
|
object_classes[OCLASS_LANGUAGE] = get_system_catalog_relid(LanguageRelationName);
|
|
object_classes[OCLASS_OPERATOR] = get_system_catalog_relid(OperatorRelationName);
|
|
object_classes[OCLASS_OPCLASS] = get_system_catalog_relid(OperatorClassRelationName);
|
|
object_classes[OCLASS_REWRITE] = get_system_catalog_relid(RewriteRelationName);
|
|
object_classes[OCLASS_TRIGGER] = get_system_catalog_relid(TriggerRelationName);
|
|
object_classes[OCLASS_SCHEMA] = get_system_catalog_relid(NamespaceRelationName);
|
|
object_classes_initialized = true;
|
|
}
|
|
|
|
/*
|
|
* Determine the class of a given object identified by objectAddress.
|
|
*
|
|
* This function is needed just because some of the system catalogs do
|
|
* not have hardwired-at-compile-time OIDs.
|
|
*/
|
|
static ObjectClasses
|
|
getObjectClass(const ObjectAddress *object)
|
|
{
|
|
/* Easy for the bootstrapped catalogs... */
|
|
switch (object->classId)
|
|
{
|
|
case RelOid_pg_class:
|
|
/* caller must check objectSubId */
|
|
return OCLASS_CLASS;
|
|
|
|
case RelOid_pg_proc:
|
|
Assert(object->objectSubId == 0);
|
|
return OCLASS_PROC;
|
|
|
|
case RelOid_pg_type:
|
|
Assert(object->objectSubId == 0);
|
|
return OCLASS_TYPE;
|
|
}
|
|
|
|
/*
|
|
* Handle cases where catalog's OID is not hardwired.
|
|
*/
|
|
if (!object_classes_initialized)
|
|
init_object_classes();
|
|
|
|
if (object->classId == object_classes[OCLASS_CAST])
|
|
{
|
|
Assert(object->objectSubId == 0);
|
|
return OCLASS_CAST;
|
|
}
|
|
if (object->classId == object_classes[OCLASS_CONSTRAINT])
|
|
{
|
|
Assert(object->objectSubId == 0);
|
|
return OCLASS_CONSTRAINT;
|
|
}
|
|
if (object->classId == object_classes[OCLASS_CONVERSION])
|
|
{
|
|
Assert(object->objectSubId == 0);
|
|
return OCLASS_CONVERSION;
|
|
}
|
|
if (object->classId == object_classes[OCLASS_DEFAULT])
|
|
{
|
|
Assert(object->objectSubId == 0);
|
|
return OCLASS_DEFAULT;
|
|
}
|
|
if (object->classId == object_classes[OCLASS_LANGUAGE])
|
|
{
|
|
Assert(object->objectSubId == 0);
|
|
return OCLASS_LANGUAGE;
|
|
}
|
|
if (object->classId == object_classes[OCLASS_OPERATOR])
|
|
{
|
|
Assert(object->objectSubId == 0);
|
|
return OCLASS_OPERATOR;
|
|
}
|
|
if (object->classId == object_classes[OCLASS_OPCLASS])
|
|
{
|
|
Assert(object->objectSubId == 0);
|
|
return OCLASS_OPCLASS;
|
|
}
|
|
if (object->classId == object_classes[OCLASS_REWRITE])
|
|
{
|
|
Assert(object->objectSubId == 0);
|
|
return OCLASS_REWRITE;
|
|
}
|
|
if (object->classId == object_classes[OCLASS_TRIGGER])
|
|
{
|
|
Assert(object->objectSubId == 0);
|
|
return OCLASS_TRIGGER;
|
|
}
|
|
if (object->classId == object_classes[OCLASS_SCHEMA])
|
|
{
|
|
Assert(object->objectSubId == 0);
|
|
return OCLASS_SCHEMA;
|
|
}
|
|
|
|
elog(ERROR, "unrecognized object class: %u", object->classId);
|
|
return OCLASS_CLASS; /* keep compiler quiet */
|
|
}
|
|
|
|
/*
|
|
* getObjectDescription: build an object description for messages
|
|
*
|
|
* The result is a palloc'd string.
|
|
*/
|
|
static char *
|
|
getObjectDescription(const ObjectAddress *object)
|
|
{
|
|
StringInfoData buffer;
|
|
|
|
initStringInfo(&buffer);
|
|
|
|
switch (getObjectClass(object))
|
|
{
|
|
case OCLASS_CLASS:
|
|
getRelationDescription(&buffer, object->objectId);
|
|
if (object->objectSubId != 0)
|
|
appendStringInfo(&buffer, " column %s",
|
|
get_relid_attribute_name(object->objectId,
|
|
object->objectSubId));
|
|
break;
|
|
|
|
case OCLASS_PROC:
|
|
appendStringInfo(&buffer, "function %s",
|
|
format_procedure(object->objectId));
|
|
break;
|
|
|
|
case OCLASS_TYPE:
|
|
appendStringInfo(&buffer, "type %s",
|
|
format_type_be(object->objectId));
|
|
break;
|
|
|
|
case OCLASS_CAST:
|
|
{
|
|
Relation castDesc;
|
|
ScanKeyData skey[1];
|
|
SysScanDesc rcscan;
|
|
HeapTuple tup;
|
|
Form_pg_cast castForm;
|
|
|
|
castDesc = heap_openr(CastRelationName, AccessShareLock);
|
|
|
|
ScanKeyInit(&skey[0],
|
|
ObjectIdAttributeNumber,
|
|
BTEqualStrategyNumber, F_OIDEQ,
|
|
ObjectIdGetDatum(object->objectId));
|
|
|
|
rcscan = systable_beginscan(castDesc, CastOidIndex, true,
|
|
SnapshotNow, 1, skey);
|
|
|
|
tup = systable_getnext(rcscan);
|
|
|
|
if (!HeapTupleIsValid(tup))
|
|
elog(ERROR, "could not find tuple for cast %u",
|
|
object->objectId);
|
|
|
|
castForm = (Form_pg_cast) GETSTRUCT(tup);
|
|
|
|
appendStringInfo(&buffer, "cast from %s to %s",
|
|
format_type_be(castForm->castsource),
|
|
format_type_be(castForm->casttarget));
|
|
|
|
systable_endscan(rcscan);
|
|
heap_close(castDesc, AccessShareLock);
|
|
break;
|
|
}
|
|
|
|
case OCLASS_CONSTRAINT:
|
|
{
|
|
Relation conDesc;
|
|
ScanKeyData skey[1];
|
|
SysScanDesc rcscan;
|
|
HeapTuple tup;
|
|
Form_pg_constraint con;
|
|
|
|
conDesc = heap_openr(ConstraintRelationName, AccessShareLock);
|
|
|
|
ScanKeyInit(&skey[0],
|
|
ObjectIdAttributeNumber,
|
|
BTEqualStrategyNumber, F_OIDEQ,
|
|
ObjectIdGetDatum(object->objectId));
|
|
|
|
rcscan = systable_beginscan(conDesc, ConstraintOidIndex, true,
|
|
SnapshotNow, 1, skey);
|
|
|
|
tup = systable_getnext(rcscan);
|
|
|
|
if (!HeapTupleIsValid(tup))
|
|
elog(ERROR, "could not find tuple for constraint %u",
|
|
object->objectId);
|
|
|
|
con = (Form_pg_constraint) GETSTRUCT(tup);
|
|
|
|
if (OidIsValid(con->conrelid))
|
|
{
|
|
appendStringInfo(&buffer, "constraint %s on ",
|
|
NameStr(con->conname));
|
|
getRelationDescription(&buffer, con->conrelid);
|
|
}
|
|
else
|
|
{
|
|
appendStringInfo(&buffer, "constraint %s",
|
|
NameStr(con->conname));
|
|
}
|
|
|
|
systable_endscan(rcscan);
|
|
heap_close(conDesc, AccessShareLock);
|
|
break;
|
|
}
|
|
|
|
case OCLASS_CONVERSION:
|
|
{
|
|
HeapTuple conTup;
|
|
|
|
conTup = SearchSysCache(CONOID,
|
|
ObjectIdGetDatum(object->objectId),
|
|
0, 0, 0);
|
|
if (!HeapTupleIsValid(conTup))
|
|
elog(ERROR, "cache lookup failed for conversion %u",
|
|
object->objectId);
|
|
appendStringInfo(&buffer, "conversion %s",
|
|
NameStr(((Form_pg_conversion) GETSTRUCT(conTup))->conname));
|
|
ReleaseSysCache(conTup);
|
|
break;
|
|
}
|
|
|
|
case OCLASS_DEFAULT:
|
|
{
|
|
Relation attrdefDesc;
|
|
ScanKeyData skey[1];
|
|
SysScanDesc adscan;
|
|
HeapTuple tup;
|
|
Form_pg_attrdef attrdef;
|
|
ObjectAddress colobject;
|
|
|
|
attrdefDesc = heap_openr(AttrDefaultRelationName, AccessShareLock);
|
|
|
|
ScanKeyInit(&skey[0],
|
|
ObjectIdAttributeNumber,
|
|
BTEqualStrategyNumber, F_OIDEQ,
|
|
ObjectIdGetDatum(object->objectId));
|
|
|
|
adscan = systable_beginscan(attrdefDesc, AttrDefaultOidIndex,
|
|
true, SnapshotNow, 1, skey);
|
|
|
|
tup = systable_getnext(adscan);
|
|
|
|
if (!HeapTupleIsValid(tup))
|
|
elog(ERROR, "could not find tuple for attrdef %u",
|
|
object->objectId);
|
|
|
|
attrdef = (Form_pg_attrdef) GETSTRUCT(tup);
|
|
|
|
colobject.classId = RelOid_pg_class;
|
|
colobject.objectId = attrdef->adrelid;
|
|
colobject.objectSubId = attrdef->adnum;
|
|
|
|
appendStringInfo(&buffer, "default for %s",
|
|
getObjectDescription(&colobject));
|
|
|
|
systable_endscan(adscan);
|
|
heap_close(attrdefDesc, AccessShareLock);
|
|
break;
|
|
}
|
|
|
|
case OCLASS_LANGUAGE:
|
|
{
|
|
HeapTuple langTup;
|
|
|
|
langTup = SearchSysCache(LANGOID,
|
|
ObjectIdGetDatum(object->objectId),
|
|
0, 0, 0);
|
|
if (!HeapTupleIsValid(langTup))
|
|
elog(ERROR, "cache lookup failed for language %u",
|
|
object->objectId);
|
|
appendStringInfo(&buffer, "language %s",
|
|
NameStr(((Form_pg_language) GETSTRUCT(langTup))->lanname));
|
|
ReleaseSysCache(langTup);
|
|
break;
|
|
}
|
|
|
|
case OCLASS_OPERATOR:
|
|
appendStringInfo(&buffer, "operator %s",
|
|
format_operator(object->objectId));
|
|
break;
|
|
|
|
case OCLASS_OPCLASS:
|
|
{
|
|
HeapTuple opcTup;
|
|
Form_pg_opclass opcForm;
|
|
HeapTuple amTup;
|
|
Form_pg_am amForm;
|
|
char *nspname;
|
|
|
|
opcTup = SearchSysCache(CLAOID,
|
|
ObjectIdGetDatum(object->objectId),
|
|
0, 0, 0);
|
|
if (!HeapTupleIsValid(opcTup))
|
|
elog(ERROR, "cache lookup failed for opclass %u",
|
|
object->objectId);
|
|
opcForm = (Form_pg_opclass) GETSTRUCT(opcTup);
|
|
|
|
/* Qualify the name if not visible in search path */
|
|
if (OpclassIsVisible(object->objectId))
|
|
nspname = NULL;
|
|
else
|
|
nspname = get_namespace_name(opcForm->opcnamespace);
|
|
|
|
appendStringInfo(&buffer, "operator class %s",
|
|
quote_qualified_identifier(nspname,
|
|
NameStr(opcForm->opcname)));
|
|
|
|
amTup = SearchSysCache(AMOID,
|
|
ObjectIdGetDatum(opcForm->opcamid),
|
|
0, 0, 0);
|
|
if (!HeapTupleIsValid(amTup))
|
|
elog(ERROR, "cache lookup failed for access method %u",
|
|
opcForm->opcamid);
|
|
amForm = (Form_pg_am) GETSTRUCT(amTup);
|
|
|
|
appendStringInfo(&buffer, " for %s",
|
|
NameStr(amForm->amname));
|
|
|
|
ReleaseSysCache(amTup);
|
|
ReleaseSysCache(opcTup);
|
|
break;
|
|
}
|
|
|
|
case OCLASS_REWRITE:
|
|
{
|
|
Relation ruleDesc;
|
|
ScanKeyData skey[1];
|
|
SysScanDesc rcscan;
|
|
HeapTuple tup;
|
|
Form_pg_rewrite rule;
|
|
|
|
ruleDesc = heap_openr(RewriteRelationName, AccessShareLock);
|
|
|
|
ScanKeyInit(&skey[0],
|
|
ObjectIdAttributeNumber,
|
|
BTEqualStrategyNumber, F_OIDEQ,
|
|
ObjectIdGetDatum(object->objectId));
|
|
|
|
rcscan = systable_beginscan(ruleDesc, RewriteOidIndex, true,
|
|
SnapshotNow, 1, skey);
|
|
|
|
tup = systable_getnext(rcscan);
|
|
|
|
if (!HeapTupleIsValid(tup))
|
|
elog(ERROR, "could not find tuple for rule %u",
|
|
object->objectId);
|
|
|
|
rule = (Form_pg_rewrite) GETSTRUCT(tup);
|
|
|
|
appendStringInfo(&buffer, "rule %s on ",
|
|
NameStr(rule->rulename));
|
|
getRelationDescription(&buffer, rule->ev_class);
|
|
|
|
systable_endscan(rcscan);
|
|
heap_close(ruleDesc, AccessShareLock);
|
|
break;
|
|
}
|
|
|
|
case OCLASS_TRIGGER:
|
|
{
|
|
Relation trigDesc;
|
|
ScanKeyData skey[1];
|
|
SysScanDesc tgscan;
|
|
HeapTuple tup;
|
|
Form_pg_trigger trig;
|
|
|
|
trigDesc = heap_openr(TriggerRelationName, AccessShareLock);
|
|
|
|
ScanKeyInit(&skey[0],
|
|
ObjectIdAttributeNumber,
|
|
BTEqualStrategyNumber, F_OIDEQ,
|
|
ObjectIdGetDatum(object->objectId));
|
|
|
|
tgscan = systable_beginscan(trigDesc, TriggerOidIndex, true,
|
|
SnapshotNow, 1, skey);
|
|
|
|
tup = systable_getnext(tgscan);
|
|
|
|
if (!HeapTupleIsValid(tup))
|
|
elog(ERROR, "could not find tuple for trigger %u",
|
|
object->objectId);
|
|
|
|
trig = (Form_pg_trigger) GETSTRUCT(tup);
|
|
|
|
appendStringInfo(&buffer, "trigger %s on ",
|
|
NameStr(trig->tgname));
|
|
getRelationDescription(&buffer, trig->tgrelid);
|
|
|
|
systable_endscan(tgscan);
|
|
heap_close(trigDesc, AccessShareLock);
|
|
break;
|
|
}
|
|
|
|
case OCLASS_SCHEMA:
|
|
{
|
|
char *nspname;
|
|
|
|
nspname = get_namespace_name(object->objectId);
|
|
if (!nspname)
|
|
elog(ERROR, "cache lookup failed for namespace %u",
|
|
object->objectId);
|
|
appendStringInfo(&buffer, "schema %s", nspname);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
appendStringInfo(&buffer, "unrecognized object %u %u %d",
|
|
object->classId,
|
|
object->objectId,
|
|
object->objectSubId);
|
|
break;
|
|
}
|
|
|
|
return buffer.data;
|
|
}
|
|
|
|
/*
|
|
* subroutine for getObjectDescription: describe a relation
|
|
*/
|
|
static void
|
|
getRelationDescription(StringInfo buffer, Oid relid)
|
|
{
|
|
HeapTuple relTup;
|
|
Form_pg_class relForm;
|
|
char *nspname;
|
|
char *relname;
|
|
|
|
relTup = SearchSysCache(RELOID,
|
|
ObjectIdGetDatum(relid),
|
|
0, 0, 0);
|
|
if (!HeapTupleIsValid(relTup))
|
|
elog(ERROR, "cache lookup failed for relation %u", relid);
|
|
relForm = (Form_pg_class) GETSTRUCT(relTup);
|
|
|
|
/* Qualify the name if not visible in search path */
|
|
if (RelationIsVisible(relid))
|
|
nspname = NULL;
|
|
else
|
|
nspname = get_namespace_name(relForm->relnamespace);
|
|
|
|
relname = quote_qualified_identifier(nspname, NameStr(relForm->relname));
|
|
|
|
switch (relForm->relkind)
|
|
{
|
|
case RELKIND_RELATION:
|
|
appendStringInfo(buffer, "table %s",
|
|
relname);
|
|
break;
|
|
case RELKIND_INDEX:
|
|
appendStringInfo(buffer, "index %s",
|
|
relname);
|
|
break;
|
|
case RELKIND_SPECIAL:
|
|
appendStringInfo(buffer, "special system relation %s",
|
|
relname);
|
|
break;
|
|
case RELKIND_SEQUENCE:
|
|
appendStringInfo(buffer, "sequence %s",
|
|
relname);
|
|
break;
|
|
case RELKIND_UNCATALOGED:
|
|
appendStringInfo(buffer, "uncataloged table %s",
|
|
relname);
|
|
break;
|
|
case RELKIND_TOASTVALUE:
|
|
appendStringInfo(buffer, "toast table %s",
|
|
relname);
|
|
break;
|
|
case RELKIND_VIEW:
|
|
appendStringInfo(buffer, "view %s",
|
|
relname);
|
|
break;
|
|
case RELKIND_COMPOSITE_TYPE:
|
|
appendStringInfo(buffer, "composite type %s",
|
|
relname);
|
|
break;
|
|
default:
|
|
/* shouldn't get here */
|
|
appendStringInfo(buffer, "relation %s",
|
|
relname);
|
|
break;
|
|
}
|
|
|
|
ReleaseSysCache(relTup);
|
|
}
|