← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/postgresql-9.1/oneiric-security

« back to all changes in this revision

Viewing changes to src/backend/commands/alter.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2011-05-11 10:41:53 UTC
  • Revision ID: james.westby@ubuntu.com-20110511104153-psbh2o58553fv1m0
Tags: upstream-9.1~beta1
Import upstream version 9.1~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/backend/commands/alter.c
 
1
/*-------------------------------------------------------------------------
 
2
 *
 
3
 * alter.c
 
4
 *        Drivers for generic alter commands
 
5
 *
 
6
 * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
 
7
 * Portions Copyright (c) 1994, Regents of the University of California
 
8
 *
 
9
 *
 
10
 * IDENTIFICATION
 
11
 *        src/backend/commands/alter.c
 
12
 *
 
13
 *-------------------------------------------------------------------------
 
14
 */
 
15
#include "postgres.h"
 
16
 
 
17
#include "catalog/dependency.h"
 
18
#include "catalog/indexing.h"
 
19
#include "catalog/namespace.h"
 
20
#include "catalog/pg_largeobject.h"
 
21
#include "catalog/pg_namespace.h"
 
22
#include "commands/alter.h"
 
23
#include "commands/collationcmds.h"
 
24
#include "commands/conversioncmds.h"
 
25
#include "commands/dbcommands.h"
 
26
#include "commands/defrem.h"
 
27
#include "commands/extension.h"
 
28
#include "commands/proclang.h"
 
29
#include "commands/schemacmds.h"
 
30
#include "commands/tablecmds.h"
 
31
#include "commands/tablespace.h"
 
32
#include "commands/trigger.h"
 
33
#include "commands/typecmds.h"
 
34
#include "commands/user.h"
 
35
#include "miscadmin.h"
 
36
#include "parser/parse_clause.h"
 
37
#include "tcop/utility.h"
 
38
#include "utils/acl.h"
 
39
#include "utils/builtins.h"
 
40
#include "utils/lsyscache.h"
 
41
#include "utils/syscache.h"
 
42
 
 
43
 
 
44
/*
 
45
 * Executes an ALTER OBJECT / RENAME TO statement.      Based on the object
 
46
 * type, the function appropriate to that type is executed.
 
47
 */
 
48
void
 
49
ExecRenameStmt(RenameStmt *stmt)
 
