LCOV - code coverage report
Current view: top level - src/backend/catalog - pg_parameter_acl.c (source / functions) Coverage Total Hit
Test: Code coverage Lines: 0.0 % 33 0
Test Date: 2026-01-26 10:56:24 Functions: 0.0 % 2 0
Legend: Lines:     hit not hit
Branches: + taken - not taken # not executed
Branches: 0.0 % 8 0

             Branch data     Line data    Source code
       1                 :             : /*-------------------------------------------------------------------------
       2                 :             :  *
       3                 :             :  * pg_parameter_acl.c
       4                 :             :  *        routines to support manipulation of the pg_parameter_acl relation
       5                 :             :  *
       6                 :             :  * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
       7                 :             :  * Portions Copyright (c) 1994, Regents of the University of California
       8                 :             :  *
       9                 :             :  *
      10                 :             :  * IDENTIFICATION
      11                 :             :  *        src/backend/catalog/pg_parameter_acl.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/indexing.h"
      21                 :             : #include "catalog/pg_parameter_acl.h"
      22                 :             : #include "utils/builtins.h"
      23                 :             : #include "utils/guc.h"
      24                 :             : #include "utils/rel.h"
      25                 :             : #include "utils/syscache.h"
      26                 :             : 
      27                 :             : 
      28                 :             : /*
      29                 :             :  * ParameterAclLookup - Given a configuration parameter name,
      30                 :             :  * look up the associated configuration parameter ACL's OID.
      31                 :             :  *
      32                 :             :  * If missing_ok is false, throw an error if ACL entry not found.  If
      33                 :             :  * true, just return InvalidOid.
      34                 :             :  */
      35                 :             : Oid
      36                 :           0 : ParameterAclLookup(const char *parameter, bool missing_ok)
      37                 :             : {
      38                 :           0 :         Oid                     oid;
      39                 :           0 :         char       *parname;
      40                 :             : 
      41                 :             :         /* Convert name to the form it should have in pg_parameter_acl... */
      42                 :           0 :         parname = convert_GUC_name_for_parameter_acl(parameter);
      43                 :             : 
      44                 :             :         /* ... and look it up */
      45                 :           0 :         oid = GetSysCacheOid1(PARAMETERACLNAME, Anum_pg_parameter_acl_oid,
      46                 :             :                                                   PointerGetDatum(cstring_to_text(parname)));
      47                 :             : 
      48   [ #  #  #  # ]:           0 :         if (!OidIsValid(oid) && !missing_ok)
      49   [ #  #  #  # ]:           0 :                 ereport(ERROR,
      50                 :             :                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
      51                 :             :                                  errmsg("parameter ACL \"%s\" does not exist", parameter)));
      52                 :             : 
      53                 :           0 :         pfree(parname);
      54                 :             : 
      55                 :           0 :         return oid;
      56                 :           0 : }
      57                 :             : 
      58                 :             : /*
      59                 :             :  * ParameterAclCreate
      60                 :             :  *
      61                 :             :  * Add a new tuple to pg_parameter_acl.
      62                 :             :  *
      63                 :             :  * parameter: the parameter name to create an entry for.
      64                 :             :  * Caller should have verified that there's no such entry already.
      65                 :             :  *
      66                 :             :  * Returns the new entry's OID.
      67                 :             :  */
      68                 :             : Oid
      69                 :           0 : ParameterAclCreate(const char *parameter)
      70                 :             : {
      71                 :           0 :         Oid                     parameterId;
      72                 :           0 :         char       *parname;
      73                 :           0 :         Relation        rel;
      74                 :           0 :         TupleDesc       tupDesc;
      75                 :           0 :         HeapTuple       tuple;
      76                 :           0 :         Datum           values[Natts_pg_parameter_acl] = {0};
      77                 :           0 :         bool            nulls[Natts_pg_parameter_acl] = {0};
      78                 :             : 
      79                 :             :         /*
      80                 :             :          * To prevent cluttering pg_parameter_acl with useless entries, insist
      81                 :             :          * that the name be valid.
      82                 :             :          */
      83                 :           0 :         check_GUC_name_for_parameter_acl(parameter);
      84                 :             : 
      85                 :             :         /* Convert name to the form it should have in pg_parameter_acl. */
      86                 :           0 :         parname = convert_GUC_name_for_parameter_acl(parameter);
      87                 :             : 
      88                 :             :         /*
      89                 :             :          * Create and insert a new record containing a null ACL.
      90                 :             :          *
      91                 :             :          * We don't take a strong enough lock to prevent concurrent insertions,
      92                 :             :          * relying instead on the unique index.
      93                 :             :          */
      94                 :           0 :         rel = table_open(ParameterAclRelationId, RowExclusiveLock);
      95                 :           0 :         tupDesc = RelationGetDescr(rel);
      96                 :           0 :         parameterId = GetNewOidWithIndex(rel,
      97                 :             :                                                                          ParameterAclOidIndexId,
      98                 :             :                                                                          Anum_pg_parameter_acl_oid);
      99                 :           0 :         values[Anum_pg_parameter_acl_oid - 1] = ObjectIdGetDatum(parameterId);
     100                 :           0 :         values[Anum_pg_parameter_acl_parname - 1] =
     101                 :           0 :                 PointerGetDatum(cstring_to_text(parname));
     102                 :           0 :         nulls[Anum_pg_parameter_acl_paracl - 1] = true;
     103                 :           0 :         tuple = heap_form_tuple(tupDesc, values, nulls);
     104                 :           0 :         CatalogTupleInsert(rel, tuple);
     105                 :             : 
     106                 :             :         /* Close pg_parameter_acl, but keep lock till commit. */
     107                 :           0 :         heap_freetuple(tuple);
     108                 :           0 :         table_close(rel, NoLock);
     109                 :             : 
     110                 :           0 :         return parameterId;
     111                 :           0 : }
        

Generated by: LCOV version 2.3.2-1