Line data    Source code

       1              : /*-------------------------------------------------------------------------
       2              :  *
       3              :  * table.c
       4              :  *    Generic routines for table related code.
       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/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_as_table(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     11019075 : table_open(Oid relationId, LOCKMODE lockmode)
      41              : {
      42              :     Relation    r;
      43              : 
      44     11019075 :     r = relation_open(relationId, lockmode);
      45              : 
      46     11019070 :     validate_relation_as_table(r);
      47              : 
      48     11019070 :     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       167821 : try_table_open(Oid relationId, LOCKMODE lockmode)
      61              : {
      62              :     Relation    r;
      63              : 
      64       167821 :     r = try_relation_open(relationId, lockmode);
      65              : 
      66              :     /* leave if table does not exist */
      67       167821 :     if (!r)
      68            0 :         return NULL;
      69              : 
      70       167821 :     validate_relation_as_table(r);
      71              : 
      72       167821 :     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        16628 : table_openrv(const RangeVar *relation, LOCKMODE lockmode)
      84              : {
      85              :     Relation    r;
      86              : 
      87        16628 :     r = relation_openrv(relation, lockmode);
      88              : 
      89        16612 :     validate_relation_as_table(r);
      90              : 
      91        16609 :     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       255211 : table_openrv_extended(const RangeVar *relation, LOCKMODE lockmode,
     104              :                       bool missing_ok)
     105              : {
     106              :     Relation    r;
     107              : 
     108       255211 :     r = relation_openrv_extended(relation, lockmode, missing_ok);
     109              : 
     110       255144 :     if (r)
     111       255030 :         validate_relation_as_table(r);
     112              : 
     113       255144 :     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     11501708 : table_close(Relation relation, LOCKMODE lockmode)
     127              : {
     128     11501708 :     relation_close(relation, lockmode);
     129     11501708 : }
     130              : 
     131              : /* ----------------
     132              :  *      validate_relation_as_table
     133              :  *
     134              :  *      Make sure relkind is table-like, that is, something that could be read
     135              :  *      from or written to directly in a query.
     136              :  * ----------------
     137              :  */
     138              : static inline void
     139     11458533 : validate_relation_as_table(Relation r)
     140              : {
     141     11458533 :     if (r->rd_rel->relkind != RELKIND_RELATION &&
     142       213057 :         r->rd_rel->relkind != RELKIND_SEQUENCE &&
     143       212929 :         r->rd_rel->relkind != RELKIND_TOASTVALUE &&
     144       152277 :         r->rd_rel->relkind != RELKIND_VIEW &&
     145       111861 :         r->rd_rel->relkind != RELKIND_MATVIEW &&
     146       107812 :         r->rd_rel->relkind != RELKIND_FOREIGN_TABLE &&
     147        94733 :         r->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
     148            3 :         ereport(ERROR,
     149              :                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
     150              :                  errmsg("cannot open relation \"%s\"",
     151              :                         RelationGetRelationName(r)),
     152              :                  errdetail_relkind_not_supported(r->rd_rel->relkind)));
     153     11458530 : }