50
{
 
51
        switch (stmt->renameType)
 
52
        {
 
53
                case OBJECT_AGGREGATE:
 
54
                        RenameAggregate(stmt->object, stmt->objarg, stmt->newname);
 
55
                        break;
 
56
 
 
57
                case OBJECT_COLLATION:
 
58
                        RenameCollation(stmt->object, stmt->newname);
 
59
                        break;
 
60
 
 
61
                case OBJECT_CONVERSION:
 
62
                        RenameConversion(stmt->object, stmt->newname);
 
63
                        break;
 
64
 
 
65
                case OBJECT_DATABASE:
 
66
                        RenameDatabase(stmt->subname, stmt->newname);
 
67
                        break;
 
68
 
 
69
                case OBJECT_FUNCTION:
 
70
                        RenameFunction(stmt->object, stmt->objarg, stmt->newname);
 
71
                        break;
 
72
 
 
73
                case OBJECT_LANGUAGE:
 
74
                        RenameLanguage(stmt->subname, stmt->newname);
 
75
                        break;
 
76
 
 
77
                case OBJECT_OPCLASS:
 
78
                        RenameOpClass(stmt->object, stmt->subname, stmt->newname);
 
79
                        break;
 
80
 
 
81
                case OBJECT_OPFAMILY:
 
82
                        RenameOpFamily(stmt->object, stmt->subname, stmt->newname);
 
83
                        break;
 
84
 
 
85
                case OBJECT_ROLE:
 
86
                        RenameRole(stmt->subname, stmt->newname);
 
87
                        break;
 
88
 
 
89
                case OBJECT_SCHEMA:
 
90
                        RenameSchema(stmt->subname, stmt->newname);
 
91
                        break;
 
92
 
 
93
                case OBJECT_TABLESPACE:
 
94
                        RenameTableSpace(stmt->subname, stmt->newname);
 
95
                        break;
 
96
 
 
97
                case OBJECT_TABLE:
 
98
                case OBJECT_SEQUENCE:
 
99
                case OBJECT_VIEW:
 
100
                case OBJECT_INDEX:
 
101
                case OBJECT_COLUMN:
 
102
                case OBJECT_ATTRIBUTE:
 
103
                case OBJECT_TRIGGER:
 
104
                case OBJECT_FOREIGN_TABLE:
 
105
                        {
 
106
                                Oid                     relid;
 
107
 
 
108
                                CheckRelationOwnership(stmt->relation, true);
 
109
 
 
110
                                relid = RangeVarGetRelid(stmt->relation, false);
 
111
 
 
112
                                switch (stmt->renameType)
 
113
                                {
 
114
                                        case OBJECT_TABLE:
 
115
                                        case OBJECT_SEQUENCE:
 
116
                                        case OBJECT_VIEW:
 
117
                                        case OBJECT_INDEX:
 
118
                                        case OBJECT_FOREIGN_TABLE:
 
119
                                                {
 
120
                                                        /*
 
121
                                                         * RENAME TABLE requires that we (still) hold
 
122
                                                         * CREATE rights on the containing namespace, as
 
123
                                                         * well as ownership of the table.
 
124
                                                         */
 
125
                                                        Oid                     namespaceId = get_rel_namespace(relid);
 
126
                                                        AclResult       aclresult;
 
127
 
 
128
                                                        aclresult = pg_namespace_aclcheck(namespaceId,
 
129
                                                                                                                          GetUserId(),
 
130
                                                                                                                          ACL_CREATE);
 
131
                                                        if (aclresult != ACLCHECK_OK)
 
132
                                                                aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
 
133
                                                                                        get_namespace_name(namespaceId));
 
134
 
 
135
                                                        RenameRelation(relid, stmt->newname, stmt->renameType);
 
136
                                                        break;
 
137
                                                }
 
138
                                        case OBJECT_COLUMN:
 
139
                                        case OBJECT_ATTRIBUTE:
 
140
                                                renameatt(relid, stmt);
 
141
                                                break;
 
142
                                        case OBJECT_TRIGGER:
 
143
                                                renametrig(relid,
 
144
                                                                   stmt->subname,               /* old att name */
 
145
                                                                   stmt->newname);              /* new att name */
 
146
                                                break;
 
147
                                        default:
 
148
                                                 /* can't happen */ ;
 
149
                                }
 
150
                                break;
 
151
                        }
 
152
 
 
153
                case OBJECT_TSPARSER:
 
154
                        RenameTSParser(stmt->object, stmt->newname);
 
155
                        break;
 
156
 
 
157
                case OBJECT_TSDICTIONARY:
 
158
                        RenameTSDictionary(stmt->object, stmt->newname);
 
159
                        break;
 
160
 
 
161
                case OBJECT_TSTEMPLATE:
 
162
                        RenameTSTemplate(stmt->object, stmt->newname);
 
163
                        break;
 
164
 
 
165
                case OBJECT_TSCONFIGURATION:
 
166
                        RenameTSConfiguration(stmt->object, stmt->newname);
 
167
                        break;
 
168
 
 
169
                case OBJECT_TYPE:
 
170
                        RenameType(stmt->object, stmt->newname);
 
171
                        break;
 
172
 
 
173
                default:
 
174
                        elog(ERROR, "unrecognized rename stmt type: %d",
 
175
                                 (int) stmt->renameType);
 
176
        }
 
177
}
 
178
 
 
179
/*
 
180
 * Executes an ALTER OBJECT / SET SCHEMA statement.  Based on the object
 
181
 * type, the function appropriate to that type is executed.
 
182
 */
 
183
void
 
184
ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt)
 
