dbcommands.h File Reference

#include "catalog/objectaddress.h"
#include "parser/parse_node.h"

Include dependency graph for dbcommands.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
Oid	createdb (ParseState *pstate, const CreatedbStmt *stmt)
void	dropdb (const char *dbname, bool missing_ok, bool force)
void	DropDatabase (ParseState *pstate, DropdbStmt *stmt)
ObjectAddress	RenameDatabase (const char *oldname, const char *newname)
Oid	AlterDatabase (ParseState *pstate, AlterDatabaseStmt *stmt, bool isTopLevel)
ObjectAddress	AlterDatabaseRefreshColl (AlterDatabaseRefreshCollStmt *stmt)
Oid	AlterDatabaseSet (AlterDatabaseSetStmt *stmt)
ObjectAddress	AlterDatabaseOwner (const char *dbname, Oid newOwnerId)
bool	have_createdb_privilege (void)
void	check_encoding_locale_matches (int encoding, const char *collate, const char *ctype)

Function Documentation

AlterDatabase()

Oid AlterDatabase ( ParseState *  pstate, AlterDatabaseStmt *  stmt, bool  isTopLevel  )

extern

Definition at line 2369 of file dbcommands.c.

{
    Relation    rel;
    Oid         dboid;
    HeapTuple   tuple,
                newtuple;
    Form_pg_database datform;
    ScanKeyData scankey;
    SysScanDesc scan;
    ListCell   *option;
    bool        dbistemplate = false;
    bool        dballowconnections = true;
    int         dbconnlimit = DATCONNLIMIT_UNLIMITED;
    DefElem    *distemplate = NULL;
    DefElem    *dallowconnections = NULL;
    DefElem    *dconnlimit = NULL;
    DefElem    *dtablespace = NULL;
    Datum       new_record[Natts_pg_database] = {0};
    bool        new_record_nulls[Natts_pg_database] = {0};
    bool        new_record_repl[Natts_pg_database] = {0};
 
    /* Extract options from the statement node tree */
    foreach(option, stmt->options)
    {
        DefElem    *defel = (DefElem *) lfirst(option);
 
        if (strcmp(defel->defname, "is_template") == 0)
        {
            if (distemplate)
                errorConflictingDefElem(defel, pstate);
            distemplate = defel;
        }
        else if (strcmp(defel->defname, "allow_connections") == 0)
        {
            if (dallowconnections)
                errorConflictingDefElem(defel, pstate);
            dallowconnections = defel;
        }
        else if (strcmp(defel->defname, "connection_limit") == 0)
        {
            if (dconnlimit)
                errorConflictingDefElem(defel, pstate);
            dconnlimit = defel;
        }
        else if (strcmp(defel->defname, "tablespace") == 0)
        {
            if (dtablespace)
                errorConflictingDefElem(defel, pstate);
            dtablespace = defel;
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("option \"%s\" not recognized", defel->defname),
                     parser_errposition(pstate, defel->location)));
    }
 
    if (dtablespace)
    {
        /*
         * While the SET TABLESPACE syntax doesn't allow any other options,
         * somebody could write "WITH TABLESPACE ...".  Forbid any other
         * options from being specified in that case.
         */
        if (list_length(stmt->options) != 1)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("option \"%s\" cannot be specified with other options",
                            dtablespace->defname),
                     parser_errposition(pstate, dtablespace->location)));
        /* this case isn't allowed within a transaction block */
        PreventInTransactionBlock(isTopLevel, "ALTER DATABASE SET TABLESPACE");
        movedb(stmt->dbname, defGetString(dtablespace));
        return InvalidOid;
    }
 
    if (distemplate && distemplate->arg)
        dbistemplate = defGetBoolean(distemplate);
    if (dallowconnections && dallowconnections->arg)
        dballowconnections = defGetBoolean(dallowconnections);
    if (dconnlimit && dconnlimit->arg)
    {
        dbconnlimit = defGetInt32(dconnlimit);
        if (dbconnlimit < DATCONNLIMIT_UNLIMITED)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid connection limit: %d", dbconnlimit)));
    }
 
    /*
     * Get the old tuple.  We don't need a lock on the database per se,
     * because we're not going to do anything that would mess up incoming
     * connections.
     */
    rel = table_open(DatabaseRelationId, RowExclusiveLock);
    ScanKeyInit(&scankey,
                Anum_pg_database_datname,
                BTEqualStrategyNumber, F_NAMEEQ,
                CStringGetDatum(stmt->dbname));
    scan = systable_beginscan(rel, DatabaseNameIndexId, true,
                              NULL, 1, &scankey);
    tuple = systable_getnext(scan);
    if (!HeapTupleIsValid(tuple))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_DATABASE),
                 errmsg("database \"%s\" does not exist", stmt->dbname)));
    LockTuple(rel, &tuple->t_self, InplaceUpdateTupleLock);
 
    datform = (Form_pg_database) GETSTRUCT(tuple);
    dboid = datform->oid;
 
    if (database_is_invalid_form(datform))
    {
        ereport(FATAL,
                errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                errmsg("cannot alter invalid database \"%s\"", stmt->dbname),
                errhint("Use DROP DATABASE to drop invalid databases."));
    }
 
    if (!object_ownercheck(DatabaseRelationId, dboid, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_DATABASE,
                       stmt->dbname);
 
    /*
     * In order to avoid getting locked out and having to go through
     * standalone mode, we refuse to disallow connections to the database
     * we're currently connected to.  Lockout can still happen with concurrent
     * sessions but the likeliness of that is not high enough to worry about.
     */
    if (!dballowconnections && dboid == MyDatabaseId)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot disallow connections for current database")));
 
    /*
     * Build an updated tuple, perusing the information just obtained
     */
    if (distemplate)
    {
        new_record[Anum_pg_database_datistemplate - 1] = BoolGetDatum(dbistemplate);
        new_record_repl[Anum_pg_database_datistemplate - 1] = true;
    }
    if (dallowconnections)
    {
        new_record[Anum_pg_database_datallowconn - 1] = BoolGetDatum(dballowconnections);
        new_record_repl[Anum_pg_database_datallowconn - 1] = true;
    }
    if (dconnlimit)
    {
        new_record[Anum_pg_database_datconnlimit - 1] = Int32GetDatum(dbconnlimit);
        new_record_repl[Anum_pg_database_datconnlimit - 1] = true;
    }
 
    newtuple = heap_modify_tuple(tuple, RelationGetDescr(rel), new_record,
                                 new_record_nulls, new_record_repl);
    CatalogTupleUpdate(rel, &tuple->t_self, newtuple);
    UnlockTuple(rel, &tuple->t_self, InplaceUpdateTupleLock);
 
    InvokeObjectPostAlterHook(DatabaseRelationId, dboid, 0);
 
    systable_endscan(scan);
 
    /* Close pg_database, but keep lock till commit */
    table_close(rel, NoLock);
 
    return dboid;
}

References aclcheck_error(), ACLCHECK_NOT_OWNER, BoolGetDatum(), BTEqualStrategyNumber, CatalogTupleUpdate(), CStringGetDatum(), database_is_invalid_form(), DATCONNLIMIT_UNLIMITED, defGetBoolean(), defGetInt32(), defGetString(), ereport, errcode(), errhint(), errmsg(), ERROR, errorConflictingDefElem(), FATAL, fb(), GETSTRUCT(), GetUserId(), heap_modify_tuple(), HeapTupleIsValid, InplaceUpdateTupleLock, Int32GetDatum(), InvalidOid, InvokeObjectPostAlterHook, lfirst, list_length(), LockTuple(), movedb(), MyDatabaseId, NoLock, OBJECT_DATABASE, object_ownercheck(), parser_errposition(), PreventInTransactionBlock(), RelationGetDescr, RowExclusiveLock, ScanKeyInit(), stmt, systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), table_open(), and UnlockTuple().

Referenced by standard_ProcessUtility().

AlterDatabaseOwner()

ObjectAddress AlterDatabaseOwner ( const char *  dbname, Oid  newOwnerId  )

extern

Definition at line 2665 of file dbcommands.c.

