LCOV - differential code coverage report
Current view: top level - src/backend/catalog - pg_namespace.c (source / functions) Coverage Total Hit UBC CBC
Current: Differential Code Coverage HEAD vs 15 Lines: 97.1 % 34 33 1 33
Current Date: 2023-04-08 17:13:01 Functions: 100.0 % 1 1 1
Baseline: 15 Line coverage date bins:
Baseline Date: 2023-04-08 15:09:40 (240..) days: 97.1 % 34 33 1 33
Legend: Lines: hit not hit Function coverage date bins:
(240..) days: 100.0 % 1 1 1

 Age         Owner                  TLA  Line data    Source code
                                  1                 : /*-------------------------------------------------------------------------
                                  2                 :  *
                                  3                 :  * pg_namespace.c
                                  4                 :  *    routines to support manipulation of the pg_namespace relation
                                  5                 :  *
                                  6                 :  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
                                  7                 :  * Portions Copyright (c) 1994, Regents of the University of California
                                  8                 :  *
                                  9                 :  *
                                 10                 :  * IDENTIFICATION
                                 11                 :  *    src/backend/catalog/pg_namespace.c
                                 12                 :  *
                                 13                 :  *-------------------------------------------------------------------------
                                 14                 :  */
                                 15                 : #include "postgres.h"
                                 16                 : 
                                 17                 : #include "access/htup_details.h"
                                 18                 : #include "access/table.h"
                                 19                 : #include "catalog/catalog.h"
                                 20                 : #include "catalog/dependency.h"
                                 21                 : #include "catalog/indexing.h"
                                 22                 : #include "catalog/objectaccess.h"
                                 23                 : #include "catalog/pg_namespace.h"
                                 24                 : #include "utils/builtins.h"
                                 25                 : #include "utils/rel.h"
                                 26                 : #include "utils/syscache.h"
                                 27                 : 
                                 28                 : 
                                 29                 : /* ----------------
                                 30                 :  * NamespaceCreate
                                 31                 :  *
                                 32                 :  * Create a namespace (schema) with the given name and owner OID.
                                 33                 :  *
                                 34                 :  * If isTemp is true, this schema is a per-backend schema for holding
                                 35                 :  * temporary tables.  Currently, it is used to prevent it from being
                                 36                 :  * linked as a member of any active extension.  (If someone does CREATE
                                 37                 :  * TEMP TABLE in an extension script, we don't want the temp schema to
                                 38                 :  * become part of the extension). And to avoid checking for default ACL
                                 39                 :  * for temp namespace (as it is not necessary).
                                 40                 :  * ---------------
                                 41                 :  */
                                 42                 : Oid
 4049 tgl                        43 CBC         822 : NamespaceCreate(const char *nspName, Oid ownerId, bool isTemp)
                                 44                 : {
                                 45                 :     Relation    nspdesc;
                                 46                 :     HeapTuple   tup;
                                 47                 :     Oid         nspoid;
                                 48                 :     bool        nulls[Natts_pg_namespace];
                                 49                 :     Datum       values[Natts_pg_namespace];
                                 50                 :     NameData    nname;
                                 51                 :     TupleDesc   tupDesc;
                                 52                 :     ObjectAddress myself;
                                 53                 :     int         i;
                                 54                 :     Acl        *nspacl;
                                 55                 : 
                                 56                 :     /* sanity checks */
 7688                            57             822 :     if (!nspName)
 7688 tgl                        58 UBC           0 :         elog(ERROR, "no namespace name supplied");
                                 59                 : 
                                 60                 :     /* make sure there is no existing namespace of same name */
 4802 rhaas                      61 CBC         822 :     if (SearchSysCacheExists1(NAMESPACENAME, PointerGetDatum(nspName)))
 7202 tgl                        62               3 :         ereport(ERROR,
                                 63                 :                 (errcode(ERRCODE_DUPLICATE_SCHEMA),
                                 64                 :                  errmsg("schema \"%s\" already exists", nspName)));
                                 65                 : 
 2203 teodor                     66             819 :     if (!isTemp)
 2006 peter_e                    67             649 :         nspacl = get_user_default_acl(OBJECT_SCHEMA, ownerId,
                                 68                 :                                       InvalidOid);
                                 69                 :     else
 2203 teodor                     70             170 :         nspacl = NULL;
                                 71                 : 
 1539 andres                     72             819 :     nspdesc = table_open(NamespaceRelationId, RowExclusiveLock);
 1601                            73             819 :     tupDesc = nspdesc->rd_att;
                                 74                 : 
                                 75                 :     /* initialize nulls and values */
 7688 tgl                        76            4095 :     for (i = 0; i < Natts_pg_namespace; i++)
                                 77                 :     {
 5271                            78            3276 :         nulls[i] = false;
 7688                            79            3276 :         values[i] = (Datum) NULL;
                                 80                 :     }
                                 81                 : 
 1601 andres                     82             819 :     nspoid = GetNewOidWithIndex(nspdesc, NamespaceOidIndexId,
                                 83                 :                                 Anum_pg_namespace_oid);
                                 84             819 :     values[Anum_pg_namespace_oid - 1] = ObjectIdGetDatum(nspoid);
 7688 tgl                        85             819 :     namestrcpy(&nname, nspName);
                                 86             819 :     values[Anum_pg_namespace_nspname - 1] = NameGetDatum(&nname);
 6494                            87             819 :     values[Anum_pg_namespace_nspowner - 1] = ObjectIdGetDatum(ownerId);
 2203 teodor                     88             819 :     if (nspacl != NULL)
                                 89               6 :         values[Anum_pg_namespace_nspacl - 1] = PointerGetDatum(nspacl);
                                 90                 :     else
                                 91             813 :         nulls[Anum_pg_namespace_nspacl - 1] = true;
                                 92                 : 
                                 93                 : 
 5271 tgl                        94             819 :     tup = heap_form_tuple(tupDesc, values, nulls);
                                 95                 : 
 1601 andres                     96             819 :     CatalogTupleInsert(nspdesc, tup);
 7628 tgl                        97             819 :     Assert(OidIsValid(nspoid));
                                 98                 : 
 1539 andres                     99             819 :     table_close(nspdesc, RowExclusiveLock);
                                100                 : 
                                101                 :     /* Record dependencies */
 4443 tgl                       102             819 :     myself.classId = NamespaceRelationId;
                                103             819 :     myself.objectId = nspoid;
                                104             819 :     myself.objectSubId = 0;
                                105                 : 
                                106                 :     /* dependency on owner */
 6485                           107             819 :     recordDependencyOnOwner(NamespaceRelationId, nspoid, ownerId);
                                108                 : 
                                109                 :     /* dependencies on roles mentioned in default ACL */
 1612                           110             819 :     recordDependencyOnNewAcl(NamespaceRelationId, nspoid, 0, ownerId, nspacl);
                                111                 : 
                                112                 :     /* dependency on extension ... but not for magic temp schemas */
 4049                           113             819 :     if (!isTemp)
                                114             649 :         recordDependencyOnCurrentExtension(&myself, false);
                                115                 : 
                                116                 :     /* Post creation hook for new schema */
 3686 rhaas                     117             819 :     InvokeObjectPostCreateHook(NamespaceRelationId, nspoid, 0);
                                118                 : 
 7688 tgl                       119             819 :     return nspoid;
                                120                 : }
        

Generated by: LCOV version v1.16-55-g56c0a2a