185
{
 
186
        switch (stmt->objectType)
 
187
        {
 
188
                case OBJECT_AGGREGATE:
 
189
                        AlterFunctionNamespace(stmt->object, stmt->objarg, true,
 
190
                                                                   stmt->newschema);
 
191
                        break;
 
192
 
 
193
                case OBJECT_COLLATION:
 
194
                        AlterCollationNamespace(stmt->object, stmt->newschema);
 
195
                        break;
 
196
 
 
197
                case OBJECT_CONVERSION:
 
198
                        AlterConversionNamespace(stmt->object, stmt->newschema);
 
199
                        break;
 
200
 
 
201
                case OBJECT_EXTENSION:
 
202
                        AlterExtensionNamespace(stmt->object, stmt->newschema);
 
203
                        break;
 
204
 
 
205
                case OBJECT_FUNCTION:
 
206
                        AlterFunctionNamespace(stmt->object, stmt->objarg, false,
 
207
                                                                   stmt->newschema);
 
208
                        break;
 
209
 
 
210
                case OBJECT_OPERATOR:
 
211
                        AlterOperatorNamespace(stmt->object, stmt->objarg, stmt->newschema);
 
212
                        break;
 
213
 
 
214
                case OBJECT_OPCLASS:
 
215
                        AlterOpClassNamespace(stmt->object, stmt->addname, stmt->newschema);
 
216
                        break;
 
217
 
 
218
                case OBJECT_OPFAMILY:
 
219
                        AlterOpFamilyNamespace(stmt->object, stmt->addname, stmt->newschema);
 
220
                        break;
 
221
 
 
222
                case OBJECT_SEQUENCE:
 
223
                case OBJECT_TABLE:
 
224
                case OBJECT_VIEW:
 
225
                case OBJECT_FOREIGN_TABLE:
 
226
                        CheckRelationOwnership(stmt->relation, true);
 
227
                        AlterTableNamespace(stmt->relation, stmt->newschema,
 
228
                                                                stmt->objectType, AccessExclusiveLock);
 
229
                        break;
 
230
 
 
231
                case OBJECT_TSPARSER:
 
232
                        AlterTSParserNamespace(stmt->object, stmt->newschema);
 
233
                        break;
 
234
 
 
235
                case OBJECT_TSDICTIONARY:
 
236
                        AlterTSDictionaryNamespace(stmt->object, stmt->newschema);
 
237
                        break;
 
238
 
 
239
                case OBJECT_TSTEMPLATE:
 
240
                        AlterTSTemplateNamespace(stmt->object, stmt->newschema);
 
241
                        break;
 
242
 
 
243
                case OBJECT_TSCONFIGURATION:
 
244
                        AlterTSConfigurationNamespace(stmt->object, stmt->newschema);
 
245
                        break;
 
246
 
 
247
                case OBJECT_TYPE:
 
248
                case OBJECT_DOMAIN:
 
249
                        AlterTypeNamespace(stmt->object, stmt->newschema);
 
250
                        break;
 
251
 
 
252
                default:
 
253
                        elog(ERROR, "unrecognized AlterObjectSchemaStmt type: %d",
 
254
                                 (int) stmt->objectType);
 
255
        }
 
256
}
 
257
 
 
258
/*
 
259
 * Change an object's namespace given its classOid and object Oid.
 
260
 *
 
261
 * Objects that don't have a namespace should be ignored.
 
262
 *
 
263
 * This function is currently used only by ALTER EXTENSION SET SCHEMA,
 
264
 * so it only needs to cover object types that can be members of an
 
265
 * extension, and it doesn't have to deal with certain special cases
 
266
 * such as not wanting to process array types --- those should never
 
267
 * be direct members of an extension anyway.
 
268
 *
 
269
 * Returns the OID of the object's previous namespace, or InvalidOid if
 
270
 * object doesn't have a schema.
 
271
 */
 
272
Oid
 
273
AlterObjectNamespace_oid(Oid classId, Oid objid, Oid nspOid)
 