{
    Oid         db_id;
    HeapTuple   tuple;
    Relation    rel;
    ScanKeyData scankey;
    SysScanDesc scan;
    Form_pg_database datForm;
    ObjectAddress address;
 
    /*
     * Get the old tuple.  We don't need a lock on the database per se,
     * because we're not going to do anything that would mess up incoming
     * connections.
     */
    rel = table_open(DatabaseRelationId, RowExclusiveLock);
    ScanKeyInit(&scankey,
                Anum_pg_database_datname,
                BTEqualStrategyNumber, F_NAMEEQ,
                CStringGetDatum(dbname));
    scan = systable_beginscan(rel, DatabaseNameIndexId, true,
                              NULL, 1, &scankey);
    tuple = systable_getnext(scan);
    if (!HeapTupleIsValid(tuple))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_DATABASE),
                 errmsg("database \"%s\" does not exist", dbname)));
 
    datForm = (Form_pg_database) GETSTRUCT(tuple);
    db_id = datForm->oid;
 
    /*
     * If the new owner is the same as the existing owner, consider the
     * command to have succeeded.  This is to be consistent with other
     * objects.
     */
    if (datForm->datdba != newOwnerId)
    {
        Datum       repl_val[Natts_pg_database];
        bool        repl_null[Natts_pg_database] = {0};
        bool        repl_repl[Natts_pg_database] = {0};
        Acl        *newAcl;
        Datum       aclDatum;
        bool        isNull;
        HeapTuple   newtuple;
 
        /* Otherwise, must be owner of the existing object */
        if (!object_ownercheck(DatabaseRelationId, db_id, GetUserId()))
            aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_DATABASE,
                           dbname);
 
        /* Must be able to become new owner */
        check_can_set_role(GetUserId(), newOwnerId);
 
        /*
         * must have createdb rights
         *
         * NOTE: This is different from other alter-owner checks in that the
         * current user is checked for createdb privileges instead of the
         * destination owner.  This is consistent with the CREATE case for
         * databases.  Because superusers will always have this right, we need
         * no special case for them.
         */
        if (!have_createdb_privilege())
            ereport(ERROR,
                    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                     errmsg("permission denied to change owner of database")));
 
        LockTuple(rel, &tuple->t_self, InplaceUpdateTupleLock);
 
        repl_repl[Anum_pg_database_datdba - 1] = true;
        repl_val[Anum_pg_database_datdba - 1] = ObjectIdGetDatum(newOwnerId);
 
        /*
         * Determine the modified ACL for the new owner.  This is only
         * necessary when the ACL is non-null.
         */
        aclDatum = heap_getattr(tuple,
                                Anum_pg_database_datacl,
                                RelationGetDescr(rel),
                                &isNull);
        if (!isNull)
        {
            newAcl = aclnewowner(DatumGetAclP(aclDatum),
                                 datForm->datdba, newOwnerId);
            repl_repl[Anum_pg_database_datacl - 1] = true;
            repl_val[Anum_pg_database_datacl - 1] = PointerGetDatum(newAcl);
        }
 
        newtuple = heap_modify_tuple(tuple, RelationGetDescr(rel), repl_val, repl_null, repl_repl);
        CatalogTupleUpdate(rel, &newtuple->t_self, newtuple);
        UnlockTuple(rel, &tuple->t_self, InplaceUpdateTupleLock);
 
        heap_freetuple(newtuple);
 
        /* Update owner dependency reference */
        changeDependencyOnOwner(DatabaseRelationId, db_id, newOwnerId);
    }
 
    InvokeObjectPostAlterHook(DatabaseRelationId, db_id, 0);
 
    ObjectAddressSet(address, DatabaseRelationId, db_id);
 
    systable_endscan(scan);
 
    /* Close pg_database, but keep lock till commit */
    table_close(rel, NoLock);
 
    return address;
}

References aclcheck_error(), ACLCHECK_NOT_OWNER, aclnewowner(), BTEqualStrategyNumber, CatalogTupleUpdate(), changeDependencyOnOwner(), check_can_set_role(), CStringGetDatum(), DatumGetAclP, dbname, ereport, errcode(), errmsg(), ERROR, fb(), GETSTRUCT(), GetUserId(), have_createdb_privilege(), heap_freetuple(), heap_getattr(), heap_modify_tuple(), HeapTupleIsValid, InplaceUpdateTupleLock, InvokeObjectPostAlterHook, LockTuple(), NoLock, OBJECT_DATABASE, object_ownercheck(), ObjectAddressSet, ObjectIdGetDatum(), PointerGetDatum(), RelationGetDescr, RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), table_open(), and UnlockTuple().

Referenced by ExecAlterOwnerStmt().

AlterDatabaseRefreshColl()

ObjectAddress AlterDatabaseRefreshColl ( AlterDatabaseRefreshCollStmt *  stmt )

extern

Definition at line 2542 of file dbcommands.c.

{
    Relation    rel;
    ScanKeyData scankey;
    SysScanDesc scan;
    Oid         db_id;
    HeapTuple   tuple;
    Form_pg_database datForm;
    ObjectAddress address;
    Datum       datum;
    bool        isnull;
    char       *oldversion;
    char       *newversion;
 
    rel = table_open(DatabaseRelationId, RowExclusiveLock);
    ScanKeyInit(&scankey,
                Anum_pg_database_datname,
                BTEqualStrategyNumber, F_NAMEEQ,
                CStringGetDatum(stmt->dbname));
    scan = systable_beginscan(rel, DatabaseNameIndexId, true,
                              NULL, 1, &scankey);
    tuple = systable_getnext(scan);
    if (!HeapTupleIsValid(tuple))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_DATABASE),
                 errmsg("database \"%s\" does not exist", stmt->dbname)));
 
    datForm = (Form_pg_database) GETSTRUCT(tuple);
    db_id = datForm->oid;
 
    if (!object_ownercheck(DatabaseRelationId, db_id, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_DATABASE,
                       stmt->dbname);
    LockTuple(rel, &tuple->t_self, InplaceUpdateTupleLock);
 
    datum = heap_getattr(tuple, Anum_pg_database_datcollversion, RelationGetDescr(rel), &isnull);
    oldversion = isnull ? NULL : TextDatumGetCString(datum);
 
    if (datForm->datlocprovider == COLLPROVIDER_LIBC)
    {
        datum = heap_getattr(tuple, Anum_pg_database_datcollate, RelationGetDescr(rel), &isnull);
        if (isnull)
            elog(ERROR, "unexpected null in pg_database");
    }
    else
    {
        datum = heap_getattr(tuple, Anum_pg_database_datlocale, RelationGetDescr(rel), &isnull);
        if (isnull)
            elog(ERROR, "unexpected null in pg_database");
    }
 
    newversion = get_collation_actual_version(datForm->datlocprovider,
                                              TextDatumGetCString(datum));
 
    /* cannot change from NULL to non-NULL or vice versa */
    if ((!oldversion && newversion) || (oldversion && !newversion))
        elog(ERROR, "invalid collation version change");
    else if (oldversion && newversion && strcmp(newversion, oldversion) != 0)
    {
        bool        nulls[Natts_pg_database] = {0};
        bool        replaces[Natts_pg_database] = {0};
        Datum       values[Natts_pg_database] = {0};
        HeapTuple   newtuple;
 
        ereport(NOTICE,
                (errmsg("changing version from %s to %s",
                        oldversion, newversion)));
 
        values[Anum_pg_database_datcollversion - 1] = CStringGetTextDatum(newversion);
        replaces[Anum_pg_database_datcollversion - 1] = true;
 
        newtuple = heap_modify_tuple(tuple, RelationGetDescr(rel),
                                     values, nulls, replaces);
        CatalogTupleUpdate(rel, &tuple->t_self, newtuple);
        heap_freetuple(newtuple);
    }
    else
        ereport(NOTICE,
                (errmsg("version has not changed")));
    UnlockTuple(rel, &tuple->t_self, InplaceUpdateTupleLock);
 
    InvokeObjectPostAlterHook(DatabaseRelationId, db_id, 0);
 
    ObjectAddressSet(address, DatabaseRelationId, db_id);
 
    systable_endscan(scan);
 
    table_close(rel, NoLock);
 
    return address;
}

References aclcheck_error(), ACLCHECK_NOT_OWNER, BTEqualStrategyNumber, CatalogTupleUpdate(), CStringGetDatum(), CStringGetTextDatum, elog, ereport, errcode(), errmsg(), ERROR, fb(), get_collation_actual_version(), GETSTRUCT(), GetUserId(), heap_freetuple(), heap_getattr(), heap_modify_tuple(), HeapTupleIsValid, InplaceUpdateTupleLock, InvokeObjectPostAlterHook, LockTuple(), NoLock, NOTICE, OBJECT_DATABASE, object_ownercheck(), ObjectAddressSet, RelationGetDescr, RowExclusiveLock, ScanKeyInit(), stmt, systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), table_open(), TextDatumGetCString, UnlockTuple(), and values.

