LCOV - code coverage report
Current view: top level - src/include/catalog - index.h (source / functions) Hit Total Coverage
Test: PostgreSQL 15devel Lines: 10 10 100.0 %
Date: 2021-11-29 06:09:26 Functions: 2 2 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * index.h
       4             :  *    prototypes for catalog/index.c.
       5             :  *
       6             :  *
       7             :  * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
       8             :  * Portions Copyright (c) 1994, Regents of the University of California
       9             :  *
      10             :  * src/include/catalog/index.h
      11             :  *
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : #ifndef INDEX_H
      15             : #define INDEX_H
      16             : 
      17             : #include "catalog/objectaddress.h"
      18             : #include "nodes/execnodes.h"
      19             : 
      20             : 
      21             : #define DEFAULT_INDEX_TYPE  "btree"
      22             : 
      23             : /* Action code for index_set_state_flags */
      24             : typedef enum
      25             : {
      26             :     INDEX_CREATE_SET_READY,
      27             :     INDEX_CREATE_SET_VALID,
      28             :     INDEX_DROP_CLEAR_VALID,
      29             :     INDEX_DROP_SET_DEAD
      30             : } IndexStateFlagsAction;
      31             : 
      32             : /* options for REINDEX */
      33             : typedef struct ReindexParams
      34             : {
      35             :     bits32      options;        /* bitmask of REINDEXOPT_* */
      36             :     Oid         tablespaceOid;  /* New tablespace to move indexes to.
      37             :                                  * InvalidOid to do nothing. */
      38             : } ReindexParams;
      39             : 
      40             : /* flag bits for ReindexParams->flags */
      41             : #define REINDEXOPT_VERBOSE      0x01    /* print progress info */
      42             : #define REINDEXOPT_REPORT_PROGRESS 0x02 /* report pgstat progress */
      43             : #define REINDEXOPT_MISSING_OK   0x04    /* skip missing relations */
      44             : #define REINDEXOPT_CONCURRENTLY 0x08    /* concurrent mode */
      45             : 
      46             : /* state info for validate_index bulkdelete callback */
      47             : typedef struct ValidateIndexState
      48             : {
      49             :     Tuplesortstate *tuplesort;  /* for sorting the index TIDs */
      50             :     /* statistics (for debug purposes only): */
      51             :     double      htups,
      52             :                 itups,
      53             :                 tups_inserted;
      54             : } ValidateIndexState;
      55             : 
      56             : extern void index_check_primary_key(Relation heapRel,
      57             :                                     IndexInfo *indexInfo,
      58             :                                     bool is_alter_table,
      59             :                                     IndexStmt *stmt);
      60             : 
      61             : #define INDEX_CREATE_IS_PRIMARY             (1 << 0)
      62             : #define INDEX_CREATE_ADD_CONSTRAINT         (1 << 1)
      63             : #define INDEX_CREATE_SKIP_BUILD             (1 << 2)
      64             : #define INDEX_CREATE_CONCURRENT             (1 << 3)
      65             : #define INDEX_CREATE_IF_NOT_EXISTS          (1 << 4)
      66             : #define INDEX_CREATE_PARTITIONED            (1 << 5)
      67             : #define INDEX_CREATE_INVALID                (1 << 6)
      68             : 
      69             : extern Oid  index_create(Relation heapRelation,
      70             :                          const char *indexRelationName,
      71             :                          Oid indexRelationId,
      72             :                          Oid parentIndexRelid,
      73             :                          Oid parentConstraintId,
      74             :                          Oid relFileNode,
      75             :                          IndexInfo *indexInfo,
      76             :                          List *indexColNames,
      77             :                          Oid accessMethodObjectId,
      78             :                          Oid tableSpaceId,
      79             :                          Oid *collationObjectId,
      80             :                          Oid *classObjectId,
      81             :                          int16 *coloptions,
      82             :                          Datum reloptions,
      83             :                          bits16 flags,
      84             :                          bits16 constr_flags,
      85             :                          bool allow_system_table_mods,
      86             :                          bool is_internal,
      87             :                          Oid *constraintId);
      88             : 
      89             : #define INDEX_CONSTR_CREATE_MARK_AS_PRIMARY (1 << 0)
      90             : #define INDEX_CONSTR_CREATE_DEFERRABLE      (1 << 1)
      91             : #define INDEX_CONSTR_CREATE_INIT_DEFERRED   (1 << 2)
      92             : #define INDEX_CONSTR_CREATE_UPDATE_INDEX    (1 << 3)
      93             : #define INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS (1 << 4)
      94             : 
      95             : extern Oid  index_concurrently_create_copy(Relation heapRelation,
      96             :                                            Oid oldIndexId,
      97             :                                            Oid tablespaceOid,
      98             :                                            const char *newName);
      99             : 
     100             : extern void index_concurrently_build(Oid heapRelationId,
     101             :                                      Oid indexRelationId);
     102             : 
     103             : extern void index_concurrently_swap(Oid newIndexId,
     104             :                                     Oid oldIndexId,
     105             :                                     const char *oldName);
     106             : 
     107             : extern void index_concurrently_set_dead(Oid heapId,
     108             :                                         Oid indexId);
     109             : 
     110             : extern ObjectAddress index_constraint_create(Relation heapRelation,
     111             :                                              Oid indexRelationId,
     112             :                                              Oid parentConstraintId,
     113             :                                              IndexInfo *indexInfo,
     114             :                                              const char *constraintName,
     115             :                                              char constraintType,
     116             :                                              bits16 constr_flags,
     117             :                                              bool allow_system_table_mods,
     118             :                                              bool is_internal);
     119             : 
     120             : extern void index_drop(Oid indexId, bool concurrent, bool concurrent_lock_mode);
     121             : 
     122             : extern IndexInfo *BuildIndexInfo(Relation index);
     123             : 
     124             : extern IndexInfo *BuildDummyIndexInfo(Relation index);
     125             : 
     126             : extern bool CompareIndexInfo(IndexInfo *info1, IndexInfo *info2,
     127             :                              Oid *collations1, Oid *collations2,
     128             :                              Oid *opfamilies1, Oid *opfamilies2,
     129             :                              AttrMap *attmap);
     130             : 
     131             : extern void BuildSpeculativeIndexInfo(Relation index, IndexInfo *ii);
     132             : 
     133             : extern void FormIndexDatum(IndexInfo *indexInfo,
     134             :                            TupleTableSlot *slot,
     135             :                            EState *estate,
     136             :                            Datum *values,
     137             :                            bool *isnull);
     138             : 
     139             : extern void index_build(Relation heapRelation,
     140             :                         Relation indexRelation,
     141             :                         IndexInfo *indexInfo,
     142             :                         bool isreindex,
     143             :                         bool parallel);
     144             : 
     145             : extern void validate_index(Oid heapId, Oid indexId, Snapshot snapshot);
     146             : 
     147             : extern void index_set_state_flags(Oid indexId, IndexStateFlagsAction action);
     148             : 
     149             : extern Oid  IndexGetRelation(Oid indexId, bool missing_ok);
     150             : 
     151             : extern void reindex_index(Oid indexId, bool skip_constraint_checks,
     152             :                           char relpersistence, ReindexParams *params);
     153             : 
     154             : /* Flag bits for reindex_relation(): */
     155             : #define REINDEX_REL_PROCESS_TOAST           0x01
     156             : #define REINDEX_REL_SUPPRESS_INDEX_USE      0x02
     157             : #define REINDEX_REL_CHECK_CONSTRAINTS       0x04
     158             : #define REINDEX_REL_FORCE_INDEXES_UNLOGGED  0x08
     159             : #define REINDEX_REL_FORCE_INDEXES_PERMANENT 0x10
     160             : 
     161             : extern bool reindex_relation(Oid relid, int flags, ReindexParams *params);
     162             : 
     163             : extern bool ReindexIsProcessingHeap(Oid heapOid);
     164             : extern bool ReindexIsProcessingIndex(Oid indexOid);
     165             : 
     166             : extern void ResetReindexState(int nestLevel);
     167             : extern Size EstimateReindexStateSpace(void);
     168             : extern void SerializeReindexState(Size maxsize, char *start_address);
     169             : extern void RestoreReindexState(void *reindexstate);
     170             : 
     171             : extern void IndexSetParentIndex(Relation idx, Oid parentOid);
     172             : 
     173             : 
     174             : /*
     175             :  * itemptr_encode - Encode ItemPointer as int64/int8
     176             :  *
     177             :  * This representation must produce values encoded as int64 that sort in the
     178             :  * same order as their corresponding original TID values would (using the
     179             :  * default int8 opclass to produce a result equivalent to the default TID
     180             :  * opclass).
     181             :  *
     182             :  * As noted in validate_index(), this can be significantly faster.
     183             :  */
     184             : static inline int64
     185    39525340 : itemptr_encode(ItemPointer itemptr)
     186             : {
     187    39525340 :     BlockNumber block = ItemPointerGetBlockNumber(itemptr);
     188    39525340 :     OffsetNumber offset = ItemPointerGetOffsetNumber(itemptr);
     189             :     int64       encoded;
     190             : 
     191             :     /*
     192             :      * Use the 16 least significant bits for the offset.  32 adjacent bits are
     193             :      * used for the block number.  Since remaining bits are unused, there
     194             :      * cannot be negative encoded values (We assume a two's complement
     195             :      * representation).
     196             :      */
     197    39525340 :     encoded = ((uint64) block << 16) | (uint16) offset;
     198             : 
     199    39525340 :     return encoded;
     200             : }
     201             : 
     202             : /*
     203             :  * itemptr_decode - Decode int64/int8 representation back to ItemPointer
     204             :  */
     205             : static inline void
     206       22004 : itemptr_decode(ItemPointer itemptr, int64 encoded)
     207             : {
     208       22004 :     BlockNumber block = (BlockNumber) (encoded >> 16);
     209       22004 :     OffsetNumber offset = (OffsetNumber) (encoded & 0xFFFF);
     210             : 
     211       22004 :     ItemPointerSet(itemptr, block, offset);
     212       22004 : }
     213             : 
     214             : #endif                          /* INDEX_H */

Generated by: LCOV version 1.14