274
{
 
275
        Oid                     oldNspOid = InvalidOid;
 
276
        ObjectAddress dep;
 
277
 
 
278
        dep.classId = classId;
 
279
        dep.objectId = objid;
 
280
        dep.objectSubId = 0;
 
281
 
 
282
        switch (getObjectClass(&dep))
 
283
        {
 
284
                case OCLASS_CLASS:
 
285
                        {
 
286
                                Relation        rel;
 
287
                                Relation        classRel;
 
288
 
 
289
                                rel = relation_open(objid, AccessExclusiveLock);
 
290
                                oldNspOid = RelationGetNamespace(rel);
 
291
 
 
292
                                classRel = heap_open(RelationRelationId, RowExclusiveLock);
 
293
 
 
294
                                AlterRelationNamespaceInternal(classRel,
 
295
                                                                                           objid,
 
296
                                                                                           oldNspOid,
 
297
                                                                                           nspOid,
 
298
                                                                                           true);
 
299
 
 
300
                                heap_close(classRel, RowExclusiveLock);
 
301
 
 
302
                                relation_close(rel, NoLock);
 
303
                                break;
 
304
                        }
 
305
 
 
306
                case OCLASS_PROC:
 
307
                        oldNspOid = AlterFunctionNamespace_oid(objid, nspOid);
 
308
                        break;
 
309
 
 
310
                case OCLASS_TYPE:
 
311
                        oldNspOid = AlterTypeNamespace_oid(objid, nspOid);
 
312
                        break;
 
313
 
 
314
                case OCLASS_COLLATION:
 
315
                        oldNspOid = AlterCollationNamespace_oid(objid, nspOid);
 
316
                        break;
 
317
 
 
318
                case OCLASS_CONVERSION:
 
319
                        oldNspOid = AlterConversionNamespace_oid(objid, nspOid);
 
320
                        break;
 
321
 
 
322
                case OCLASS_OPERATOR:
 
323
                        oldNspOid = AlterOperatorNamespace_oid(objid, nspOid);
 
324
                        break;
 
325
 
 
326
                case OCLASS_OPCLASS:
 
327
                        oldNspOid = AlterOpClassNamespace_oid(objid, nspOid);
 
328
                        break;
 
329
 
 
330
                case OCLASS_OPFAMILY:
 
331
                        oldNspOid = AlterOpFamilyNamespace_oid(objid, nspOid);
 
332
                        break;
 
333
 
 
334
                case OCLASS_TSPARSER:
 
335
                        oldNspOid = AlterTSParserNamespace_oid(objid, nspOid);
 
336
                        break;
 
337
 
 
338
                case OCLASS_TSDICT:
 
339
                        oldNspOid = AlterTSDictionaryNamespace_oid(objid, nspOid);
 
340
                        break;
 
341
 
 
342
                case OCLASS_TSTEMPLATE:
 
343
                        oldNspOid = AlterTSTemplateNamespace_oid(objid, nspOid);
 
344
                        break;
 
345
 
 
346
                case OCLASS_TSCONFIG:
 
347
                        oldNspOid = AlterTSConfigurationNamespace_oid(objid, nspOid);
 
348
                        break;
 
349
 
 
350
                default:
 
351
                        break;
 
352
        }
 
353
 
 
354
        return oldNspOid;
 
355
}
 
356
 
 
357
/*
 
358
 * Generic function to change the namespace of a given object, for simple
 
359
 * cases (won't work for tables, nor other cases where we need to do more
 
360
 * than change the namespace column of a single catalog entry).
 
361
 *
 
362
 * The AlterFooNamespace() calls just above will call a function whose job
 
363
 * is to lookup the arguments for the generic function here.
 
364
 *
 
365
 * rel: catalog relation containing object (RowExclusiveLock'd by caller)
 
366
 * oidCacheId: syscache that indexes this catalog by OID
 
367
 * nameCacheId: syscache that indexes this catalog by name and namespace
 
368
 *              (pass -1 if there is none)
 
369
 * objid: OID of object to change the namespace of
 
370
 * nspOid: OID of new namespace
 
371
 * Anum_name: column number of catalog's name column
 
372
 * Anum_namespace: column number of catalog's namespace column
 
373
 * Anum_owner: column number of catalog's owner column, or -1 if none
 
374
 * acl_kind: ACL type for object, or -1 if none assigned
 
375
 *
 
376
 * If the object does not have an owner or permissions, pass -1 for
 
377
 * Anum_owner and acl_kind.  In this case the calling user must be superuser.
 
378
 *
 
379
 * Returns the OID of the object's previous namespace.
 
380
 */
 
381
Oid
 
382
AlterObjectNamespace(Relation rel, int oidCacheId, int nameCacheId,
 
383
                                         Oid objid, Oid nspOid,
 
384
                                         int Anum_name, int Anum_namespace, int Anum_owner,
 
385
                                         AclObjectKind acl_kind)
 