Referenced by standard_ProcessUtility().

AlterDatabaseSet()

Oid AlterDatabaseSet ( AlterDatabaseSetStmt *  stmt )

extern

Definition at line 2639 of file dbcommands.c.

{
    Oid         datid = get_database_oid(stmt->dbname, false);
 
    /*
     * Obtain a lock on the database and make sure it didn't go away in the
     * meantime.
     */
    shdepLockAndCheckObject(DatabaseRelationId, datid);
 
    if (!object_ownercheck(DatabaseRelationId, datid, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_DATABASE,
                       stmt->dbname);
 
    AlterSetting(datid, InvalidOid, stmt->setstmt);
 
    UnlockSharedObject(DatabaseRelationId, datid, 0, AccessShareLock);
 
    return datid;
}

References AccessShareLock, aclcheck_error(), ACLCHECK_NOT_OWNER, AlterSetting(), fb(), get_database_oid(), GetUserId(), InvalidOid, OBJECT_DATABASE, object_ownercheck(), shdepLockAndCheckObject(), stmt, and UnlockSharedObject().

Referenced by standard_ProcessUtility().

check_encoding_locale_matches()

void check_encoding_locale_matches ( int  encoding, const char *  collate, const char *  ctype  )

extern

Definition at line 1597 of file dbcommands.c.

{
    int         ctype_encoding = pg_get_encoding_from_locale(ctype, true);
    int         collate_encoding = pg_get_encoding_from_locale(collate, true);
 
    if (!(ctype_encoding == encoding ||
          ctype_encoding == PG_SQL_ASCII ||
          ctype_encoding == -1 ||
#ifdef WIN32
          encoding == PG_UTF8 ||
#endif
          (encoding == PG_SQL_ASCII && superuser())))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("encoding \"%s\" does not match locale \"%s\"",
                        pg_encoding_to_char(encoding),
                        ctype),
                 errdetail("The chosen LC_CTYPE setting requires encoding \"%s\".",
                           pg_encoding_to_char(ctype_encoding))));
 
    if (!(collate_encoding == encoding ||
          collate_encoding == PG_SQL_ASCII ||
          collate_encoding == -1 ||
#ifdef WIN32
          encoding == PG_UTF8 ||
#endif
          (encoding == PG_SQL_ASCII && superuser())))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("encoding \"%s\" does not match locale \"%s\"",
                        pg_encoding_to_char(encoding),
                        collate),
                 errdetail("The chosen LC_COLLATE setting requires encoding \"%s\".",
                           pg_encoding_to_char(collate_encoding))));
}

References encoding, ereport, errcode(), errdetail(), errmsg(), ERROR, fb(), pg_encoding_to_char, pg_get_encoding_from_locale(), PG_SQL_ASCII, PG_UTF8, and superuser().

Referenced by createdb(), and DefineCollation().

createdb()

Oid createdb ( ParseState *  pstate, const CreatedbStmt *  stmt  )

extern

Definition at line 685 of file dbcommands.c.

