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           64 : ParameterAclLookup(const char *parameter, bool missing_ok)
      37              : {
      38              :     Oid         oid;
      39              :     char       *parname;
      40              : 
      41              :     /* Convert name to the form it should have in pg_parameter_acl... */
      42           64 :     parname = convert_GUC_name_for_parameter_acl(parameter);
      43              : 
      44              :     /* ... and look it up */
      45           64 :     oid = GetSysCacheOid1(PARAMETERACLNAME, Anum_pg_parameter_acl_oid,
      46              :                           PointerGetDatum(cstring_to_text(parname)));
      47              : 
      48           64 :     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           64 :     pfree(parname);
      54              : 
      55           64 :     return oid;
      56              : }
      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           34 : ParameterAclCreate(const char *parameter)
      70              : {
      71              :     Oid         parameterId;
      72              :     char       *parname;
      73              :     Relation    rel;
      74              :     TupleDesc   tupDesc;
      75              :     HeapTuple   tuple;
      76           34 :     Datum       values[Natts_pg_parameter_acl] = {0};
      77           34 :     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           34 :     check_GUC_name_for_parameter_acl(parameter);
      84              : 
      85              :     /* Convert name to the form it should have in pg_parameter_acl. */
      86           33 :     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           33 :     rel = table_open(ParameterAclRelationId, RowExclusiveLock);
      95           33 :     tupDesc = RelationGetDescr(rel);
      96           33 :     parameterId = GetNewOidWithIndex(rel,
      97              :                                      ParameterAclOidIndexId,
      98              :                                      Anum_pg_parameter_acl_oid);
      99           33 :     values[Anum_pg_parameter_acl_oid - 1] = ObjectIdGetDatum(parameterId);
     100           33 :     values[Anum_pg_parameter_acl_parname - 1] =
     101           33 :         PointerGetDatum(cstring_to_text(parname));
     102           33 :     nulls[Anum_pg_parameter_acl_paracl - 1] = true;
     103           33 :     tuple = heap_form_tuple(tupDesc, values, nulls);
     104           33 :     CatalogTupleInsert(rel, tuple);
     105              : 
     106              :     /* Close pg_parameter_acl, but keep lock till commit. */
     107           33 :     heap_freetuple(tuple);
     108           33 :     table_close(rel, NoLock);
     109              : 
     110           33 :     return parameterId;
     111              : }