386
{
 
387
        Oid                     classId = RelationGetRelid(rel);
 
388
        Oid                     oldNspOid;
 
389
        Datum           name,
 
390
                                namespace;
 
391
        bool            isnull;
 
392
        HeapTuple       tup,
 
393
                                newtup;
 
394
        Datum      *values;
 
395
        bool       *nulls;
 
396
        bool       *replaces;
 
397
 
 
398
        tup = SearchSysCacheCopy1(oidCacheId, ObjectIdGetDatum(objid));
 
399
        if (!HeapTupleIsValid(tup)) /* should not happen */
 
400
                elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
 
401
                         objid, RelationGetRelationName(rel));
 
402
 
 
403
        name = heap_getattr(tup, Anum_name, RelationGetDescr(rel), &isnull);
 
404
        Assert(!isnull);
 
405
        namespace = heap_getattr(tup, Anum_namespace, RelationGetDescr(rel), &isnull);
 
406
        Assert(!isnull);
 
407
        oldNspOid = DatumGetObjectId(namespace);
 
408
 
 
409
        /* Check basic namespace related issues */
 
410
        CheckSetNamespace(oldNspOid, nspOid, classId, objid);
 
411
 
 
412
        /* Permission checks ... superusers can always do it */
 
413
        if (!superuser())
 
414
        {
 
415
                Datum           owner;
 
416
                Oid                     ownerId;
 
417
                AclResult       aclresult;
 
418
 
 
419
                /* Fail if object does not have an explicit owner */
 
420
                if (Anum_owner <= 0)
 
421
                        ereport(ERROR,
 
422
                                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 
423
                                         (errmsg("must be superuser to SET SCHEMA of %s",
 
424
                                                         getObjectDescriptionOids(classId, objid)))));
 
425
 
 
426
                /* Otherwise, must be owner of the existing object */
 
427
                owner = heap_getattr(tup, Anum_owner, RelationGetDescr(rel), &isnull);
 
428
                Assert(!isnull);
 
429
                ownerId = DatumGetObjectId(owner);
 
430
 
 
431
                if (!has_privs_of_role(GetUserId(), ownerId))
 
432
                        aclcheck_error(ACLCHECK_NOT_OWNER, acl_kind,
 
433
                                                   NameStr(*(DatumGetName(name))));
 
434
 
 
435
                /* User must have CREATE privilege on new namespace */
 
436
                aclresult = pg_namespace_aclcheck(nspOid, GetUserId(), ACL_CREATE);
 
437
                if (aclresult != ACLCHECK_OK)
 
438
                        aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
 
439
                                                   get_namespace_name(nspOid));
 
440
        }
 
441
 
 
442
        /*
 
443
         * Check for duplicate name (more friendly than unique-index failure).
 
444
         * Since this is just a friendliness check, we can just skip it in cases
 
445
         * where there isn't a suitable syscache available.
 
446
         */
 
447
        if (nameCacheId >= 0 &&
 
448
                SearchSysCacheExists2(nameCacheId, name, ObjectIdGetDatum(nspOid)))
 
449
                ereport(ERROR,
 
450
                                (errcode(ERRCODE_DUPLICATE_OBJECT),
 
451
                                 errmsg("%s already exists in schema \"%s\"",
 
452
                                                getObjectDescriptionOids(classId, objid),
 
453
                                                get_namespace_name(nspOid))));
 
454
 
 
455
        /* Build modified tuple */
 
456
        values = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(Datum));
 
457
        nulls = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
 
458
        replaces = palloc0(RelationGetNumberOfAttributes(rel) * sizeof(bool));
 
459
        values[Anum_namespace - 1] = ObjectIdGetDatum(nspOid);
 
460
        replaces[Anum_namespace - 1] = true;
 
461
        newtup = heap_modify_tuple(tup, RelationGetDescr(rel),
 
462
                                                           values, nulls, replaces);
 
463
 
 
464
        /* Perform actual update */
 
465
        simple_heap_update(rel, &tup->t_self, newtup);
 
466
        CatalogUpdateIndexes(rel, newtup);
 
467
 
 
468
        /* Release memory */
 
469
        pfree(values);
 
470
        pfree(nulls);
 
471
        pfree(replaces);
 
472
 
 
473
        /* update dependencies to point to the new schema */
 
