F.22. pageinspect

get_raw_page lit le bloc spécifié de la relation nommée et renvoie une copie en tant que valeur de type bytea. Ceci permet la récupération de la copie cohérente à un instant t d'un bloc spécifique. fork devrait être 'main' pour les données, et 'fsm' pour la carte des espaces libres, 'vm' pour la carte de visibilité ou 'init'.

Une version raccourcie de get_raw_page, pour le lire que la partie des données. Équivalent à get_raw_page(relname, 'main', blkno).

page_header affiche les champs communs à toutes les pages des tables et index PostgreSQL™.

L'image d'une page obtenu avec get_raw_page doit être passé en argument. Par exemple :

test=# SELECT * FROM page_header(get_raw_page('pg_class', 0));
    lsn    | checksum | flags  | lower | upper | special | pagesize | version | prune_xid
-----------+----------+--------+-------+-------+---------+----------+---------+-----------
 0/24A1B50 |        1 |      1 |   232 |   368 |    8192 |     8192 |       4 |         0
     

Les colonnes renvoyées correspondent aux champs de la structure PageHeaderData. Voir src/include/storage/bufpage.h pour les détails.

heap_page_items affiche tous les pointeurs de ligne dans une page de table. Pour les pointeurs de ligne en utilisation, les en-têtes de ligne ainsi que les données des lignes sont aussi affichées. Toutes les lignes sont affichées, qu'elles soient ou non visibles dans l'image MVCC au moment où la page brute a été copiée.

Une image d'une page de table obtenue avec get_raw_page doit être fournie en argument. Par exemple :

test=# SELECT * FROM heap_page_items(get_raw_page('pg_class', 0));
     

Voir src/include/storage/itemid.h et src/include/access/htup_details.h pour des explications sur les champs renvoyés.

tuple_data_split divise les données d'une ligne en attributs de la même façon que le fait le moteur.

test=# SELECT tuple_data_split('pg_class'::regclass, t_data, t_infomask, t_infomask2, t_bits) FROM heap_page_items(get_raw_page('pg_class', 0));

Cette fonction doit être appelée avec les mêmes arguments que ce qui est renvoyé par heap_page_items.

Si do_detoast est true, la donnée TOAST sera traitée. La valeur par défaut est false.

heap_page_item_attrs est équivalent à heap_page_items sauf qu'elle renvoie les données brutes de la ligne sous la forme d'un tableau d'attributs pouvant en option être traités par do_detoast (comportement désactivé par défaut).

Une image de la page HEAP obtenue avec get_raw_page doit être fournie comme argument. Par exemple :

test=# SELECT * FROM heap_page_item_attrs(get_raw_page('pg_class', 0), 'pg_class'::regclass);

bt_metap renvoie des informations sur une méta-page d'un index B-tree. Par exemple :

test=# SELECT * FROM bt_metap('pg_cast_oid_index');
-[ RECORD 1 ]-----
magic     | 340322
version   | 2
root      | 1
level     | 0
fastroot  | 1
fastlevel | 0
     

bt_page_stats renvoie un résumé des informations sur les pages enfants des index B-tree. Par exemple :

test=# SELECT * FROM bt_page_stats('pg_cast_oid_index', 1);
-[ RECORD 1 ]-+-----
blkno         | 1
type          | l
live_items    | 256
dead_items    | 0
avg_item_size | 12
page_size     | 8192
free_size     | 4056
btpo_prev     | 0
btpo_next     | 0
btpo          | 0
btpo_flags    | 3
     

bt_page_items renvoie des informations détaillées sur tous les éléments d'une page d'index btree. Par exemple :

test=# SELECT * FROM bt_page_items('pg_cast_oid_index', 1);
 itemoffset |  ctid   | itemlen | nulls | vars |    data
------------+---------+---------+-------+------+-------------
          1 | (0,1)   |      12 | f     | f    | 23 27 00 00
          2 | (0,2)   |      12 | f     | f    | 24 27 00 00
          3 | (0,3)   |      12 | f     | f    | 25 27 00 00
          4 | (0,4)   |      12 | f     | f    | 26 27 00 00
          5 | (0,5)   |      12 | f     | f    | 27 27 00 00
          6 | (0,6)   |      12 | f     | f    | 28 27 00 00
          7 | (0,7)   |      12 | f     | f    | 29 27 00 00
          8 | (0,8)   |      12 | f     | f    | 2a 27 00 00
     

Dans un bloc feuille d'un index B-tree, ctid pointe vers un enregistrement de la table. Dans une page interne, la partie du numéro de bloc du ctid pointe vers une autre page de l'index lui-même alors que la partie décalage (le deuxième nombre) est ignoré et vaut généralement 1.