{
    Oid         src_dboid;
    Oid         src_owner;
    int         src_encoding = -1;
    char       *src_collate = NULL;
    char       *src_ctype = NULL;
    char       *src_locale = NULL;
    char       *src_icurules = NULL;
    char        src_locprovider = '\0';
    char       *src_collversion = NULL;
    bool        src_istemplate;
    bool        src_hasloginevt = false;
    bool        src_allowconn;
    TransactionId src_frozenxid = InvalidTransactionId;
    MultiXactId src_minmxid = InvalidMultiXactId;
    Oid         src_deftablespace;
    volatile Oid dst_deftablespace;
    Relation    pg_database_rel;
    HeapTuple   tuple;
    Datum       new_record[Natts_pg_database] = {0};
    bool        new_record_nulls[Natts_pg_database] = {0};
    Oid         dboid = InvalidOid;
    Oid         datdba;
    ListCell   *option;
    DefElem    *tablespacenameEl = NULL;
    DefElem    *ownerEl = NULL;
    DefElem    *templateEl = NULL;
    DefElem    *encodingEl = NULL;
    DefElem    *localeEl = NULL;
    DefElem    *builtinlocaleEl = NULL;
    DefElem    *collateEl = NULL;
    DefElem    *ctypeEl = NULL;
    DefElem    *iculocaleEl = NULL;
    DefElem    *icurulesEl = NULL;
    DefElem    *locproviderEl = NULL;
    DefElem    *istemplateEl = NULL;
    DefElem    *allowconnectionsEl = NULL;
    DefElem    *connlimitEl = NULL;
    DefElem    *collversionEl = NULL;
    DefElem    *strategyEl = NULL;
    char       *dbname = stmt->dbname;
    char       *dbowner = NULL;
    const char *dbtemplate = NULL;
    char       *dbcollate = NULL;
    char       *dbctype = NULL;
    const char *dblocale = NULL;
    char       *dbicurules = NULL;
    char        dblocprovider = '\0';
    char       *canonname;
    int         encoding = -1;
    bool        dbistemplate = false;
    bool        dballowconnections = true;
    int         dbconnlimit = DATCONNLIMIT_UNLIMITED;
    char       *dbcollversion = NULL;
    int         notherbackends;
    int         npreparedxacts;
    CreateDBStrategy dbstrategy = CREATEDB_WAL_LOG;
    createdb_failure_params fparms;
 
    /* Extract options from the statement node tree */
    foreach(option, stmt->options)
    {
        DefElem    *defel = (DefElem *) lfirst(option);
 
        if (strcmp(defel->defname, "tablespace") == 0)
        {
            if (tablespacenameEl)
                errorConflictingDefElem(defel, pstate);
            tablespacenameEl = defel;
        }
        else if (strcmp(defel->defname, "owner") == 0)
        {
            if (ownerEl)
                errorConflictingDefElem(defel, pstate);
            ownerEl = defel;
        }
        else if (strcmp(defel->defname, "template") == 0)
        {
            if (templateEl)
                errorConflictingDefElem(defel, pstate);
            templateEl = defel;
        }
        else if (strcmp(defel->defname, "encoding") == 0)
        {
            if (encodingEl)
                errorConflictingDefElem(defel, pstate);
            encodingEl = defel;
        }
        else if (strcmp(defel->defname, "locale") == 0)
        {
            if (localeEl)
                errorConflictingDefElem(defel, pstate);
            localeEl = defel;
        }
        else if (strcmp(defel->defname, "builtin_locale") == 0)
        {
            if (builtinlocaleEl)
                errorConflictingDefElem(defel, pstate);
            builtinlocaleEl = defel;
        }
        else if (strcmp(defel->defname, "lc_collate") == 0)
        {
            if (collateEl)
                errorConflictingDefElem(defel, pstate);
            collateEl = defel;
        }
        else if (strcmp(defel->defname, "lc_ctype") == 0)
        {
            if (ctypeEl)
                errorConflictingDefElem(defel, pstate);
            ctypeEl = defel;
        }
        else if (strcmp(defel->defname, "icu_locale") == 0)
        {
            if (iculocaleEl)
                errorConflictingDefElem(defel, pstate);
            iculocaleEl = defel;
        }
        else if (strcmp(defel->defname, "icu_rules") == 0)
        {
            if (icurulesEl)
                errorConflictingDefElem(defel, pstate);
            icurulesEl = defel;
        }
        else if (strcmp(defel->defname, "locale_provider") == 0)
        {
            if (locproviderEl)
                errorConflictingDefElem(defel, pstate);
            locproviderEl = defel;
        }
        else if (strcmp(defel->defname, "is_template") == 0)
        {
            if (istemplateEl)
                errorConflictingDefElem(defel, pstate);
            istemplateEl = defel;
        }
        else if (strcmp(defel->defname, "allow_connections") == 0)
        {
            if (allowconnectionsEl)
                errorConflictingDefElem(defel, pstate);
            allowconnectionsEl = defel;
        }
        else if (strcmp(defel->defname, "connection_limit") == 0)
        {
            if (connlimitEl)
                errorConflictingDefElem(defel, pstate);
            connlimitEl = defel;
        }
        else if (strcmp(defel->defname, "collation_version") == 0)
        {
            if (collversionEl)
                errorConflictingDefElem(defel, pstate);
            collversionEl = defel;
        }
        else if (strcmp(defel->defname, "location") == 0)
        {
            ereport(WARNING,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("LOCATION is not supported anymore"),
                     errhint("Consider using tablespaces instead."),
                     parser_errposition(pstate, defel->location)));
        }
        else if (strcmp(defel->defname, "oid") == 0)
        {
            dboid = defGetObjectId(defel);
 
            /*
             * We don't normally permit new databases to be created with
             * system-assigned OIDs. pg_upgrade tries to preserve database
             * OIDs, so we can't allow any database to be created with an OID
             * that might be in use in a freshly-initialized cluster created
             * by some future version. We assume all such OIDs will be from
             * the system-managed OID range.
             *
             * As an exception, however, we permit any OID to be assigned when
             * allow_system_table_mods=on (so that initdb can assign system
             * OIDs to template0 and postgres) or when performing a binary
             * upgrade (so that pg_upgrade can preserve whatever OIDs it finds
             * in the source cluster).
             */
            if (dboid < FirstNormalObjectId &&
                !allowSystemTableMods && !IsBinaryUpgrade)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE)),
                        errmsg("OIDs less than %u are reserved for system objects", FirstNormalObjectId));
        }
        else if (strcmp(defel->defname, "strategy") == 0)
        {
            if (strategyEl)
                errorConflictingDefElem(defel, pstate);
            strategyEl = defel;
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("option \"%s\" not recognized", defel->defname),
                     parser_errposition(pstate, defel->location)));
    }
 
    if (ownerEl && ownerEl->arg)
        dbowner = defGetString(ownerEl);
    if (templateEl && templateEl->arg)
        dbtemplate = defGetString(templateEl);
    if (encodingEl && encodingEl->arg)
    {
        const char *encoding_name;
 
        if (IsA(encodingEl->arg, Integer))
        {
            encoding = defGetInt32(encodingEl);
            encoding_name = pg_encoding_to_char(encoding);
            if (strcmp(encoding_name, "") == 0 ||
                pg_valid_server_encoding(encoding_name) < 0)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("%d is not a valid encoding code",
                                encoding),
                         parser_errposition(pstate, encodingEl->location)));
        }
        else
        {
            encoding_name = defGetString(encodingEl);
            encoding = pg_valid_server_encoding(encoding_name);
            if (encoding < 0)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("%s is not a valid encoding name",
                                encoding_name),
                         parser_errposition(pstate, encodingEl->location)));
        }
    }
    if (localeEl && localeEl->arg)
    {
        dbcollate = defGetString(localeEl);
        dbctype = defGetString(localeEl);
        dblocale = defGetString(localeEl);
    }
    if (builtinlocaleEl && builtinlocaleEl->arg)
        dblocale = defGetString(builtinlocaleEl);
    if (collateEl && collateEl->arg)
        dbcollate = defGetString(collateEl);
    if (ctypeEl && ctypeEl->arg)
        dbctype = defGetString(ctypeEl);
    if (iculocaleEl && iculocaleEl->arg)
        dblocale = defGetString(iculocaleEl);
    if (icurulesEl && icurulesEl->arg)
        dbicurules = defGetString(icurulesEl);
    if (locproviderEl && locproviderEl->arg)
    {
        char       *locproviderstr = defGetString(locproviderEl);
 
        if (pg_strcasecmp(locproviderstr, "builtin") == 0)
            dblocprovider = COLLPROVIDER_BUILTIN;
        else if (pg_strcasecmp(locproviderstr, "icu") == 0)
            dblocprovider = COLLPROVIDER_ICU;
        else if (pg_strcasecmp(locproviderstr, "libc") == 0)
            dblocprovider = COLLPROVIDER_LIBC;
        else
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("unrecognized locale provider: %s",
                            locproviderstr)));
    }
    if (istemplateEl && istemplateEl->arg)
        dbistemplate = defGetBoolean(istemplateEl);
    if (allowconnectionsEl && allowconnectionsEl->arg)
        dballowconnections = defGetBoolean(allowconnectionsEl);
    if (connlimitEl && connlimitEl->arg)
    {
        dbconnlimit = defGetInt32(connlimitEl);
        if (dbconnlimit < DATCONNLIMIT_UNLIMITED)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid connection limit: %d", dbconnlimit)));
    }
    if (collversionEl)
        dbcollversion = defGetString(collversionEl);
 
    /* obtain OID of proposed owner */
    if (dbowner)
        datdba = get_role_oid(dbowner, false);
    else
        datdba = GetUserId();
 
    /*
     * To create a database, must have createdb privilege and must be able to
     * become the target role (this does not imply that the target role itself
     * must have createdb privilege).  The latter provision guards against
     * "giveaway" attacks.  Note that a superuser will always have both of
     * these privileges a fortiori.
     */
    if (!have_createdb_privilege())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to create database")));
 
    check_can_set_role(GetUserId(), datdba);
 
    /*
     * Lookup database (template) to be cloned, and obtain share lock on it.
     * ShareLock allows two CREATE DATABASEs to work from the same template
     * concurrently, while ensuring no one is busy dropping it in parallel
     * (which would be Very Bad since we'd likely get an incomplete copy
     * without knowing it).  This also prevents any new connections from being
     * made to the source until we finish copying it, so we can be sure it
     * won't change underneath us.
     */
    if (!dbtemplate)
        dbtemplate = "template1";   /* Default template database name */
 
    if (!get_db_info(dbtemplate, ShareLock,
                     &src_dboid, &src_owner, &src_encoding,
                     &src_istemplate, &src_allowconn, &src_hasloginevt,
                     &src_frozenxid, &src_minmxid, &src_deftablespace,
                     &src_collate, &src_ctype, &src_locale, &src_icurules, &src_locprovider,
                     &src_collversion))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_DATABASE),
                 errmsg("template database \"%s\" does not exist",
                        dbtemplate)));
 
    /*
     * If the source database was in the process of being dropped, we can't
     * use it as a template.
     */
    if (database_is_invalid_oid(src_dboid))
        ereport(ERROR,
                errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                errmsg("cannot use invalid database \"%s\" as template", dbtemplate),
                errhint("Use DROP DATABASE to drop invalid databases."));
 
    /*
     * Permission check: to copy a DB that's not marked datistemplate, you
     * must be superuser or the owner thereof.
     */
    if (!src_istemplate)
    {
        if (!object_ownercheck(DatabaseRelationId, src_dboid, GetUserId()))
            ereport(ERROR,
                    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                     errmsg("permission denied to copy database \"%s\"",
                            dbtemplate)));
    }
 
    /* Validate the database creation strategy. */
    if (strategyEl && strategyEl->arg)
    {
        char       *strategy;
 
        strategy = defGetString(strategyEl);
        if (pg_strcasecmp(strategy, "wal_log") == 0)
            dbstrategy = CREATEDB_WAL_LOG;
        else if (pg_strcasecmp(strategy, "file_copy") == 0)
            dbstrategy = CREATEDB_FILE_COPY;
        else
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid create database strategy \"%s\"", strategy),
                     errhint("Valid strategies are \"wal_log\" and \"file_copy\".")));
    }
 
    /* If encoding or locales are defaulted, use source's setting */
    if (encoding < 0)
        encoding = src_encoding;
    if (dbcollate == NULL)
        dbcollate = src_collate;
    if (dbctype == NULL)
        dbctype = src_ctype;
    if (dblocprovider == '\0')
        dblocprovider = src_locprovider;
    if (dblocale == NULL && dblocprovider == src_locprovider)
        dblocale = src_locale;
    if (dbicurules == NULL)
        dbicurules = src_icurules;
 
    /* Some encodings are client only */
    if (!PG_VALID_BE_ENCODING(encoding))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("invalid server encoding %d", encoding)));
 
    /* Check that the chosen locales are valid, and get canonical spellings */
    if (!check_locale(LC_COLLATE, dbcollate, &canonname))
    {
        if (dblocprovider == COLLPROVIDER_BUILTIN)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("invalid LC_COLLATE locale name: \"%s\"", dbcollate),
                     errhint("If the locale name is specific to the builtin provider, use BUILTIN_LOCALE.")));
        else if (dblocprovider == COLLPROVIDER_ICU)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("invalid LC_COLLATE locale name: \"%s\"", dbcollate),
                     errhint("If the locale name is specific to the ICU provider, use ICU_LOCALE.")));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("invalid LC_COLLATE locale name: \"%s\"", dbcollate)));
    }
    dbcollate = canonname;
    if (!check_locale(LC_CTYPE, dbctype, &canonname))
    {
        if (dblocprovider == COLLPROVIDER_BUILTIN)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("invalid LC_CTYPE locale name: \"%s\"", dbctype),
                     errhint("If the locale name is specific to the builtin provider, use BUILTIN_LOCALE.")));
        else if (dblocprovider == COLLPROVIDER_ICU)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("invalid LC_CTYPE locale name: \"%s\"", dbctype),
                     errhint("If the locale name is specific to the ICU provider, use ICU_LOCALE.")));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("invalid LC_CTYPE locale name: \"%s\"", dbctype)));
    }
 
    dbctype = canonname;
 
    check_encoding_locale_matches(encoding, dbcollate, dbctype);
 
    /* validate provider-specific parameters */
    if (dblocprovider != COLLPROVIDER_BUILTIN)
    {
        if (builtinlocaleEl)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("BUILTIN_LOCALE cannot be specified unless locale provider is builtin")));
    }
 
    if (dblocprovider != COLLPROVIDER_ICU)
    {
        if (iculocaleEl)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("ICU locale cannot be specified unless locale provider is ICU")));
 
        if (dbicurules)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("ICU rules cannot be specified unless locale provider is ICU")));
    }
 
    /* validate and canonicalize locale for the provider */
    if (dblocprovider == COLLPROVIDER_BUILTIN)
    {
        /*
         * This would happen if template0 uses the libc provider but the new
         * database uses builtin.
         */
        if (!dblocale)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("LOCALE or BUILTIN_LOCALE must be specified")));
 
        dblocale = builtin_validate_locale(encoding, dblocale);
    }
    else if (dblocprovider == COLLPROVIDER_ICU)
    {
        if (!(is_encoding_supported_by_icu(encoding)))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("encoding \"%s\" is not supported with ICU provider",
                            pg_encoding_to_char(encoding))));
 
        /*
         * This would happen if template0 uses the libc provider but the new
         * database uses icu.
         */
        if (!dblocale)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("LOCALE or ICU_LOCALE must be specified")));
 
        /*
         * During binary upgrade, or when the locale came from the template
         * database, preserve locale string. Otherwise, canonicalize to a
         * language tag.
         */
        if (!IsBinaryUpgrade && dblocale != src_locale)
        {
            char       *langtag = icu_language_tag(dblocale,
                                                   icu_validation_level);
 
            if (langtag && strcmp(dblocale, langtag) != 0)
            {
                ereport(NOTICE,
                        (errmsg("using standard form \"%s\" for ICU locale \"%s\"",
                                langtag, dblocale)));
 
                dblocale = langtag;
            }
        }
 
        icu_validate_locale(dblocale);
    }
 
    /* for libc, locale comes from datcollate and datctype */
    if (dblocprovider == COLLPROVIDER_LIBC)
        dblocale = NULL;
 
    /*
     * Check that the new encoding and locale settings match the source
     * database.  We insist on this because we simply copy the source data ---
     * any non-ASCII data would be wrongly encoded, and any indexes sorted
     * according to the source locale would be wrong.
     *
     * However, we assume that template0 doesn't contain any non-ASCII data
     * nor any indexes that depend on collation or ctype, so template0 can be
     * used as template for creating a database with any encoding or locale.
     */
    if (strcmp(dbtemplate, "template0") != 0)
    {
        if (encoding != src_encoding)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("new encoding (%s) is incompatible with the encoding of the template database (%s)",
                            pg_encoding_to_char(encoding),
                            pg_encoding_to_char(src_encoding)),
                     errhint("Use the same encoding as in the template database, or use template0 as template.")));
 
        if (strcmp(dbcollate, src_collate) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("new collation (%s) is incompatible with the collation of the template database (%s)",
                            dbcollate, src_collate),
                     errhint("Use the same collation as in the template database, or use template0 as template.")));
 
        if (strcmp(dbctype, src_ctype) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("new LC_CTYPE (%s) is incompatible with the LC_CTYPE of the template database (%s)",
                            dbctype, src_ctype),
                     errhint("Use the same LC_CTYPE as in the template database, or use template0 as template.")));
 
        if (dblocprovider != src_locprovider)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("new locale provider (%s) does not match locale provider of the template database (%s)",
                            collprovider_name(dblocprovider), collprovider_name(src_locprovider)),
                     errhint("Use the same locale provider as in the template database, or use template0 as template.")));
 
        if (dblocprovider == COLLPROVIDER_ICU)
        {
            char       *val1;
            char       *val2;
 
            Assert(dblocale);
            Assert(src_locale);
            if (strcmp(dblocale, src_locale) != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("new ICU locale (%s) is incompatible with the ICU locale of the template database (%s)",
                                dblocale, src_locale),
                         errhint("Use the same ICU locale as in the template database, or use template0 as template.")));
 
            val1 = dbicurules;
            if (!val1)
                val1 = "";
            val2 = src_icurules;
            if (!val2)
                val2 = "";
            if (strcmp(val1, val2) != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("new ICU collation rules (%s) are incompatible with the ICU collation rules of the template database (%s)",
                                val1, val2),
                         errhint("Use the same ICU collation rules as in the template database, or use template0 as template.")));
        }
    }
 
    /*
     * If we got a collation version for the template database, check that it
     * matches the actual OS collation version.  Otherwise error; the user
     * needs to fix the template database first.  Don't complain if a
     * collation version was specified explicitly as a statement option; that
     * is used by pg_upgrade to reproduce the old state exactly.
     *
     * (If the template database has no collation version, then either the
     * platform/provider does not support collation versioning, or it's
     * template0, for which we stipulate that it does not contain
     * collation-using objects.)
     */
    if (src_collversion && !collversionEl)
    {
        char       *actual_versionstr;
        const char *locale;
 
        if (dblocprovider == COLLPROVIDER_LIBC)
            locale = dbcollate;
        else
            locale = dblocale;
 
        actual_versionstr = get_collation_actual_version(dblocprovider, locale);
        if (!actual_versionstr)
            ereport(ERROR,
                    (errmsg("template database \"%s\" has a collation version, but no actual collation version could be determined",
                            dbtemplate)));
 
        if (strcmp(actual_versionstr, src_collversion) != 0)
            ereport(ERROR,
                    (errmsg("template database \"%s\" has a collation version mismatch",
                            dbtemplate),
                     errdetail("The template database was created using collation version %s, "
                               "but the operating system provides version %s.",
                               src_collversion, actual_versionstr),
                     errhint("Rebuild all objects in the template database that use the default collation and run "
                             "ALTER DATABASE %s REFRESH COLLATION VERSION, "
                             "or build PostgreSQL with the right library version.",
                             quote_identifier(dbtemplate))));
    }
 
    if (dbcollversion == NULL)
        dbcollversion = src_collversion;
 
    /*
     * Normally, we copy the collation version from the template database.
     * This last resort only applies if the template database does not have a
     * collation version, which is normally only the case for template0.
     */
    if (dbcollversion == NULL)
    {
        const char *locale;
 
        if (dblocprovider == COLLPROVIDER_LIBC)
            locale = dbcollate;
        else
            locale = dblocale;
 
        dbcollversion = get_collation_actual_version(dblocprovider, locale);
    }
 
    /* Resolve default tablespace for new database */
    if (tablespacenameEl && tablespacenameEl->arg)
    {
        char       *tablespacename;
        AclResult   aclresult;
 
        tablespacename = defGetString(tablespacenameEl);
        dst_deftablespace = get_tablespace_oid(tablespacename, false);
        /* check permissions */
        aclresult = object_aclcheck(TableSpaceRelationId, dst_deftablespace, GetUserId(),
                                    ACL_CREATE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_TABLESPACE,
                           tablespacename);
 
        /* pg_global must never be the default tablespace */
        if (dst_deftablespace == GLOBALTABLESPACE_OID)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("pg_global cannot be used as default tablespace")));
 
        /*
         * If we are trying to change the default tablespace of the template,
         * we require that the template not have any files in the new default
         * tablespace.  This is necessary because otherwise the copied
         * database would contain pg_class rows that refer to its default
         * tablespace both explicitly (by OID) and implicitly (as zero), which
         * would cause problems.  For example another CREATE DATABASE using
         * the copied database as template, and trying to change its default
         * tablespace again, would yield outright incorrect results (it would
         * improperly move tables to the new default tablespace that should
         * stay in the same tablespace).
         */
        if (dst_deftablespace != src_deftablespace)
        {
            char       *srcpath;
            struct stat st;
 
            srcpath = GetDatabasePath(src_dboid, dst_deftablespace);
 
            if (stat(srcpath, &st) == 0 &&
                S_ISDIR(st.st_mode) &&
                !directory_is_empty(srcpath))
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot assign new default tablespace \"%s\"",
                                tablespacename),
                         errdetail("There is a conflict because database \"%s\" already has some tables in this tablespace.",
                                   dbtemplate)));
            pfree(srcpath);
        }
    }
    else
    {
        /* Use template database's default tablespace */
        dst_deftablespace = src_deftablespace;
        /* Note there is no additional permission check in this path */
    }
 
    /*
     * If built with appropriate switch, whine when regression-testing
     * conventions for database names are violated.  But don't complain during
     * initdb.
     */
