LCOV - code coverage report
Current view: top level - src/backend/access/table - table.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17beta1 Lines: 27 28 96.4 %
Date: 2024-05-29 11:10:47 Functions: 6 6 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * table.c
       4             :  *    Generic routines for table related code.
       5             :  *
       6             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/access/table/table.c
      12             :  *
      13             :  *
      14             :  * NOTES
      15             :  *    This file contains table_ routines that implement access to tables (in
      16             :  *    contrast to other relation types like indexes) that are independent of
      17             :  *    individual table access methods.
      18             :  *
      19             :  *-------------------------------------------------------------------------
      20             :  */
      21             : 
      22             : #include "postgres.h"
      23             : 
      24             : #include "access/relation.h"
      25             : #include "access/table.h"
      26             : #include "utils/rel.h"
      27             : 
      28             : static inline void validate_relation_kind(Relation r);
      29             : 
      30             : /* ----------------
      31             :  *      table_open - open a table relation by relation OID
      32             :  *
      33             :  *      This is essentially relation_open plus check that the relation
      34             :  *      is not an index nor a composite type.  (The caller should also
      35             :  *      check that it's not a view or foreign table before assuming it has
      36             :  *      storage.)
      37             :  * ----------------
      38             :  */
      39             : Relation
      40    14391430 : table_open(Oid relationId, LOCKMODE lockmode)
      41             : {
      42             :     Relation    r;
      43             : 
      44    14391430 :     r = relation_open(relationId, lockmode);
      45             : 
      46    14391420 :     validate_relation_kind(r);
      47             : 
      48    14391420 :     return r;
      49             : }
      50             : 
      51             : 
      52             : /* ----------------
      53             :  *      try_table_open - open a table relation by relation OID
      54             :  *
      55             :  *      Same as table_open, except return NULL instead of failing
      56             :  *      if the relation does not exist.
      57             :  * ----------------
      58             :  */
      59             : Relation
      60      300354 : try_table_open(Oid relationId, LOCKMODE lockmode)
      61             : {
      62             :     Relation    r;
      63             : 
      64      300354 :     r = try_relation_open(relationId, lockmode);
      65             : 
      66             :     /* leave if table does not exist */
      67      300354 :     if (!r)
      68           0 :         return NULL;
      69             : 
      70      300354 :     validate_relation_kind(r);
      71             : 
      72      300354 :     return r;
      73             : }
      74             : 
      75             : /* ----------------
      76             :  *      table_openrv - open a table relation specified
      77             :  *      by a RangeVar node
      78             :  *
      79             :  *      As above, but relation is specified by a RangeVar.
      80             :  * ----------------
      81             :  */
      82             : Relation
      83       27872 : table_openrv(const RangeVar *relation, LOCKMODE lockmode)
      84             : {
      85             :     Relation    r;
      86             : 
      87       27872 :     r = relation_openrv(relation, lockmode);
      88             : 
      89       27852 :     validate_relation_kind(r);
      90             : 
      91       27846 :     return r;
      92             : }
      93             : 
      94             : /* ----------------
      95             :  *      table_openrv_extended - open a table relation specified
      96             :  *      by a RangeVar node
      97             :  *
      98             :  *      As above, but optionally return NULL instead of failing for
      99             :  *      relation-not-found.
     100             :  * ----------------
     101             :  */
     102             : Relation
     103      414338 : table_openrv_extended(const RangeVar *relation, LOCKMODE lockmode,
     104             :                       bool missing_ok)
     105             : {
     106             :     Relation    r;
     107             : 
     108      414338 :     r = relation_openrv_extended(relation, lockmode, missing_ok);
     109             : 
     110      414204 :     if (r)
     111      413970 :         validate_relation_kind(r);
     112             : 
     113      414204 :     return r;
     114             : }
     115             : 
     116             : /* ----------------
     117             :  *      table_close - close a table
     118             :  *
     119             :  *      If lockmode is not "NoLock", we then release the specified lock.
     120             :  *
     121             :  *      Note that it is often sensible to hold a lock beyond relation_close;
     122             :  *      in that case, the lock is released automatically at xact end.
     123             :  *      ----------------
     124             :  */
     125             : void
     126    15206676 : table_close(Relation relation, LOCKMODE lockmode)
     127             : {
     128    15206676 :     relation_close(relation, lockmode);
     129    15206676 : }
     130             : 
     131             : /* ----------------
     132             :  *      validate_relation_kind - check the relation's kind
     133             :  *
     134             :  *      Make sure relkind is not index or composite type
     135             :  * ----------------
     136             :  */
     137             : static inline void
     138    15133596 : validate_relation_kind(Relation r)
     139             : {
     140    15133596 :     if (r->rd_rel->relkind == RELKIND_INDEX ||
     141    15133590 :         r->rd_rel->relkind == RELKIND_PARTITIONED_INDEX ||
     142    15133590 :         r->rd_rel->relkind == RELKIND_COMPOSITE_TYPE)
     143           6 :         ereport(ERROR,
     144             :                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
     145             :                  errmsg("cannot open relation \"%s\"",
     146             :                         RelationGetRelationName(r)),
     147             :                  errdetail_relkind_not_supported(r->rd_rel->relkind)));
     148    15133590 : }

Generated by: LCOV version 1.14