Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * dropcmds.c
4 : : * handle various "DROP" operations
5 : : *
6 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : : * Portions Copyright (c) 1994, Regents of the University of California
8 : : *
9 : : *
10 : : * IDENTIFICATION
11 : : * src/backend/commands/dropcmds.c
12 : : *
13 : : *-------------------------------------------------------------------------
14 : : */
15 : : #include "postgres.h"
16 : :
17 : : #include "access/table.h"
18 : : #include "access/xact.h"
19 : : #include "catalog/dependency.h"
20 : : #include "catalog/namespace.h"
21 : : #include "catalog/objectaddress.h"
22 : : #include "catalog/pg_namespace.h"
23 : : #include "catalog/pg_proc.h"
24 : : #include "commands/defrem.h"
25 : : #include "miscadmin.h"
26 : : #include "parser/parse_type.h"
27 : : #include "utils/acl.h"
28 : : #include "utils/lsyscache.h"
29 : :
30 : :
31 : : static void does_not_exist_skipping(ObjectType objtype,
32 : : Node *object);
33 : : static bool owningrel_does_not_exist_skipping(List *object,
34 : : const char **msg, char **name);
35 : : static bool schema_does_not_exist_skipping(List *object,
36 : : const char **msg, char **name);
37 : : static bool type_in_list_does_not_exist_skipping(List *typenames,
38 : : const char **msg, char **name);
39 : :
40 : :
41 : : /*
42 : : * Drop one or more objects.
43 : : *
44 : : * We don't currently handle all object types here. Relations, for example,
45 : : * require special handling, because (for example) indexes have additional
46 : : * locking requirements.
47 : : *
48 : : * We look up all the objects first, and then delete them in a single
49 : : * performMultipleDeletions() call. This avoids unnecessary DROP RESTRICT
50 : : * errors if there are dependencies between them.
51 : : */
52 : : void
53 : 6193 : RemoveObjects(DropStmt *stmt)
54 : : {
55 : : ObjectAddresses *objects;
56 : : ListCell *cell1;
57 : :
58 : 6193 : objects = new_object_addresses();
59 : :
60 [ + - + + : 12300 : foreach(cell1, stmt->objects)
+ + ]
61 : : {
62 : : ObjectAddress address;
63 : 6449 : Node *object = lfirst(cell1);
64 : 6449 : Relation relation = NULL;
65 : : Oid namespaceId;
66 : :
67 : : /* Get an ObjectAddress for the object. */
68 : 6449 : address = get_object_address(stmt->removeType,
69 : : object,
70 : : &relation,
71 : : AccessExclusiveLock,
72 : 6449 : stmt->missing_ok);
73 : :
74 : : /*
75 : : * Issue NOTICE if supplied object was not found. Note this is only
76 : : * relevant in the missing_ok case, because otherwise
77 : : * get_object_address would have thrown an error.
78 : : */
79 [ + + ]: 6159 : if (!OidIsValid(address.objectId))
80 : : {
81 : : Assert(stmt->missing_ok);
82 : 382 : does_not_exist_skipping(stmt->removeType, object);
83 : 382 : continue;
84 : : }
85 : :
86 : : /*
87 : : * Although COMMENT ON FUNCTION, SECURITY LABEL ON FUNCTION, etc. are
88 : : * happy to operate on an aggregate as on any other function, we have
89 : : * historically not allowed this for DROP FUNCTION.
90 : : */
91 [ + + ]: 5777 : if (stmt->removeType == OBJECT_FUNCTION)
92 : : {
93 [ - + ]: 2322 : if (get_func_prokind(address.objectId) == PROKIND_AGGREGATE)
94 [ # # ]: 0 : ereport(ERROR,
95 : : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
96 : : errmsg("\"%s\" is an aggregate function",
97 : : NameListToString(castNode(ObjectWithArgs, object)->objname)),
98 : : errhint("Use DROP AGGREGATE to drop aggregate functions.")));
99 : : }
100 : :
101 : : /* Check permissions. */
102 : 5777 : namespaceId = get_object_namespace(&address);
103 [ + + ]: 5777 : if (!OidIsValid(namespaceId) ||
104 [ + + ]: 3790 : !object_ownercheck(NamespaceRelationId, namespaceId, GetUserId()))
105 : 2099 : check_object_ownership(GetUserId(), stmt->removeType, address,
106 : : object, relation);
107 : :
108 : : /*
109 : : * Make note if a temporary namespace has been accessed in this
110 : : * transaction.
111 : : */
112 [ + + + + ]: 5725 : if (OidIsValid(namespaceId) && isTempNamespace(namespaceId))
113 : 133 : MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPNAMESPACE;
114 : :
115 : : /* Release any relcache reference count, but keep lock until commit. */
116 [ + + ]: 5725 : if (relation)
117 : 767 : table_close(relation, NoLock);
118 : :
119 : 5725 : add_exact_object_address(&address, objects);
120 : : }
121 : :
122 : : /* Here we really delete them. */
123 : 5851 : performMultipleDeletions(objects, stmt->behavior, 0);
124 : :
125 : 5733 : free_object_addresses(objects);
126 : 5733 : }
127 : :
128 : : /*
129 : : * owningrel_does_not_exist_skipping
130 : : * Subroutine for RemoveObjects
131 : : *
132 : : * After determining that a specification for a rule or trigger returns that
133 : : * the specified object does not exist, test whether its owning relation, and
134 : : * its schema, exist or not; if they do, return false --- the trigger or rule
135 : : * itself is missing instead. If the owning relation or its schema do not
136 : : * exist, fill the error message format string and name, and return true.
137 : : */
138 : : static bool
139 : 32 : owningrel_does_not_exist_skipping(List *object, const char **msg, char **name)
140 : : {
141 : : List *parent_object;
142 : : RangeVar *parent_rel;
143 : :
144 : 32 : parent_object = list_copy_head(object, list_length(object) - 1);
145 : :
146 [ + + ]: 32 : if (schema_does_not_exist_skipping(parent_object, msg, name))
147 : 16 : return true;
148 : :
149 : 16 : parent_rel = makeRangeVarFromNameList(parent_object);
150 : :
151 [ + + ]: 16 : if (!OidIsValid(RangeVarGetRelid(parent_rel, NoLock, true)))
152 : : {
153 : 8 : *msg = gettext_noop("relation \"%s\" does not exist, skipping");
154 : 8 : *name = NameListToString(parent_object);
155 : :
156 : 8 : return true;
157 : : }
158 : :
159 : 8 : return false;
160 : : }
161 : :
162 : : /*
163 : : * schema_does_not_exist_skipping
164 : : * Subroutine for RemoveObjects
165 : : *
166 : : * After determining that a specification for a schema-qualifiable object
167 : : * refers to an object that does not exist, test whether the specified schema
168 : : * exists or not. If no schema was specified, or if the schema does exist,
169 : : * return false -- the object itself is missing instead. If the specified
170 : : * schema does not exist, fill the error message format string and the
171 : : * specified schema name, and return true.
172 : : */
173 : : static bool
174 : 334 : schema_does_not_exist_skipping(List *object, const char **msg, char **name)
175 : : {
176 : : RangeVar *rel;
177 : :
178 : 334 : rel = makeRangeVarFromNameList(object);
179 : :
180 [ + + + + ]: 461 : if (rel->schemaname != NULL &&
181 : 127 : !OidIsValid(LookupNamespaceNoError(rel->schemaname)))
182 : : {
183 : 94 : *msg = gettext_noop("schema \"%s\" does not exist, skipping");
184 : 94 : *name = rel->schemaname;
185 : :
186 : 94 : return true;
187 : : }
188 : :
189 : 240 : return false;
190 : : }
191 : :
192 : : /*
193 : : * type_in_list_does_not_exist_skipping
194 : : * Subroutine for RemoveObjects
195 : : *
196 : : * After determining that a specification for a function, cast, aggregate or
197 : : * operator returns that the specified object does not exist, test whether the
198 : : * involved datatypes, and their schemas, exist or not; if they do, return
199 : : * false --- the original object itself is missing instead. If the datatypes
200 : : * or schemas do not exist, fill the error message format string and the
201 : : * missing name, and return true.
202 : : *
203 : : * First parameter is a list of TypeNames.
204 : : */
205 : : static bool
206 : 171 : type_in_list_does_not_exist_skipping(List *typenames, const char **msg,
207 : : char **name)
208 : : {
209 : : ListCell *l;
210 : :
211 [ + + + + : 232 : foreach(l, typenames)
+ + ]
212 : : {
213 : 107 : TypeName *typeName = lfirst_node(TypeName, l);
214 : :
215 [ + + ]: 107 : if (typeName != NULL)
216 : : {
217 [ + + ]: 103 : if (!OidIsValid(LookupTypeNameOid(NULL, typeName, true)))
218 : : {
219 : : /* type doesn't exist, try to find why */
220 [ + + ]: 46 : if (schema_does_not_exist_skipping(typeName->names, msg, name))
221 : 46 : return true;
222 : :
223 : 22 : *msg = gettext_noop("type \"%s\" does not exist, skipping");
224 : 22 : *name = TypeNameToString(typeName);
225 : :
226 : 22 : return true;
227 : : }
228 : : }
229 : : }
230 : :
231 : 125 : return false;
232 : : }
233 : :
234 : : /*
235 : : * does_not_exist_skipping
236 : : * Subroutine for RemoveObjects
237 : : *
238 : : * Generate a NOTICE stating that the named object was not found, and is
239 : : * being skipped. This is only relevant when "IF EXISTS" is used; otherwise,
240 : : * get_object_address() in RemoveObjects would have thrown an ERROR.
241 : : */
242 : : static void
243 : 382 : does_not_exist_skipping(ObjectType objtype, Node *object)
244 : : {
245 : 382 : const char *msg = NULL;
246 : 382 : char *name = NULL;
247 : 382 : char *args = NULL;
248 : :
249 [ + + + + : 382 : switch (objtype)
+ - + + +
+ + + - -
+ + + + +
+ - + + +
+ + + - -
- - ]
250 : : {
251 : 4 : case OBJECT_ACCESS_METHOD:
252 : 4 : msg = gettext_noop("access method \"%s\" does not exist, skipping");
253 : 4 : name = strVal(object);
254 : 4 : break;
255 : 38 : case OBJECT_TYPE:
256 : : case OBJECT_DOMAIN:
257 : : {
258 : 38 : TypeName *typ = castNode(TypeName, object);
259 : :
260 [ + + ]: 38 : if (!schema_does_not_exist_skipping(typ->names, &msg, &name))
261 : : {
262 : 30 : msg = gettext_noop("type \"%s\" does not exist, skipping");
263 : 30 : name = TypeNameToString(typ);
264 : : }
265 : : }
266 : 38 : break;
267 : 12 : case OBJECT_COLLATION:
268 [ + + ]: 12 : if (!schema_does_not_exist_skipping(castNode(List, object), &msg, &name))
269 : : {
270 : 8 : msg = gettext_noop("collation \"%s\" does not exist, skipping");
271 : 8 : name = NameListToString(castNode(List, object));
272 : : }
273 : 12 : break;
274 : 8 : case OBJECT_CONVERSION:
275 [ + + ]: 8 : if (!schema_does_not_exist_skipping(castNode(List, object), &msg, &name))
276 : : {
277 : 4 : msg = gettext_noop("conversion \"%s\" does not exist, skipping");
278 : 4 : name = NameListToString(castNode(List, object));
279 : : }
280 : 8 : break;
281 : 14 : case OBJECT_SCHEMA:
282 : 14 : msg = gettext_noop("schema \"%s\" does not exist, skipping");
283 : 14 : name = strVal(object);
284 : 14 : break;
285 : 0 : case OBJECT_STATISTIC_EXT:
286 [ # # ]: 0 : if (!schema_does_not_exist_skipping(castNode(List, object), &msg, &name))
287 : : {
288 : 0 : msg = gettext_noop("statistics object \"%s\" does not exist, skipping");
289 : 0 : name = NameListToString(castNode(List, object));
290 : : }
291 : 0 : break;
292 : 8 : case OBJECT_TSPARSER:
293 [ + + ]: 8 : if (!schema_does_not_exist_skipping(castNode(List, object), &msg, &name))
294 : : {
295 : 4 : msg = gettext_noop("text search parser \"%s\" does not exist, skipping");
296 : 4 : name = NameListToString(castNode(List, object));
297 : : }
298 : 8 : break;
299 : 8 : case OBJECT_TSDICTIONARY:
300 [ + + ]: 8 : if (!schema_does_not_exist_skipping(castNode(List, object), &msg, &name))
301 : : {
302 : 4 : msg = gettext_noop("text search dictionary \"%s\" does not exist, skipping");
303 : 4 : name = NameListToString(castNode(List, object));
304 : : }
305 : 8 : break;
306 : 8 : case OBJECT_TSTEMPLATE:
307 [ + + ]: 8 : if (!schema_does_not_exist_skipping(castNode(List, object), &msg, &name))
308 : : {
309 : 4 : msg = gettext_noop("text search template \"%s\" does not exist, skipping");
310 : 4 : name = NameListToString(castNode(List, object));
311 : : }
312 : 8 : break;
313 : 8 : case OBJECT_TSCONFIGURATION:
314 [ + + ]: 8 : if (!schema_does_not_exist_skipping(castNode(List, object), &msg, &name))
315 : : {
316 : 4 : msg = gettext_noop("text search configuration \"%s\" does not exist, skipping");
317 : 4 : name = NameListToString(castNode(List, object));
318 : : }
319 : 8 : break;
320 : 12 : case OBJECT_EXTENSION:
321 : 12 : msg = gettext_noop("extension \"%s\" does not exist, skipping");
322 : 12 : name = strVal(object);
323 : 12 : break;
324 : 110 : case OBJECT_FUNCTION:
325 : : {
326 : 110 : ObjectWithArgs *owa = castNode(ObjectWithArgs, object);
327 : :
328 [ + + ]: 110 : if (!schema_does_not_exist_skipping(owa->objname, &msg, &name) &&
329 [ + + ]: 104 : !type_in_list_does_not_exist_skipping(owa->objargs, &msg, &name))
330 : : {
331 : 95 : msg = gettext_noop("function %s(%s) does not exist, skipping");
332 : 95 : name = NameListToString(owa->objname);
333 : 95 : args = TypeNameListToString(owa->objargs);
334 : : }
335 : 110 : break;
336 : : }
337 : 0 : case OBJECT_PROCEDURE:
338 : : {
339 : 0 : ObjectWithArgs *owa = castNode(ObjectWithArgs, object);
340 : :
341 [ # # ]: 0 : if (!schema_does_not_exist_skipping(owa->objname, &msg, &name) &&
342 [ # # ]: 0 : !type_in_list_does_not_exist_skipping(owa->objargs, &msg, &name))
343 : : {
344 : 0 : msg = gettext_noop("procedure %s(%s) does not exist, skipping");
345 : 0 : name = NameListToString(owa->objname);
346 : 0 : args = TypeNameListToString(owa->objargs);
347 : : }
348 : 0 : break;
349 : : }
350 : 0 : case OBJECT_ROUTINE:
351 : : {
352 : 0 : ObjectWithArgs *owa = castNode(ObjectWithArgs, object);
353 : :
354 [ # # ]: 0 : if (!schema_does_not_exist_skipping(owa->objname, &msg, &name) &&
355 [ # # ]: 0 : !type_in_list_does_not_exist_skipping(owa->objargs, &msg, &name))
356 : : {
357 : 0 : msg = gettext_noop("routine %s(%s) does not exist, skipping");
358 : 0 : name = NameListToString(owa->objname);
359 : 0 : args = TypeNameListToString(owa->objargs);
360 : : }
361 : 0 : break;
362 : : }
363 : 20 : case OBJECT_AGGREGATE:
364 : : {
365 : 20 : ObjectWithArgs *owa = castNode(ObjectWithArgs, object);
366 : :
367 [ + + ]: 20 : if (!schema_does_not_exist_skipping(owa->objname, &msg, &name) &&
368 [ + + ]: 16 : !type_in_list_does_not_exist_skipping(owa->objargs, &msg, &name))
369 : : {
370 : 8 : msg = gettext_noop("aggregate %s(%s) does not exist, skipping");
371 : 8 : name = NameListToString(owa->objname);
372 : 8 : args = TypeNameListToString(owa->objargs);
373 : : }
374 : 20 : break;
375 : : }
376 : 20 : case OBJECT_OPERATOR:
377 : : {
378 : 20 : ObjectWithArgs *owa = castNode(ObjectWithArgs, object);
379 : :
380 [ + + ]: 20 : if (!schema_does_not_exist_skipping(owa->objname, &msg, &name) &&
381 [ + + ]: 16 : !type_in_list_does_not_exist_skipping(owa->objargs, &msg, &name))
382 : : {
383 : 4 : msg = gettext_noop("operator %s does not exist, skipping");
384 : 4 : name = NameListToString(owa->objname);
385 : : }
386 : 20 : break;
387 : : }
388 : 4 : case OBJECT_LANGUAGE:
389 : 4 : msg = gettext_noop("language \"%s\" does not exist, skipping");
390 : 4 : name = strVal(object);
391 : 4 : break;
392 : 20 : case OBJECT_CAST:
393 : : {
394 [ + + ]: 20 : if (!type_in_list_does_not_exist_skipping(list_make1(linitial(castNode(List, object))), &msg, &name) &&
395 [ + + ]: 12 : !type_in_list_does_not_exist_skipping(list_make1(lsecond(castNode(List, object))), &msg, &name))
396 : : {
397 : : /* XXX quote or no quote? */
398 : 4 : msg = gettext_noop("cast from type %s to type %s does not exist, skipping");
399 : 4 : name = TypeNameToString(linitial_node(TypeName, castNode(List, object)));
400 : 4 : args = TypeNameToString(lsecond_node(TypeName, castNode(List, object)));
401 : : }
402 : : }
403 : 20 : break;
404 : 3 : case OBJECT_TRANSFORM:
405 [ + + ]: 3 : if (!type_in_list_does_not_exist_skipping(list_make1(linitial(castNode(List, object))), &msg, &name))
406 : : {
407 : 2 : msg = gettext_noop("transform for type %s language \"%s\" does not exist, skipping");
408 : 2 : name = TypeNameToString(linitial_node(TypeName, castNode(List, object)));
409 : 2 : args = strVal(lsecond(castNode(List, object)));
410 : : }
411 : 3 : break;
412 : 16 : case OBJECT_TRIGGER:
413 [ + + ]: 16 : if (!owningrel_does_not_exist_skipping(castNode(List, object), &msg, &name))
414 : : {
415 : 4 : msg = gettext_noop("trigger \"%s\" for relation \"%s\" does not exist, skipping");
416 : 4 : name = strVal(llast(castNode(List, object)));
417 : 4 : args = NameListToString(list_copy_head(castNode(List, object),
418 : 4 : list_length(castNode(List, object)) - 1));
419 : : }
420 : 16 : break;
421 : 0 : case OBJECT_POLICY:
422 [ # # ]: 0 : if (!owningrel_does_not_exist_skipping(castNode(List, object), &msg, &name))
423 : : {
424 : 0 : msg = gettext_noop("policy \"%s\" for relation \"%s\" does not exist, skipping");
425 : 0 : name = strVal(llast(castNode(List, object)));
426 : 0 : args = NameListToString(list_copy_head(castNode(List, object),
427 : 0 : list_length(castNode(List, object)) - 1));
428 : : }
429 : 0 : break;
430 : 4 : case OBJECT_EVENT_TRIGGER:
431 : 4 : msg = gettext_noop("event trigger \"%s\" does not exist, skipping");
432 : 4 : name = strVal(object);
433 : 4 : break;
434 : 16 : case OBJECT_RULE:
435 [ + + ]: 16 : if (!owningrel_does_not_exist_skipping(castNode(List, object), &msg, &name))
436 : : {
437 : 4 : msg = gettext_noop("rule \"%s\" for relation \"%s\" does not exist, skipping");
438 : 4 : name = strVal(llast(castNode(List, object)));
439 : 4 : args = NameListToString(list_copy_head(castNode(List, object),
440 : 4 : list_length(castNode(List, object)) - 1));
441 : : }
442 : 16 : break;
443 : 9 : case OBJECT_FDW:
444 : 9 : msg = gettext_noop("foreign-data wrapper \"%s\" does not exist, skipping");
445 : 9 : name = strVal(object);
446 : 9 : break;
447 : 24 : case OBJECT_FOREIGN_SERVER:
448 : 24 : msg = gettext_noop("server \"%s\" does not exist, skipping");
449 : 24 : name = strVal(object);
450 : 24 : break;
451 : 8 : case OBJECT_OPCLASS:
452 : : {
453 : 8 : List *opcname = list_copy_tail(castNode(List, object), 1);
454 : :
455 [ + + ]: 8 : if (!schema_does_not_exist_skipping(opcname, &msg, &name))
456 : : {
457 : 4 : msg = gettext_noop("operator class \"%s\" does not exist for access method \"%s\", skipping");
458 : 4 : name = NameListToString(opcname);
459 : 4 : args = strVal(linitial(castNode(List, object)));
460 : : }
461 : : }
462 : 8 : break;
463 : 8 : case OBJECT_OPFAMILY:
464 : : {
465 : 8 : List *opfname = list_copy_tail(castNode(List, object), 1);
466 : :
467 [ + + ]: 8 : if (!schema_does_not_exist_skipping(opfname, &msg, &name))
468 : : {
469 : 4 : msg = gettext_noop("operator family \"%s\" does not exist for access method \"%s\", skipping");
470 : 4 : name = NameListToString(opfname);
471 : 4 : args = strVal(linitial(castNode(List, object)));
472 : : }
473 : : }
474 : 8 : break;
475 : 0 : case OBJECT_PUBLICATION:
476 : 0 : msg = gettext_noop("publication \"%s\" does not exist, skipping");
477 : 0 : name = strVal(object);
478 : 0 : break;
479 : :
480 : 0 : case OBJECT_COLUMN:
481 : : case OBJECT_DATABASE:
482 : : case OBJECT_FOREIGN_TABLE:
483 : : case OBJECT_INDEX:
484 : : case OBJECT_MATVIEW:
485 : : case OBJECT_PROPGRAPH:
486 : : case OBJECT_ROLE:
487 : : case OBJECT_SEQUENCE:
488 : : case OBJECT_SUBSCRIPTION:
489 : : case OBJECT_TABLE:
490 : : case OBJECT_TABLESPACE:
491 : : case OBJECT_VIEW:
492 : :
493 : : /*
494 : : * These are handled elsewhere, so if someone gets here the code
495 : : * is probably wrong or should be revisited.
496 : : */
497 [ # # ]: 0 : elog(ERROR, "unsupported object type: %d", (int) objtype);
498 : : break;
499 : :
500 : 0 : case OBJECT_AMOP:
501 : : case OBJECT_AMPROC:
502 : : case OBJECT_ATTRIBUTE:
503 : : case OBJECT_DEFAULT:
504 : : case OBJECT_DEFACL:
505 : : case OBJECT_DOMCONSTRAINT:
506 : : case OBJECT_LARGEOBJECT:
507 : : case OBJECT_PARAMETER_ACL:
508 : : case OBJECT_PUBLICATION_NAMESPACE:
509 : : case OBJECT_PUBLICATION_REL:
510 : : case OBJECT_TABCONSTRAINT:
511 : : case OBJECT_USER_MAPPING:
512 : : /* These are currently not used or needed. */
513 [ # # ]: 0 : elog(ERROR, "unsupported object type: %d", (int) objtype);
514 : : break;
515 : :
516 : : /* no default, to let compiler warn about missing case */
517 : : }
518 [ - + ]: 382 : if (!msg)
519 [ # # ]: 0 : elog(ERROR, "unrecognized object type: %d", (int) objtype);
520 : :
521 [ + + ]: 382 : if (!args)
522 [ + + ]: 257 : ereport(NOTICE, (errmsg(msg, name)));
523 : : else
524 [ + - ]: 125 : ereport(NOTICE, (errmsg(msg, name, args)));
525 : 382 : }
|