#ifdef ENFORCE_REGRESSION_TEST_NAME_RESTRICTIONS
    if (IsUnderPostmaster && strstr(dbname, "regression") == NULL)
        elog(WARNING, "databases created by regression test cases should have names including \"regression\"");
#endif
 
    /*
     * Check for db name conflict.  This is just to give a more friendly error
     * message than "unique index violation".  There's a race condition but
     * we're willing to accept the less friendly message in that case.
     */
    if (OidIsValid(get_database_oid(dbname, true)))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_DATABASE),
                 errmsg("database \"%s\" already exists", dbname)));
 
    /*
     * The source DB can't have any active backends, except this one
     * (exception is to allow CREATE DB while connected to template1).
     * Otherwise we might copy inconsistent data.
     *
     * This should be last among the basic error checks, because it involves
     * potential waiting; we may as well throw an error first if we're gonna
     * throw one.
     */
    if (CountOtherDBBackends(src_dboid, &notherbackends, &npreparedxacts))
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_IN_USE),
                 errmsg("source database \"%s\" is being accessed by other users",
                        dbtemplate),
                 errdetail_busy_db(notherbackends, npreparedxacts)));
 
    /*
     * Select an OID for the new database, checking that it doesn't have a
     * filename conflict with anything already existing in the tablespace
     * directories.
     */
    pg_database_rel = table_open(DatabaseRelationId, RowExclusiveLock);
 
    /*
     * If database OID is configured, check if the OID is already in use or
     * data directory already exists.
     */
    if (OidIsValid(dboid))
    {
        char       *existing_dbname = get_database_name(dboid);
 
        if (existing_dbname != NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE)),
                    errmsg("database OID %u is already in use by database \"%s\"",
                           dboid, existing_dbname));
 
        if (check_db_file_conflict(dboid))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE)),
                    errmsg("data directory with the specified OID %u already exists", dboid));
    }
    else
    {
        /* Select an OID for the new database if is not explicitly configured. */
        do
        {
            dboid = GetNewOidWithIndex(pg_database_rel, DatabaseOidIndexId,
                                       Anum_pg_database_oid);
        } while (check_db_file_conflict(dboid));
    }
 
    /*
     * Insert a new tuple into pg_database.  This establishes our ownership of
     * the new database name (anyone else trying to insert the same name will
     * block on the unique index, and fail after we commit).
     */
 
    Assert((dblocprovider != COLLPROVIDER_LIBC && dblocale) ||
           (dblocprovider == COLLPROVIDER_LIBC && !dblocale));
 
    /* Form tuple */
    new_record[Anum_pg_database_oid - 1] = ObjectIdGetDatum(dboid);
    new_record[Anum_pg_database_datname - 1] =
        DirectFunctionCall1(namein, CStringGetDatum(dbname));
    new_record[Anum_pg_database_datdba - 1] = ObjectIdGetDatum(datdba);
    new_record[Anum_pg_database_encoding - 1] = Int32GetDatum(encoding);
    new_record[Anum_pg_database_datlocprovider - 1] = CharGetDatum(dblocprovider);
    new_record[Anum_pg_database_datistemplate - 1] = BoolGetDatum(dbistemplate);
    new_record[Anum_pg_database_datallowconn - 1] = BoolGetDatum(dballowconnections);
    new_record[Anum_pg_database_dathasloginevt - 1] = BoolGetDatum(src_hasloginevt);
    new_record[Anum_pg_database_datconnlimit - 1] = Int32GetDatum(dbconnlimit);
    new_record[Anum_pg_database_datfrozenxid - 1] = TransactionIdGetDatum(src_frozenxid);
    new_record[Anum_pg_database_datminmxid - 1] = TransactionIdGetDatum(src_minmxid);
    new_record[Anum_pg_database_dattablespace - 1] = ObjectIdGetDatum(dst_deftablespace);
    new_record[Anum_pg_database_datcollate - 1] = CStringGetTextDatum(dbcollate);
    new_record[Anum_pg_database_datctype - 1] = CStringGetTextDatum(dbctype);
    if (dblocale)
        new_record[Anum_pg_database_datlocale - 1] = CStringGetTextDatum(dblocale);
    else
        new_record_nulls[Anum_pg_database_datlocale - 1] = true;
    if (dbicurules)
        new_record[Anum_pg_database_daticurules - 1] = CStringGetTextDatum(dbicurules);
    else
        new_record_nulls[Anum_pg_database_daticurules - 1] = true;
    if (dbcollversion)
        new_record[Anum_pg_database_datcollversion - 1] = CStringGetTextDatum(dbcollversion);
    else
        new_record_nulls[Anum_pg_database_datcollversion - 1] = true;
 
    /*
     * We deliberately set datacl to default (NULL), rather than copying it
     * from the template database.  Copying it would be a bad idea when the
     * owner is not the same as the template's owner.
     */
    new_record_nulls[Anum_pg_database_datacl - 1] = true;
 
    tuple = heap_form_tuple(RelationGetDescr(pg_database_rel),
                            new_record, new_record_nulls);
 
    CatalogTupleInsert(pg_database_rel, tuple);
 
    /*
     * Now generate additional catalog entries associated with the new DB
     */
 
    /* Register owner dependency */
    recordDependencyOnOwner(DatabaseRelationId, dboid, datdba);
 
    /* Create pg_shdepend entries for objects within database */
    copyTemplateDependencies(src_dboid, dboid);
 
    /* Post creation hook for new database */
    InvokeObjectPostCreateHook(DatabaseRelationId, dboid, 0);
 
    /*
     * If we're going to be reading data for the to-be-created database into
     * shared_buffers, take a lock on it. Nobody should know that this
     * database exists yet, but it's good to maintain the invariant that an
     * AccessExclusiveLock on the database is sufficient to drop all of its
     * buffers without worrying about more being read later.
     *
     * Note that we need to do this before entering the
     * PG_ENSURE_ERROR_CLEANUP block below, because createdb_failure_callback
     * expects this lock to be held already.
     */
    if (dbstrategy == CREATEDB_WAL_LOG)
        LockSharedObject(DatabaseRelationId, dboid, 0, AccessShareLock);
 
    /*
     * Once we start copying subdirectories, we need to be able to clean 'em
     * up if we fail.  Use an ENSURE block to make sure this happens.  (This
     * is not a 100% solution, because of the possibility of failure during
     * transaction commit after we leave this routine, but it should handle
     * most scenarios.)
     */
    fparms.src_dboid = src_dboid;
    fparms.dest_dboid = dboid;
    fparms.strategy = dbstrategy;
 
    PG_ENSURE_ERROR_CLEANUP(createdb_failure_callback,
                            PointerGetDatum(&fparms));
    {
        /*
         * If the user has asked to create a database with WAL_LOG strategy
         * then call CreateDatabaseUsingWalLog, which will copy the database
         * at the block level and it will WAL log each copied block.
         * Otherwise, call CreateDatabaseUsingFileCopy that will copy the
         * database file by file.
         */
        if (dbstrategy == CREATEDB_WAL_LOG)
            CreateDatabaseUsingWalLog(src_dboid, dboid, src_deftablespace,
                                      dst_deftablespace);
        else
            CreateDatabaseUsingFileCopy(src_dboid, dboid, src_deftablespace,
                                        dst_deftablespace);
 
        /*
         * Close pg_database, but keep lock till commit.
         */
        table_close(pg_database_rel, NoLock);
 
        /*
         * Force synchronous commit, thus minimizing the window between
         * creation of the database files and committal of the transaction. If
         * we crash before committing, we'll have a DB that's taking up disk
         * space but is not in pg_database, which is not good.
         */
        ForceSyncCommit();
    }
    PG_END_ENSURE_ERROR_CLEANUP(createdb_failure_callback,
                                PointerGetDatum(&fparms));
 
    return dboid;
}

