TLA Line data Source code
1 : /*
2 : * contrib/pageinspect/btreefuncs.c
3 : *
4 : *
5 : * btreefuncs.c
6 : *
7 : * Copyright (c) 2006 Satoshi Nagayasu <nagayasus@nttdata.co.jp>
8 : *
9 : * Permission to use, copy, modify, and distribute this software and
10 : * its documentation for any purpose, without fee, and without a
11 : * written agreement is hereby granted, provided that the above
12 : * copyright notice and this paragraph and the following two
13 : * paragraphs appear in all copies.
14 : *
15 : * IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT,
16 : * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
17 : * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
18 : * DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED
19 : * OF THE POSSIBILITY OF SUCH DAMAGE.
20 : *
21 : * THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
22 : * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 : * A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS
24 : * IS" BASIS, AND THE AUTHOR HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE,
25 : * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
26 : */
27 :
28 : #include "postgres.h"
29 :
30 : #include "access/nbtree.h"
31 : #include "access/relation.h"
32 : #include "catalog/namespace.h"
33 : #include "catalog/pg_am.h"
34 : #include "catalog/pg_type.h"
35 : #include "funcapi.h"
36 : #include "miscadmin.h"
37 : #include "pageinspect.h"
38 : #include "utils/array.h"
39 : #include "utils/builtins.h"
40 : #include "utils/rel.h"
41 : #include "utils/varlena.h"
42 :
43 CBC 25 : PG_FUNCTION_INFO_V1(bt_metap);
44 7 : PG_FUNCTION_INFO_V1(bt_page_items_1_9);
45 13 : PG_FUNCTION_INFO_V1(bt_page_items);
46 13 : PG_FUNCTION_INFO_V1(bt_page_items_bytea);
47 7 : PG_FUNCTION_INFO_V1(bt_page_stats_1_9);
48 7 : PG_FUNCTION_INFO_V1(bt_page_stats);
49 GNC 6 : PG_FUNCTION_INFO_V1(bt_multi_page_stats);
50 ECB :
51 : #define IS_INDEX(r) ((r)->rd_rel->relkind == RELKIND_INDEX)
52 : #define IS_BTREE(r) ((r)->rd_rel->relam == BTREE_AM_OID)
53 :
54 : /* ------------------------------------------------
55 : * structure for single btree page statistics
56 : * ------------------------------------------------
57 : */
58 : typedef struct BTPageStat
59 : {
60 : uint32 blkno;
61 : uint32 live_items;
62 : uint32 dead_items;
63 : uint32 page_size;
64 : uint32 max_avail;
65 : uint32 free_size;
66 : uint32 avg_item_size;
67 : char type;
68 :
69 : /* opaque data */
70 : BlockNumber btpo_prev;
71 : BlockNumber btpo_next;
72 : uint32 btpo_level;
73 : uint16 btpo_flags;
74 : BTCycleId btpo_cycleid;
75 : } BTPageStat;
76 :
77 : /*
78 : * cross-call data structure for SRF for page stats
79 : */
80 : typedef struct ua_page_stats
81 : {
82 : Oid relid;
83 : int64 blkno;
84 : int64 blk_count;
85 : bool allpages;
86 : } ua_page_stats;
87 :
88 : /*
89 : * cross-call data structure for SRF for page items
90 : */
91 : typedef struct ua_page_items
92 : {
93 : Page page;
94 : OffsetNumber offset;
95 : bool leafpage;
96 : bool rightmost;
97 : TupleDesc tupd;
98 : } ua_page_items;
99 :
100 :
101 : /* -------------------------------------------------
102 : * GetBTPageStatistics()
103 : *
104 : * Collect statistics of single b-tree page
105 : * -------------------------------------------------
106 : */
107 : static void
108 GIC 10 : GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
109 : {
110 10 : Page page = BufferGetPage(buffer);
111 10 : PageHeader phdr = (PageHeader) page;
112 10 : OffsetNumber maxoff = PageGetMaxOffsetNumber(page);
113 10 : BTPageOpaque opaque = BTPageGetOpaque(page);
114 10 : int item_size = 0;
115 : int off;
116 :
117 10 : stat->blkno = blkno;
118 :
119 10 : stat->max_avail = BLCKSZ - (BLCKSZ - phdr->pd_special + SizeOfPageHeaderData);
120 :
121 10 : stat->dead_items = stat->live_items = 0;
122 :
123 10 : stat->page_size = PageGetPageSize(page);
124 :
125 ECB : /* page type (flags) */
126 GIC 10 : if (P_ISDELETED(opaque))
127 ECB : {
128 : /* We divide deleted pages into leaf ('d') or internal ('D') */
129 LBC 0 : if (P_ISLEAF(opaque) || !P_HAS_FULLXID(opaque))
130 0 : stat->type = 'd';
131 ECB : else
132 UIC 0 : stat->type = 'D';
133 :
134 ECB : /*
135 : * Report safexid in a deleted page.
136 : *
137 : * Handle pg_upgrade'd deleted pages that used the previous safexid
138 : * representation in btpo_level field (this used to be a union type
139 : * called "bpto").
140 : */
141 UIC 0 : if (P_HAS_FULLXID(opaque))
142 : {
143 LBC 0 : FullTransactionId safexid = BTPageGetDeleteXid(page);
144 :
145 UIC 0 : elog(DEBUG2, "deleted page from block %u has safexid %u:%u",
146 EUB : blkno, EpochFromFullTransactionId(safexid),
147 : XidFromFullTransactionId(safexid));
148 : }
149 : else
150 UIC 0 : elog(DEBUG2, "deleted page from block %u has safexid %u",
151 : blkno, opaque->btpo_level);
152 :
153 : /* Don't interpret BTDeletedPageData as index tuples */
154 0 : maxoff = InvalidOffsetNumber;
155 : }
156 GIC 10 : else if (P_IGNORE(opaque))
157 UIC 0 : stat->type = 'e';
158 GBC 10 : else if (P_ISLEAF(opaque))
159 GIC 8 : stat->type = 'l';
160 GBC 2 : else if (P_ISROOT(opaque))
161 GIC 2 : stat->type = 'r';
162 EUB : else
163 UIC 0 : stat->type = 'i';
164 :
165 : /* btpage opaque data */
166 GIC 10 : stat->btpo_prev = opaque->btpo_prev;
167 GBC 10 : stat->btpo_next = opaque->btpo_next;
168 GIC 10 : stat->btpo_level = opaque->btpo_level;
169 10 : stat->btpo_flags = opaque->btpo_flags;
170 10 : stat->btpo_cycleid = opaque->btpo_cycleid;
171 EUB :
172 : /* count live and dead tuples, and free space */
173 CBC 2022 : for (off = FirstOffsetNumber; off <= maxoff; off++)
174 EUB : {
175 ECB : IndexTuple itup;
176 :
177 CBC 2012 : ItemId id = PageGetItemId(page, off);
178 ECB :
179 GIC 2012 : itup = (IndexTuple) PageGetItem(page, id);
180 EUB :
181 GIC 2012 : item_size += IndexTupleSize(itup);
182 :
183 CBC 2012 : if (!ItemIdIsDead(id))
184 2012 : stat->live_items++;
185 ECB : else
186 LBC 0 : stat->dead_items++;
187 ECB : }
188 GIC 10 : stat->free_size = PageGetFreeSpace(page);
189 :
190 CBC 10 : if ((stat->live_items + stat->dead_items) > 0)
191 GIC 10 : stat->avg_item_size = item_size / (stat->live_items + stat->dead_items);
192 : else
193 UIC 0 : stat->avg_item_size = 0;
194 CBC 10 : }
195 :
196 : /* -----------------------------------------------
197 : * check_relation_block_range()
198 : *
199 : * Verify that a block number (given as int64) is valid for the relation.
200 : * -----------------------------------------------
201 : */
202 : static void
203 GNC 15 : check_relation_block_range(Relation rel, int64 blkno)
204 : {
205 : /* Ensure we can cast to BlockNumber */
206 15 : if (blkno < 0 || blkno > MaxBlockNumber)
207 2 : ereport(ERROR,
208 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
209 : errmsg("invalid block number %lld",
210 : (long long) blkno)));
211 :
212 13 : if ((BlockNumber) (blkno) >= RelationGetNumberOfBlocks(rel))
213 3 : ereport(ERROR,
214 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
215 : errmsg("block number %lld is out of range",
216 : (long long) blkno)));
217 10 : }
218 :
219 : /* -----------------------------------------------
220 : * bt_index_block_validate()
221 : *
222 : * Validate index type is btree and block number
223 : * is valid (and not the metapage).
224 : * -----------------------------------------------
225 : */
226 : static void
227 18 : bt_index_block_validate(Relation rel, int64 blkno)
228 : {
229 18 : if (!IS_INDEX(rel) || !IS_BTREE(rel))
230 2 : ereport(ERROR,
231 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
232 : errmsg("\"%s\" is not a %s index",
233 : RelationGetRelationName(rel), "btree")));
234 :
235 : /*
236 : * Reject attempts to read non-local temporary relations; we would be
237 : * likely to get wrong data since we have no visibility into the owning
238 : * session's local buffers.
239 : */
240 16 : if (RELATION_IS_OTHER_TEMP(rel))
241 UNC 0 : ereport(ERROR,
242 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
243 : errmsg("cannot access temporary tables of other sessions")));
244 :
245 GNC 16 : if (blkno == 0)
246 3 : ereport(ERROR,
247 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
248 : errmsg("block 0 is a meta page")));
249 :
250 13 : check_relation_block_range(rel, blkno);
251 8 : }
252 :
253 ECB : /* -----------------------------------------------
254 : * bt_page_stats()
255 : *
256 : * Usage: SELECT * FROM bt_page_stats('t1_pkey', 1);
257 : * Arguments are index relation name and block number
258 : * -----------------------------------------------
259 : */
260 : static Datum
261 GBC 6 : bt_page_stats_internal(PG_FUNCTION_ARGS, enum pageinspect_version ext_version)
262 : {
263 CBC 6 : text *relname = PG_GETARG_TEXT_PP(0);
264 GIC 6 : int64 blkno = (ext_version == PAGEINSPECT_V1_8 ? PG_GETARG_UINT32(1) : PG_GETARG_INT64(1));
265 ECB : Buffer buffer;
266 : Relation rel;
267 : RangeVar *relrv;
268 EUB : Datum result;
269 ECB : HeapTuple tuple;
270 : TupleDesc tupleDesc;
271 : int j;
272 : char *values[11];
273 : BTPageStat stat;
274 :
275 GIC 6 : if (!superuser())
276 UIC 0 : ereport(ERROR,
277 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
278 ECB : errmsg("must be superuser to use pageinspect functions")));
279 :
280 GIC 6 : relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
281 CBC 6 : rel = relation_openrv(relrv, AccessShareLock);
282 ECB :
283 GNC 6 : bt_index_block_validate(rel, blkno);
284 :
285 GIC 2 : buffer = ReadBuffer(rel, blkno);
286 2 : LockBuffer(buffer, BUFFER_LOCK_SHARE);
287 :
288 : /* keep compiler quiet */
289 CBC 2 : stat.btpo_prev = stat.btpo_next = InvalidBlockNumber;
290 GBC 2 : stat.btpo_flags = stat.free_size = stat.avg_item_size = 0;
291 :
292 GIC 2 : GetBTPageStatistics(blkno, buffer, &stat);
293 :
294 CBC 2 : UnlockReleaseBuffer(buffer);
295 2 : relation_close(rel, AccessShareLock);
296 :
297 : /* Build a tuple descriptor for our result type */
298 GIC 2 : if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
299 LBC 0 : elog(ERROR, "return type must be a row type");
300 ECB :
301 GIC 2 : j = 0;
302 2 : values[j++] = psprintf("%u", stat.blkno);
303 2 : values[j++] = psprintf("%c", stat.type);
304 2 : values[j++] = psprintf("%u", stat.live_items);
305 2 : values[j++] = psprintf("%u", stat.dead_items);
306 2 : values[j++] = psprintf("%u", stat.avg_item_size);
307 2 : values[j++] = psprintf("%u", stat.page_size);
308 2 : values[j++] = psprintf("%u", stat.free_size);
309 2 : values[j++] = psprintf("%u", stat.btpo_prev);
310 CBC 2 : values[j++] = psprintf("%u", stat.btpo_next);
311 GIC 2 : values[j++] = psprintf("%u", stat.btpo_level);
312 CBC 2 : values[j++] = psprintf("%d", stat.btpo_flags);
313 ECB :
314 GIC 2 : tuple = BuildTupleFromCStrings(TupleDescGetAttInMetadata(tupleDesc),
315 : values);
316 :
317 2 : result = HeapTupleGetDatum(tuple);
318 :
319 2 : PG_RETURN_DATUM(result);
320 : }
321 :
322 : Datum
323 5 : bt_page_stats_1_9(PG_FUNCTION_ARGS)
324 ECB : {
325 GBC 5 : return bt_page_stats_internal(fcinfo, PAGEINSPECT_V1_9);
326 : }
327 :
328 : /* entry point for old extension version */
329 ECB : Datum
330 CBC 1 : bt_page_stats(PG_FUNCTION_ARGS)
331 : {
332 1 : return bt_page_stats_internal(fcinfo, PAGEINSPECT_V1_8);
333 : }
334 ECB :
335 :
336 : /* -----------------------------------------------
337 : * bt_multi_page_stats()
338 : *
339 : * Usage: SELECT * FROM bt_page_stats('t1_pkey', 1, 2);
340 : * Arguments are index relation name, first block number, number of blocks
341 : * (but number of blocks can be negative to mean "read all the rest")
342 : * -----------------------------------------------
343 : */
344 : Datum
345 GNC 14 : bt_multi_page_stats(PG_FUNCTION_ARGS)
346 : {
347 : Relation rel;
348 : ua_page_stats *uargs;
349 : FuncCallContext *fctx;
350 : MemoryContext mctx;
351 :
352 14 : if (!superuser())
353 UNC 0 : ereport(ERROR,
354 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
355 : errmsg("must be superuser to use pageinspect functions")));
356 :
357 GNC 14 : if (SRF_IS_FIRSTCALL())
358 : {
359 6 : text *relname = PG_GETARG_TEXT_PP(0);
360 6 : int64 blkno = PG_GETARG_INT64(1);
361 6 : int64 blk_count = PG_GETARG_INT64(2);
362 : RangeVar *relrv;
363 :
364 6 : fctx = SRF_FIRSTCALL_INIT();
365 :
366 6 : relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
367 6 : rel = relation_openrv(relrv, AccessShareLock);
368 :
369 : /* Check that rel is a valid btree index and 1st block number is OK */
370 6 : bt_index_block_validate(rel, blkno);
371 :
372 : /*
373 : * Check if upper bound of the specified range is valid. If only one
374 : * page is requested, skip as we've already validated the page. (Also,
375 : * it's important to skip this if blk_count is negative.)
376 : */
377 4 : if (blk_count > 1)
378 2 : check_relation_block_range(rel, blkno + blk_count - 1);
379 :
380 : /* Save arguments for reuse */
381 4 : mctx = MemoryContextSwitchTo(fctx->multi_call_memory_ctx);
382 :
383 4 : uargs = palloc(sizeof(ua_page_stats));
384 :
385 4 : uargs->relid = RelationGetRelid(rel);
386 4 : uargs->blkno = blkno;
387 4 : uargs->blk_count = blk_count;
388 4 : uargs->allpages = (blk_count < 0);
389 :
390 4 : fctx->user_fctx = uargs;
391 :
392 4 : MemoryContextSwitchTo(mctx);
393 :
394 : /*
395 : * To avoid possibly leaking a relcache reference if the SRF isn't run
396 : * to completion, we close and re-open the index rel each time
397 : * through, using the index's OID for re-opens to ensure we get the
398 : * same rel. Keep the AccessShareLock though, to ensure it doesn't go
399 : * away underneath us.
400 : */
401 4 : relation_close(rel, NoLock);
402 : }
403 :
404 12 : fctx = SRF_PERCALL_SETUP();
405 12 : uargs = fctx->user_fctx;
406 :
407 : /* We should have lock already */
408 12 : rel = relation_open(uargs->relid, NoLock);
409 :
410 : /* In all-pages mode, recheck the index length each time */
411 12 : if (uargs->allpages)
412 5 : uargs->blk_count = RelationGetNumberOfBlocks(rel) - uargs->blkno;
413 :
414 12 : if (uargs->blk_count > 0)
415 : {
416 : /* We need to fetch next block statistics */
417 : Buffer buffer;
418 : Datum result;
419 : HeapTuple tuple;
420 : int j;
421 : char *values[11];
422 : BTPageStat stat;
423 : TupleDesc tupleDesc;
424 :
425 8 : buffer = ReadBuffer(rel, uargs->blkno);
426 8 : LockBuffer(buffer, BUFFER_LOCK_SHARE);
427 :
428 : /* keep compiler quiet */
429 8 : stat.btpo_prev = stat.btpo_next = InvalidBlockNumber;
430 8 : stat.btpo_flags = stat.free_size = stat.avg_item_size = 0;
431 :
432 8 : GetBTPageStatistics(uargs->blkno, buffer, &stat);
433 :
434 8 : UnlockReleaseBuffer(buffer);
435 8 : relation_close(rel, NoLock);
436 :
437 : /* Build a tuple descriptor for our result type */
438 8 : if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
439 UNC 0 : elog(ERROR, "return type must be a row type");
440 :
441 GNC 8 : j = 0;
442 8 : values[j++] = psprintf("%u", stat.blkno);
443 8 : values[j++] = psprintf("%c", stat.type);
444 8 : values[j++] = psprintf("%u", stat.live_items);
445 8 : values[j++] = psprintf("%u", stat.dead_items);
446 8 : values[j++] = psprintf("%u", stat.avg_item_size);
447 8 : values[j++] = psprintf("%u", stat.page_size);
448 8 : values[j++] = psprintf("%u", stat.free_size);
449 8 : values[j++] = psprintf("%u", stat.btpo_prev);
450 8 : values[j++] = psprintf("%u", stat.btpo_next);
451 8 : values[j++] = psprintf("%u", stat.btpo_level);
452 8 : values[j++] = psprintf("%d", stat.btpo_flags);
453 :
454 : /* Construct tuple to be returned */
455 8 : tuple = BuildTupleFromCStrings(TupleDescGetAttInMetadata(tupleDesc),
456 : values);
457 :
458 8 : result = HeapTupleGetDatum(tuple);
459 :
460 : /*
461 : * Move to the next block number and decrement the number of blocks
462 : * still to be fetched
463 : */
464 8 : uargs->blkno++;
465 8 : uargs->blk_count--;
466 :
467 8 : SRF_RETURN_NEXT(fctx, result);
468 : }
469 :
470 : /* Done, so finally we can release the index lock */
471 4 : relation_close(rel, AccessShareLock);
472 4 : SRF_RETURN_DONE(fctx);
473 : }
474 ECB :
475 EUB : /*-------------------------------------------------------
476 : * bt_page_print_tuples()
477 ECB : *
478 : * Form a tuple describing index tuple at a given offset
479 : * ------------------------------------------------------
480 : */
481 : static Datum
482 GNC 3 : bt_page_print_tuples(ua_page_items *uargs)
483 ECB : {
484 CBC 3 : Page page = uargs->page;
485 3 : OffsetNumber offset = uargs->offset;
486 3 : bool leafpage = uargs->leafpage;
487 3 : bool rightmost = uargs->rightmost;
488 ECB : bool ispivottuple;
489 : Datum values[9];
490 : bool nulls[9];
491 : HeapTuple tuple;
492 : ItemId id;
493 : IndexTuple itup;
494 : int j;
495 : int off;
496 : int dlen;
497 : char *dump,
498 : *datacstring;
499 : char *ptr;
500 : ItemPointer htid;
501 :
502 GIC 3 : id = PageGetItemId(page, offset);
503 :
504 3 : if (!ItemIdIsValid(id))
505 UIC 0 : elog(ERROR, "invalid ItemId");
506 ECB :
507 GIC 3 : itup = (IndexTuple) PageGetItem(page, id);
508 ECB :
509 GIC 3 : j = 0;
510 3 : memset(nulls, 0, sizeof(nulls));
511 3 : values[j++] = DatumGetInt16(offset);
512 3 : values[j++] = ItemPointerGetDatum(&itup->t_tid);
513 3 : values[j++] = Int32GetDatum((int) IndexTupleSize(itup));
514 3 : values[j++] = BoolGetDatum(IndexTupleHasNulls(itup));
515 3 : values[j++] = BoolGetDatum(IndexTupleHasVarwidths(itup));
516 :
517 3 : ptr = (char *) itup + IndexInfoFindDataOffset(itup->t_info);
518 3 : dlen = IndexTupleSize(itup) - IndexInfoFindDataOffset(itup->t_info);
519 :
520 : /*
521 ECB : * Make sure that "data" column does not include posting list or pivot
522 : * tuple representation of heap TID(s).
523 : *
524 : * Note: BTreeTupleIsPivot() won't work reliably on !heapkeyspace indexes
525 : * (those built before BTREE_VERSION 4), but we have no way of determining
526 : * if this page came from a !heapkeyspace index. We may only have a bytea
527 : * nbtree page image to go on, so in general there is no metapage that we
528 : * can check.
529 EUB : *
530 : * That's okay here because BTreeTupleIsPivot() can only return false for
531 : * a !heapkeyspace pivot, never true for a !heapkeyspace non-pivot. Since
532 : * heap TID isn't part of the keyspace in a !heapkeyspace index anyway,
533 ECB : * there cannot possibly be a pivot tuple heap TID representation that we
534 : * fail to make an adjustment for. A !heapkeyspace index can have
535 : * BTreeTupleIsPivot() return true (due to things like suffix truncation
536 : * for INCLUDE indexes in Postgres v11), but when that happens
537 : * BTreeTupleGetHeapTID() can be trusted to work reliably (i.e. return
538 : * NULL).
539 : *
540 : * Note: BTreeTupleIsPosting() always works reliably, even with
541 : * !heapkeyspace indexes.
542 : */
543 CBC 3 : if (BTreeTupleIsPosting(itup))
544 UIC 0 : dlen -= IndexTupleSize(itup) - BTreeTupleGetPostingOffset(itup);
545 GIC 3 : else if (BTreeTupleIsPivot(itup) && BTreeTupleGetHeapTID(itup) != NULL)
546 LBC 0 : dlen -= MAXALIGN(sizeof(ItemPointerData));
547 :
548 GIC 3 : if (dlen < 0 || dlen > INDEX_SIZE_MASK)
549 UIC 0 : elog(ERROR, "invalid tuple length %d for tuple at offset number %u",
550 : dlen, offset);
551 GIC 3 : dump = palloc0(dlen * 3 + 1);
552 3 : datacstring = dump;
553 CBC 27 : for (off = 0; off < dlen; off++)
554 ECB : {
555 GIC 24 : if (off > 0)
556 21 : *dump++ = ' ';
557 CBC 24 : sprintf(dump, "%02x", *(ptr + off) & 0xff);
558 GIC 24 : dump += 2;
559 ECB : }
560 GIC 3 : values[j++] = CStringGetTextDatum(datacstring);
561 CBC 3 : pfree(datacstring);
562 ECB :
563 : /*
564 : * We need to work around the BTreeTupleIsPivot() !heapkeyspace limitation
565 : * again. Deduce whether or not tuple must be a pivot tuple based on
566 : * whether or not the page is a leaf page, as well as the page offset
567 : * number of the tuple.
568 : */
569 GIC 3 : ispivottuple = (!leafpage || (!rightmost && offset == P_HIKEY));
570 :
571 : /* LP_DEAD bit can never be set for pivot tuples, so show a NULL there */
572 3 : if (!ispivottuple)
573 3 : values[j++] = BoolGetDatum(ItemIdIsDead(id));
574 : else
575 : {
576 UIC 0 : Assert(!ItemIdIsDead(id));
577 LBC 0 : nulls[j++] = true;
578 : }
579 :
580 CBC 3 : htid = BTreeTupleGetHeapTID(itup);
581 3 : if (ispivottuple && !BTreeTupleIsPivot(itup))
582 : {
583 : /* Don't show bogus heap TID in !heapkeyspace pivot tuple */
584 LBC 0 : htid = NULL;
585 : }
586 :
587 CBC 3 : if (htid)
588 3 : values[j++] = ItemPointerGetDatum(htid);
589 : else
590 LBC 0 : nulls[j++] = true;
591 :
592 GIC 3 : if (BTreeTupleIsPosting(itup))
593 : {
594 : /* Build an array of item pointers */
595 : ItemPointer tids;
596 : Datum *tids_datum;
597 : int nposting;
598 :
599 UIC 0 : tids = BTreeTupleGetPosting(itup);
600 0 : nposting = BTreeTupleGetNPosting(itup);
601 LBC 0 : tids_datum = (Datum *) palloc(nposting * sizeof(Datum));
602 0 : for (int i = 0; i < nposting; i++)
603 UIC 0 : tids_datum[i] = ItemPointerGetDatum(&tids[i]);
604 UNC 0 : values[j++] = PointerGetDatum(construct_array_builtin(tids_datum, nposting, TIDOID));
605 UIC 0 : pfree(tids_datum);
606 ECB : }
607 : else
608 GIC 3 : nulls[j++] = true;
609 :
610 ECB : /* Build and return the result tuple */
611 GBC 3 : tuple = heap_form_tuple(uargs->tupd, values, nulls);
612 :
613 CBC 3 : return HeapTupleGetDatum(tuple);
614 ECB : }
615 :
616 : /*-------------------------------------------------------
617 : * bt_page_items()
618 : *
619 : * Get IndexTupleData set in a btree page
620 : *
621 : * Usage: SELECT * FROM bt_page_items('t1_pkey', 1);
622 : *-------------------------------------------------------
623 : */
624 : static Datum
625 GIC 8 : bt_page_items_internal(PG_FUNCTION_ARGS, enum pageinspect_version ext_version)
626 : {
627 CBC 8 : text *relname = PG_GETARG_TEXT_PP(0);
628 GIC 8 : int64 blkno = (ext_version == PAGEINSPECT_V1_8 ? PG_GETARG_UINT32(1) : PG_GETARG_INT64(1));
629 : Datum result;
630 ECB : FuncCallContext *fctx;
631 : MemoryContext mctx;
632 : ua_page_items *uargs;
633 :
634 GIC 8 : if (!superuser())
635 UIC 0 : ereport(ERROR,
636 ECB : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
637 : errmsg("must be superuser to use pageinspect functions")));
638 :
639 CBC 8 : if (SRF_IS_FIRSTCALL())
640 : {
641 : RangeVar *relrv;
642 : Relation rel;
643 ECB : Buffer buffer;
644 : BTPageOpaque opaque;
645 : TupleDesc tupleDesc;
646 :
647 GIC 6 : fctx = SRF_FIRSTCALL_INIT();
648 :
649 6 : relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
650 6 : rel = relation_openrv(relrv, AccessShareLock);
651 :
652 GNC 6 : bt_index_block_validate(rel, blkno);
653 ECB :
654 GIC 2 : buffer = ReadBuffer(rel, blkno);
655 CBC 2 : LockBuffer(buffer, BUFFER_LOCK_SHARE);
656 ECB :
657 : /*
658 : * We copy the page into local storage to avoid holding pin on the
659 : * buffer longer than we must, and possibly failing to release it at
660 : * all if the calling query doesn't fetch all rows.
661 : */
662 GIC 2 : mctx = MemoryContextSwitchTo(fctx->multi_call_memory_ctx);
663 ECB :
664 GNC 2 : uargs = palloc(sizeof(ua_page_items));
665 :
666 GIC 2 : uargs->page = palloc(BLCKSZ);
667 2 : memcpy(uargs->page, BufferGetPage(buffer), BLCKSZ);
668 :
669 2 : UnlockReleaseBuffer(buffer);
670 2 : relation_close(rel, AccessShareLock);
671 :
672 2 : uargs->offset = FirstOffsetNumber;
673 :
674 2 : opaque = BTPageGetOpaque(uargs->page);
675 :
676 2 : if (!P_ISDELETED(opaque))
677 2 : fctx->max_calls = PageGetMaxOffsetNumber(uargs->page);
678 : else
679 : {
680 : /* Don't interpret BTDeletedPageData as index tuples */
681 UIC 0 : elog(NOTICE, "page from block " INT64_FORMAT " is deleted", blkno);
682 0 : fctx->max_calls = 0;
683 : }
684 GIC 2 : uargs->leafpage = P_ISLEAF(opaque);
685 2 : uargs->rightmost = P_RIGHTMOST(opaque);
686 :
687 : /* Build a tuple descriptor for our result type */
688 2 : if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
689 LBC 0 : elog(ERROR, "return type must be a row type");
690 GBC 2 : tupleDesc = BlessTupleDesc(tupleDesc);
691 ECB :
692 GBC 2 : uargs->tupd = tupleDesc;
693 :
694 CBC 2 : fctx->user_fctx = uargs;
695 EUB :
696 GIC 2 : MemoryContextSwitchTo(mctx);
697 ECB : }
698 :
699 CBC 4 : fctx = SRF_PERCALL_SETUP();
700 GIC 4 : uargs = fctx->user_fctx;
701 ECB :
702 CBC 4 : if (fctx->call_cntr < fctx->max_calls)
703 ECB : {
704 CBC 2 : result = bt_page_print_tuples(uargs);
705 GIC 2 : uargs->offset++;
706 CBC 2 : SRF_RETURN_NEXT(fctx, result);
707 ECB : }
708 :
709 GIC 2 : SRF_RETURN_DONE(fctx);
710 : }
711 :
712 : Datum
713 6 : bt_page_items_1_9(PG_FUNCTION_ARGS)
714 : {
715 CBC 6 : return bt_page_items_internal(fcinfo, PAGEINSPECT_V1_9);
716 : }
717 :
718 ECB : /* entry point for old extension version */
719 : Datum
720 GIC 2 : bt_page_items(PG_FUNCTION_ARGS)
721 : {
722 GBC 2 : return bt_page_items_internal(fcinfo, PAGEINSPECT_V1_8);
723 EUB : }
724 :
725 : /*-------------------------------------------------------
726 ECB : * bt_page_items_bytea()
727 : *
728 : * Get IndexTupleData set in a btree page
729 : *
730 EUB : * Usage: SELECT * FROM bt_page_items(get_raw_page('t1_pkey', 1));
731 : *-------------------------------------------------------
732 : */
733 ECB :
734 : Datum
735 GIC 9 : bt_page_items_bytea(PG_FUNCTION_ARGS)
736 EUB : {
737 GIC 9 : bytea *raw_page = PG_GETARG_BYTEA_P(0);
738 ECB : Datum result;
739 : FuncCallContext *fctx;
740 : ua_page_items *uargs;
741 :
742 GIC 9 : if (!superuser())
743 UIC 0 : ereport(ERROR,
744 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
745 EUB : errmsg("must be superuser to use raw page functions")));
746 :
747 GBC 9 : if (SRF_IS_FIRSTCALL())
748 EUB : {
749 : BTPageOpaque opaque;
750 : MemoryContext mctx;
751 : TupleDesc tupleDesc;
752 :
753 GIC 8 : fctx = SRF_FIRSTCALL_INIT();
754 CBC 8 : mctx = MemoryContextSwitchTo(fctx->multi_call_memory_ctx);
755 :
756 GNC 8 : uargs = palloc(sizeof(ua_page_items));
757 ECB :
758 GIC 8 : uargs->page = get_page_from_raw(raw_page);
759 ECB :
760 GIC 7 : if (PageIsNew(uargs->page))
761 : {
762 1 : MemoryContextSwitchTo(mctx);
763 1 : PG_RETURN_NULL();
764 : }
765 :
766 6 : uargs->offset = FirstOffsetNumber;
767 :
768 : /* verify the special space has the expected size */
769 6 : if (PageGetSpecialSize(uargs->page) != MAXALIGN(sizeof(BTPageOpaqueData)))
770 2 : ereport(ERROR,
771 ECB : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
772 : errmsg("input page is not a valid %s page", "btree"),
773 : errdetail("Expected special size %d, got %d.",
774 : (int) MAXALIGN(sizeof(BTPageOpaqueData)),
775 : (int) PageGetSpecialSize(uargs->page))));
776 :
777 GIC 4 : opaque = BTPageGetOpaque(uargs->page);
778 :
779 4 : if (P_ISMETA(opaque))
780 CBC 2 : ereport(ERROR,
781 EUB : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
782 : errmsg("block is a meta page")));
783 :
784 GIC 2 : if (P_ISLEAF(opaque) && opaque->btpo_level != 0)
785 CBC 1 : ereport(ERROR,
786 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
787 : errmsg("block is not a valid btree leaf page")));
788 :
789 GIC 1 : if (P_ISDELETED(opaque))
790 UIC 0 : elog(NOTICE, "page is deleted");
791 :
792 GIC 1 : if (!P_ISDELETED(opaque))
793 CBC 1 : fctx->max_calls = PageGetMaxOffsetNumber(uargs->page);
794 : else
795 ECB : {
796 : /* Don't interpret BTDeletedPageData as index tuples */
797 UIC 0 : elog(NOTICE, "page from block is deleted");
798 LBC 0 : fctx->max_calls = 0;
799 : }
800 CBC 1 : uargs->leafpage = P_ISLEAF(opaque);
801 1 : uargs->rightmost = P_RIGHTMOST(opaque);
802 :
803 : /* Build a tuple descriptor for our result type */
804 GIC 1 : if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
805 UIC 0 : elog(ERROR, "return type must be a row type");
806 GIC 1 : tupleDesc = BlessTupleDesc(tupleDesc);
807 :
808 CBC 1 : uargs->tupd = tupleDesc;
809 :
810 1 : fctx->user_fctx = uargs;
811 :
812 1 : MemoryContextSwitchTo(mctx);
813 ECB : }
814 :
815 CBC 2 : fctx = SRF_PERCALL_SETUP();
816 2 : uargs = fctx->user_fctx;
817 :
818 2 : if (fctx->call_cntr < fctx->max_calls)
819 : {
820 1 : result = bt_page_print_tuples(uargs);
821 GIC 1 : uargs->offset++;
822 CBC 1 : SRF_RETURN_NEXT(fctx, result);
823 ECB : }
824 :
825 GIC 1 : SRF_RETURN_DONE(fctx);
826 : }
827 EUB :
828 : /* Number of output arguments (columns) for bt_metap() */
829 : #define BT_METAP_COLS_V1_8 9
830 ECB :
831 : /* ------------------------------------------------
832 : * bt_metap()
833 : *
834 : * Get a btree's meta-page information
835 EUB : *
836 ECB : * Usage: SELECT * FROM bt_metap('t1_pkey')
837 : * ------------------------------------------------
838 : */
839 : Datum
840 CBC 2 : bt_metap(PG_FUNCTION_ARGS)
841 : {
842 2 : text *relname = PG_GETARG_TEXT_PP(0);
843 : Datum result;
844 : Relation rel;
845 ECB : RangeVar *relrv;
846 : BTMetaPageData *metad;
847 : TupleDesc tupleDesc;
848 : int j;
849 : char *values[9];
850 : Buffer buffer;
851 : Page page;
852 : HeapTuple tuple;
853 :
854 GIC 2 : if (!superuser())
855 LBC 0 : ereport(ERROR,
856 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
857 : errmsg("must be superuser to use pageinspect functions")));
858 :
859 CBC 2 : relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
860 GIC 2 : rel = relation_openrv(relrv, AccessShareLock);
861 ECB :
862 GIC 2 : if (!IS_INDEX(rel) || !IS_BTREE(rel))
863 1 : ereport(ERROR,
864 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
865 : errmsg("\"%s\" is not a %s index",
866 ECB : RelationGetRelationName(rel), "btree")));
867 :
868 : /*
869 : * Reject attempts to read non-local temporary relations; we would be
870 : * likely to get wrong data since we have no visibility into the owning
871 : * session's local buffers.
872 : */
873 GIC 1 : if (RELATION_IS_OTHER_TEMP(rel))
874 UIC 0 : ereport(ERROR,
875 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
876 : errmsg("cannot access temporary tables of other sessions")));
877 :
878 GIC 1 : buffer = ReadBuffer(rel, 0);
879 1 : LockBuffer(buffer, BUFFER_LOCK_SHARE);
880 :
881 CBC 1 : page = BufferGetPage(buffer);
882 GIC 1 : metad = BTPageGetMeta(page);
883 ECB :
884 : /* Build a tuple descriptor for our result type */
885 GIC 1 : if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
886 UIC 0 : elog(ERROR, "return type must be a row type");
887 :
888 ECB : /*
889 EUB : * We need a kluge here to detect API versions prior to 1.8. Earlier
890 : * versions incorrectly used int4 for certain columns.
891 : *
892 : * There is no way to reliably avoid the problems created by the old
893 ECB : * function definition at this point, so insist that the user update the
894 : * extension.
895 : */
896 GIC 1 : if (tupleDesc->natts < BT_METAP_COLS_V1_8)
897 UIC 0 : ereport(ERROR,
898 : (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
899 ECB : errmsg("function has wrong number of declared columns"),
900 : errhint("To resolve the problem, update the \"pageinspect\" extension to the latest version.")));
901 :
902 CBC 1 : j = 0;
903 GIC 1 : values[j++] = psprintf("%d", metad->btm_magic);
904 CBC 1 : values[j++] = psprintf("%d", metad->btm_version);
905 GIC 1 : values[j++] = psprintf(INT64_FORMAT, (int64) metad->btm_root);
906 CBC 1 : values[j++] = psprintf(INT64_FORMAT, (int64) metad->btm_level);
907 GIC 1 : values[j++] = psprintf(INT64_FORMAT, (int64) metad->btm_fastroot);
908 CBC 1 : values[j++] = psprintf(INT64_FORMAT, (int64) metad->btm_fastlevel);
909 ECB :
910 : /*
911 : * Get values of extended metadata if available, use default values
912 : * otherwise. Note that we rely on the assumption that btm_allequalimage
913 : * is initialized to zero with indexes that were built on versions prior
914 : * to Postgres 13 (just like _bt_metaversion()).
915 : */
916 CBC 1 : if (metad->btm_version >= BTREE_NOVAC_VERSION)
917 : {
918 GIC 2 : values[j++] = psprintf(INT64_FORMAT,
919 1 : (int64) metad->btm_last_cleanup_num_delpages);
920 1 : values[j++] = psprintf("%f", metad->btm_last_cleanup_num_heap_tuples);
921 1 : values[j++] = metad->btm_allequalimage ? "t" : "f";
922 : }
923 ECB : else
924 : {
925 LBC 0 : values[j++] = "0";
926 0 : values[j++] = "-1";
927 UIC 0 : values[j++] = "f";
928 : }
929 :
930 CBC 1 : tuple = BuildTupleFromCStrings(TupleDescGetAttInMetadata(tupleDesc),
931 ECB : values);
932 :
933 GIC 1 : result = HeapTupleGetDatum(tuple);
934 :
935 CBC 1 : UnlockReleaseBuffer(buffer);
936 GBC 1 : relation_close(rel, AccessShareLock);
937 :
938 CBC 1 : PG_RETURN_DATUM(result);
939 ECB : }
|