474
        changeDependencyFor(classId, objid,
 
475
                                                NamespaceRelationId, oldNspOid, nspOid);
 
476
 
 
477
        return oldNspOid;
 
478
}
 
479
 
 
480
 
 
481
/*
 
482
 * Executes an ALTER OBJECT / OWNER TO statement.  Based on the object
 
483
 * type, the function appropriate to that type is executed.
 
484
 */
 
485
void
 
486
ExecAlterOwnerStmt(AlterOwnerStmt *stmt)
 
487
{
 
488
        Oid                     newowner = get_role_oid(stmt->newowner, false);
 
489
 
 
490
        switch (stmt->objectType)
 
491
        {
 
492
                case OBJECT_AGGREGATE:
 
493
                        AlterAggregateOwner(stmt->object, stmt->objarg, newowner);
 
494
                        break;
 
495
 
 
496
                case OBJECT_COLLATION:
 
497
                        AlterCollationOwner(stmt->object, newowner);
 
498
                        break;
 
499
 
 
500
                case OBJECT_CONVERSION:
 
501
                        AlterConversionOwner(stmt->object, newowner);
 
502
                        break;
 
503
 
 
504
                case OBJECT_DATABASE:
 
505
                        AlterDatabaseOwner(strVal(linitial(stmt->object)), newowner);
 
506
                        break;
 
507
 
 
508
                case OBJECT_FUNCTION:
 
509
                        AlterFunctionOwner(stmt->object, stmt->objarg, newowner);
 
510
                        break;
 
511
 
 
512
                case OBJECT_LANGUAGE:
 
513
                        AlterLanguageOwner(strVal(linitial(stmt->object)), newowner);
 
514
                        break;
 
515
 
 
516
                case OBJECT_LARGEOBJECT:
 
517
                        LargeObjectAlterOwner(oidparse(linitial(stmt->object)), newowner);
 
518
                        break;
 
519
 
 
520
                case OBJECT_OPERATOR:
 
521
                        Assert(list_length(stmt->objarg) == 2);
 
522
                        AlterOperatorOwner(stmt->object,
 
523
                                                           (TypeName *) linitial(stmt->objarg),
 
524
                                                           (TypeName *) lsecond(stmt->objarg),
 
525
                                                           newowner);
 
526
                        break;
 
527
 
 
528
                case OBJECT_OPCLASS:
 
529
                        AlterOpClassOwner(stmt->object, stmt->addname, newowner);
 
530
                        break;
 
531
 
 
532
                case OBJECT_OPFAMILY:
 
533
                        AlterOpFamilyOwner(stmt->object, stmt->addname, newowner);
 
534
                        break;
 
535
 
 
536
                case OBJECT_SCHEMA:
 
537
                        AlterSchemaOwner(strVal(linitial(stmt->object)), newowner);
 
538
                        break;
 
539
 
 
540
                case OBJECT_TABLESPACE:
 
541
                        AlterTableSpaceOwner(strVal(linitial(stmt->object)), newowner);
 
542
                        break;
 
543
 
 
544
                case OBJECT_TYPE:
 
545
                case OBJECT_DOMAIN:             /* same as TYPE */
 
546
                        AlterTypeOwner(stmt->object, newowner);
 
547
                        break;
 
548
 
 
549
                case OBJECT_TSDICTIONARY:
 
550
                        AlterTSDictionaryOwner(stmt->object, newowner);
 
551
                        break;
 
552
 
 
553
                case OBJECT_TSCONFIGURATION:
 
554
                        AlterTSConfigurationOwner(stmt->object, newowner);
 
555
                        break;
 
556
 
 
557
                case OBJECT_FDW:
 
558
                        AlterForeignDataWrapperOwner(strVal(linitial(stmt->object)),
 
559
                                                                                 newowner);
 
560
                        break;
 
561
 
 
562
                case OBJECT_FOREIGN_SERVER:
 
563
                        AlterForeignServerOwner(strVal(linitial(stmt->object)), newowner);
 
564
                        break;
 
565
 
 
566
                default:
 
567
                        elog(ERROR, "unrecognized AlterOwnerStmt type: %d",
 
568
                                 (int) stmt->objectType);
 
569
        }
 
570
}