References AccessShareLock, ACL_CREATE, aclcheck_error(), ACLCHECK_OK, allowSystemTableMods, Assert, BoolGetDatum(), builtin_validate_locale(), CatalogTupleInsert(), CharGetDatum(), check_can_set_role(), check_db_file_conflict(), check_encoding_locale_matches(), check_locale(), copyTemplateDependencies(), CountOtherDBBackends(), CreateDatabaseUsingFileCopy(), CreateDatabaseUsingWalLog(), createdb_failure_callback(), CREATEDB_FILE_COPY, CREATEDB_WAL_LOG, CStringGetDatum(), CStringGetTextDatum, database_is_invalid_oid(), DATCONNLIMIT_UNLIMITED, dbname, defGetBoolean(), defGetInt32(), defGetObjectId(), defGetString(), DirectFunctionCall1, directory_is_empty(), elog, encoding, ereport, errcode(), errdetail(), errdetail_busy_db(), errhint(), errmsg(), ERROR, errorConflictingDefElem(), fb(), FirstNormalObjectId, ForceSyncCommit(), get_collation_actual_version(), get_database_name(), get_database_oid(), get_db_info(), get_role_oid(), get_tablespace_oid(), GetDatabasePath(), GetNewOidWithIndex(), GetUserId(), have_createdb_privilege(), heap_form_tuple(), icu_language_tag(), icu_validate_locale(), icu_validation_level, Int32GetDatum(), InvalidMultiXactId, InvalidOid, InvalidTransactionId, InvokeObjectPostCreateHook, is_encoding_supported_by_icu(), IsA, IsBinaryUpgrade, IsUnderPostmaster, lfirst, LockSharedObject(), namein(), NoLock, NOTICE, object_aclcheck(), object_ownercheck(), OBJECT_TABLESPACE, ObjectIdGetDatum(), OidIsValid, parser_errposition(), pfree(), pg_encoding_to_char, PG_END_ENSURE_ERROR_CLEANUP, PG_ENSURE_ERROR_CLEANUP, pg_strcasecmp(), PG_VALID_BE_ENCODING, pg_valid_server_encoding, PointerGetDatum(), quote_identifier(), recordDependencyOnOwner(), RelationGetDescr, RowExclusiveLock, S_ISDIR, ShareLock, stat::st_mode, stat, stmt, table_close(), table_open(), TransactionIdGetDatum(), and WARNING.