Notez que le premier élément une page (autre que la dernière, toute page avec une valeur différente de zéro dans le champ btpo_next) est la « clé haute » du bloc, ce qui signifie que ces données (data) serve comme limite haute de tous les éléments apparaissant sur la page, alors que son champ ctid n'a aucune signification. De plus, sur les blocs qui ne sont pas des feuilles, le premier élément contenant de vraies données (autrement dit le premier élément qui n'est pas une clé haute) est un élément « moins infinité » sans valeur réelle dans son champ data. Néanmoins, un tel élément doit avoir un lien valide dans son champ ctid.

brin_page_type renvoie le type de bloc du bloc indiqué pour l'index BRIN donné ou renvoie une erreur si le bloc n'est pas un bloc valide d'un index BRIN. Par exemple :

test=# SELECT brin_page_type(get_raw_page('brinidx', 0));
 brin_page_type 
----------------
 meta

brin_metapage_info renvoie une information assortie sur la métapage d'un index BRIN. Par exemple :

test=# SELECT * FROM brin_metapage_info(get_raw_page('brinidx', 0));
   magic    | version | pagesperrange | lastrevmappage 
------------+---------+---------------+----------------
 0xA8109CFA |       1 |             4 |              2

brin_revmap_data renvoie la liste des identifiants de lignes dans un bloc de type « range map » d'un index BRIN. Par exemple :

test=# SELECT * FROM brin_revmap_data(get_raw_page('brinidx', 2)) limit 5;
  pages  
---------
 (6,137)
 (6,138)
 (6,139)
 (6,140)
 (6,141)

brin_page_items renvoie les données enregistrées dans le bloc de données de l'index BRIN. Par exemple :

test=# SELECT * FROM brin_page_items(get_raw_page('brinidx', 5),
                                     'brinidx')
       ORDER BY blknum, attnum LIMIT 6;
 itemoffset | blknum | attnum | allnulls | hasnulls | placeholder |    value     
------------+--------+--------+----------+----------+-------------+--------------
        137 |      0 |      1 | t        | f        | f           | 
        137 |      0 |      2 | f        | f        | f           | {1 .. 88}
        138 |      4 |      1 | t        | f        | f           | 
        138 |      4 |      2 | f        | f        | f           | {89 .. 176}
        139 |      8 |      1 | t        | f        | f           | 
        139 |      8 |      2 | f        | f        | f           | {177 .. 264}

Les colonnes renvoyées correspondent aux champs des structures BrinMemTuple et BrinValues. Voir src/include/access/brin_tuple.h pour plus de détails.

gin_metapage_info renvoie des informations sur la métapage d'un index GIN index metapage. Par exemple :

test=# SELECT * FROM gin_metapage_info(get_raw_page('gin_index', 0));
-[ RECORD 1 ]----+-----------
pending_head     | 4294967295
pending_tail     | 4294967295
tail_free_size   | 0
n_pending_pages  | 0
n_pending_tuples | 0
n_total_pages    | 7
n_entry_pages    | 6
n_data_pages     | 0
n_entries        | 693
version          | 2

gin_page_opaque_info renvoie des informations sur la partie opaque d'un index GIN, comme le type de bloc. Par exemple :

test=# SELECT * FROM gin_page_opaque_info(get_raw_page('gin_index', 2));
 rightlink | maxoff |         flags
-----------+--------+------------------------
         5 |      0 | {data,leaf,compressed}
(1 row)

gin_leafpage_items renvoie des informations sur les données enregistrées dans un bloc feuille d'un index GIN. Par exemple :

test=# SELECT first_tid, nbytes, tids[0:5] as some_tids
        FROM gin_leafpage_items(get_raw_page('gin_test_idx', 2));
 first_tid | nbytes |                        some_tids
-----------+--------+----------------------------------------------------------
 (8,41)    |    244 | {"(8,41)","(8,43)","(8,44)","(8,45)","(8,46)"}
 (10,45)   |    248 | {"(10,45)","(10,46)","(10,47)","(10,48)","(10,49)"}
 (12,52)   |    248 | {"(12,52)","(12,53)","(12,54)","(12,55)","(12,56)"}
 (14,59)   |    320 | {"(14,59)","(14,60)","(14,61)","(14,62)","(14,63)"}
 (167,16)  |    376 | {"(167,16)","(167,17)","(167,18)","(167,19)","(167,20)"}
 (170,30)  |    376 | {"(170,30)","(170,31)","(170,32)","(170,33)","(170,34)"}
 (173,44)  |    197 | {"(173,44)","(173,45)","(173,46)","(173,47)","(173,48)"}
(7 rows)

fsm_page_contents affiche la structure interne d'une page FSM. La sortie est une chaîne multi-lignes, chaque ligne décrivant un nœud de l'arbre binaire d'une page. Seuls les nœuds différents de zéro sont affichés. Le pointeur appelé « next », qui pointe vers le prochain slot à renvoyer pour cette page, est aussi affiché.

Voir src/backend/storage/freespace/README pour plus d'informations sur la structure d'une page FSM.