Referenced by CreateRole(), main(), and standard_ProcessUtility().

DropDatabase()

void DropDatabase ( ParseState *  pstate, DropdbStmt *  stmt  )

extern

Definition at line 2343 of file dbcommands.c.

{
    bool        force = false;
    ListCell   *lc;
 
    foreach(lc, stmt->options)
    {
        DefElem    *opt = (DefElem *) lfirst(lc);
 
        if (strcmp(opt->defname, "force") == 0)
            force = true;
        else
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("unrecognized %s option \"%s\"",
                            "DROP DATABASE", opt->defname),
                     parser_errposition(pstate, opt->location)));
    }
 
    dropdb(stmt->dbname, stmt->missing_ok, force);
}

References DefElem::defname, dropdb(), ereport, errcode(), errmsg(), ERROR, fb(), lfirst, DefElem::location, parser_errposition(), and stmt.

Referenced by standard_ProcessUtility().

dropdb()

void dropdb ( const char *  dbname, bool  missing_ok, bool  force  )

extern

Definition at line 1674 of file dbcommands.c.

{
    Oid         db_id;
    bool        db_istemplate;
    Relation    pgdbrel;
    HeapTuple   tup;
    ScanKeyData scankey;
    void       *inplace_state;
    Form_pg_database datform;
    int         notherbackends;
    int         npreparedxacts;
    int         nslots,
                nslots_active;
    int         nsubscriptions;
 
    /*
     * Look up the target database's OID, and get exclusive lock on it. We
     * need this to ensure that no new backend starts up in the target
     * database while we are deleting it (see postinit.c), and that no one is
     * using it as a CREATE DATABASE template or trying to delete it for
     * themselves.
     */
    pgdbrel = table_open(DatabaseRelationId, RowExclusiveLock);
 
    if (!get_db_info(dbname, AccessExclusiveLock, &db_id, NULL, NULL,
                     &db_istemplate, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL))
    {
        if (!missing_ok)
        {
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_DATABASE),
                     errmsg("database \"%s\" does not exist", dbname)));
        }
        else
        {
            /* Close pg_database, release the lock, since we changed nothing */
            table_close(pgdbrel, RowExclusiveLock);
            ereport(NOTICE,
                    (errmsg("database \"%s\" does not exist, skipping",
                            dbname)));
            return;
        }
    }
 
    /*
     * Permission checks
     */
    if (!object_ownercheck(DatabaseRelationId, db_id, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_DATABASE,
                       dbname);
 
    /* DROP hook for the database being removed */
    InvokeObjectDropHook(DatabaseRelationId, db_id, 0);
 
    /*
     * Disallow dropping a DB that is marked istemplate.  This is just to
     * prevent people from accidentally dropping template0 or template1; they
     * can do so if they're really determined ...
     */
    if (db_istemplate)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot drop a template database")));
 
    /* Obviously can't drop my own database */
    if (db_id == MyDatabaseId)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_IN_USE),
                 errmsg("cannot drop the currently open database")));
 
    /*
     * Check whether there are active logical slots that refer to the
     * to-be-dropped database. The database lock we are holding prevents the
     * creation of new slots using the database or existing slots becoming
     * active.
     */
    (void) ReplicationSlotsCountDBSlots(db_id, &nslots, &nslots_active);
    if (nslots_active)
    {
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_IN_USE),
                 errmsg("database \"%s\" is used by an active logical replication slot",
                        dbname),
                 errdetail_plural("There is %d active slot.",
                                  "There are %d active slots.",
                                  nslots_active, nslots_active)));
    }
 
    /*
     * Check if there are subscriptions defined in the target database.
     *
     * We can't drop them automatically because they might be holding
     * resources in other databases/instances.
     */
    if ((nsubscriptions = CountDBSubscriptions(db_id)) > 0)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_IN_USE),
                 errmsg("database \"%s\" is being used by logical replication subscription",
                        dbname),
                 errdetail_plural("There is %d subscription.",
                                  "There are %d subscriptions.",
                                  nsubscriptions, nsubscriptions)));
 
 
    /*
     * Attempt to terminate all existing connections to the target database if
     * the user has requested to do so.
     */
    if (force)
        TerminateOtherDBBackends(db_id);
 
    /*
     * Check for other backends in the target database.  (Because we hold the
     * database lock, no new ones can start after this.)
     *
     * As in CREATE DATABASE, check this after other error conditions.
     */
    if (CountOtherDBBackends(db_id, &notherbackends, &npreparedxacts))
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_IN_USE),
                 errmsg("database \"%s\" is being accessed by other users",
                        dbname),
                 errdetail_busy_db(notherbackends, npreparedxacts)));
 
    /*
     * Delete any comments or security labels associated with the database.
     */
    DeleteSharedComments(db_id, DatabaseRelationId);
    DeleteSharedSecurityLabel(db_id, DatabaseRelationId);
 
    /*
     * Remove settings associated with this database
     */
    DropSetting(db_id, InvalidOid);
 
    /*
     * Remove shared dependency references for the database.
     */
    dropDatabaseDependencies(db_id);
 
    /*
     * Tell the cumulative stats system to forget it immediately, too.
     */
    pgstat_drop_database(db_id);
 
    /*
     * Except for the deletion of the catalog row, subsequent actions are not
     * transactional (consider DropDatabaseBuffers() discarding modified
     * buffers). But we might crash or get interrupted below. To prevent
     * accesses to a database with invalid contents, mark the database as
     * invalid using an in-place update.
     *
     * We need to flush the WAL before continuing, to guarantee the
     * modification is durable before performing irreversible filesystem
     * operations.
     */
    ScanKeyInit(&scankey,
                Anum_pg_database_datname,
                BTEqualStrategyNumber, F_NAMEEQ,
                CStringGetDatum(dbname));
    systable_inplace_update_begin(pgdbrel, DatabaseNameIndexId, true,
                                  NULL, 1, &scankey, &tup, &inplace_state);
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for database %u", db_id);
    datform = (Form_pg_database) GETSTRUCT(tup);
    datform->datconnlimit = DATCONNLIMIT_INVALID_DB;
    systable_inplace_update_finish(inplace_state, tup);
    XLogFlush(XactLastRecEnd);
 
    /*
     * Also delete the tuple - transactionally. If this transaction commits,
     * the row will be gone, but if we fail, dropdb() can be invoked again.
     */
    CatalogTupleDelete(pgdbrel, &tup->t_self);
    heap_freetuple(tup);
 
    /*
     * Drop db-specific replication slots.
     */
    ReplicationSlotsDropDBSlots(db_id);
 
    /*
     * Drop pages for this database that are in the shared buffer cache. This
     * is important to ensure that no remaining backend tries to write out a
     * dirty buffer to the dead database later...
     */
    DropDatabaseBuffers(db_id);
 
    /*
     * Tell checkpointer to forget any pending fsync and unlink requests for
     * files in the database; else the fsyncs will fail at next checkpoint, or
     * worse, it will delete files that belong to a newly created database
     * with the same OID.
     */
    ForgetDatabaseSyncRequests(db_id);
 
    /*
     * Force a checkpoint to make sure the checkpointer has received the
     * message sent by ForgetDatabaseSyncRequests.
     */
    RequestCheckpoint(CHECKPOINT_FAST | CHECKPOINT_FORCE | CHECKPOINT_WAIT);
 
    /* Close all smgr fds in all backends. */
    WaitForProcSignalBarrier(EmitProcSignalBarrier(PROCSIGNAL_BARRIER_SMGRRELEASE));
 
    /*
     * Remove all tablespace subdirs belonging to the database.
     */
    remove_dbtablespaces(db_id);
 
    /*
     * Close pg_database, but keep lock till commit.
     */
    table_close(pgdbrel, NoLock);
 
    /*
     * Force synchronous commit, thus minimizing the window between removal of
     * the database files and committal of the transaction. If we crash before
     * committing, we'll have a DB that's gone on disk but still there
     * according to pg_database, which is not good.
     */
    ForceSyncCommit();
}

References AccessExclusiveLock, aclcheck_error(), ACLCHECK_NOT_OWNER, BTEqualStrategyNumber, CatalogTupleDelete(), CHECKPOINT_FAST, CHECKPOINT_FORCE, CHECKPOINT_WAIT, CountDBSubscriptions(), CountOtherDBBackends(), CStringGetDatum(), DATCONNLIMIT_INVALID_DB, dbname, DeleteSharedComments(), DeleteSharedSecurityLabel(), DropDatabaseBuffers(), dropDatabaseDependencies(), DropSetting(), elog, EmitProcSignalBarrier(), ereport, errcode(), errdetail_busy_db(), errdetail_plural(), errmsg(), ERROR, fb(), ForceSyncCommit(), ForgetDatabaseSyncRequests(), get_db_info(), GETSTRUCT(), GetUserId(), heap_freetuple(), HeapTupleIsValid, InvalidOid, InvokeObjectDropHook, MyDatabaseId, NoLock, NOTICE, OBJECT_DATABASE, object_ownercheck(), pgstat_drop_database(), PROCSIGNAL_BARRIER_SMGRRELEASE, remove_dbtablespaces(), ReplicationSlotsCountDBSlots(), ReplicationSlotsDropDBSlots(), RequestCheckpoint(), RowExclusiveLock, ScanKeyInit(), systable_inplace_update_begin(), systable_inplace_update_finish(), table_close(), table_open(), TerminateOtherDBBackends(), WaitForProcSignalBarrier(), XactLastRecEnd, and XLogFlush().

Referenced by DropDatabase().

have_createdb_privilege()

bool have_createdb_privilege ( void  )

extern

Definition at line 2980 of file dbcommands.c.

{
    bool        result = false;
    HeapTuple   utup;
 
    /* Superusers can always do everything */
    if (superuser())
        return true;
 
    utup = SearchSysCache1(AUTHOID, ObjectIdGetDatum(GetUserId()));
    if (HeapTupleIsValid(utup))
    {
        result = ((Form_pg_authid) GETSTRUCT(utup))->rolcreatedb;
        ReleaseSysCache(utup);
    }
    return result;
}

References fb(), GETSTRUCT(), GetUserId(), HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), rolcreatedb, SearchSysCache1(), and superuser().

Referenced by AlterDatabaseOwner(), AlterRole(), createdb(), CreateRole(), and RenameDatabase().

RenameDatabase()

ObjectAddress RenameDatabase ( const char *  oldname, const char *  newname  )

extern

Definition at line 1903 of file dbcommands.c.

{
    Oid         db_id;
    HeapTuple   newtup;
    ItemPointerData otid;
    Relation    rel;
    int         notherbackends;
    int         npreparedxacts;
    ObjectAddress address;
 
    /*
     * Look up the target database's OID, and get exclusive lock on it. We
     * need this for the same reasons as DROP DATABASE.
     */
    rel = table_open(DatabaseRelationId, RowExclusiveLock);
 
    if (!get_db_info(oldname, AccessExclusiveLock, &db_id, NULL, NULL, NULL,
                     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_DATABASE),
                 errmsg("database \"%s\" does not exist", oldname)));
 
    /* must be owner */
    if (!object_ownercheck(DatabaseRelationId, db_id, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_DATABASE,
                       oldname);
 
    /* must have createdb rights */
    if (!have_createdb_privilege())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to rename database")));
 
    /*
     * If built with appropriate switch, whine when regression-testing
     * conventions for database names are violated.
     */
#ifdef ENFORCE_REGRESSION_TEST_NAME_RESTRICTIONS
    if (strstr(newname, "regression") == NULL)
        elog(WARNING, "databases created by regression test cases should have names including \"regression\"");
#endif
 
    /*
     * Make sure the new name doesn't exist.  See notes for same error in
     * CREATE DATABASE.
     */
    if (OidIsValid(get_database_oid(newname, true)))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_DATABASE),
                 errmsg("database \"%s\" already exists", newname)));
 
    /*
     * XXX Client applications probably store the current database somewhere,
     * so renaming it could cause confusion.  On the other hand, there may not
     * be an actual problem besides a little confusion, so think about this
     * and decide.
     */
    if (db_id == MyDatabaseId)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("current database cannot be renamed")));
 
    /*
     * Make sure the database does not have active sessions.  This is the same
     * concern as above, but applied to other sessions.
     *
     * As in CREATE DATABASE, check this after other error conditions.
     */
    if (CountOtherDBBackends(db_id, &notherbackends, &npreparedxacts))
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_IN_USE),
                 errmsg("database \"%s\" is being accessed by other users",
                        oldname),
                 errdetail_busy_db(notherbackends, npreparedxacts)));
 
    /* rename */
    newtup = SearchSysCacheLockedCopy1(DATABASEOID, ObjectIdGetDatum(db_id));
    if (!HeapTupleIsValid(newtup))
        elog(ERROR, "cache lookup failed for database %u", db_id);
    otid = newtup->t_self;
    namestrcpy(&(((Form_pg_database) GETSTRUCT(newtup))->datname), newname);
    CatalogTupleUpdate(rel, &otid, newtup);
    UnlockTuple(rel, &otid, InplaceUpdateTupleLock);
 
    InvokeObjectPostAlterHook(DatabaseRelationId, db_id, 0);
 
    ObjectAddressSet(address, DatabaseRelationId, db_id);
 
    /*
     * Close pg_database, but keep lock till commit.
     */
    table_close(rel, NoLock);
 
    return address;
}

References AccessExclusiveLock, aclcheck_error(), ACLCHECK_NOT_OWNER, CatalogTupleUpdate(), CountOtherDBBackends(), datname, elog, ereport, errcode(), errdetail_busy_db(), errmsg(), ERROR, fb(), get_database_oid(), get_db_info(), GETSTRUCT(), GetUserId(), have_createdb_privilege(), HeapTupleIsValid, InplaceUpdateTupleLock, InvokeObjectPostAlterHook, MyDatabaseId, namestrcpy(), NoLock, OBJECT_DATABASE, object_ownercheck(), ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, RowExclusiveLock, SearchSysCacheLockedCopy1(), table_close(), table_open(), UnlockTuple(), and WARNING.

Referenced by ExecRenameStmt().