Branch data Line data Source code
1 : : /*
2 : : * contrib/pgstattuple/pgstatindex.c
3 : : *
4 : : *
5 : : * pgstatindex
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/gin_private.h"
31 : : #include "access/hash.h"
32 : : #include "access/htup_details.h"
33 : : #include "access/nbtree.h"
34 : : #include "access/relation.h"
35 : : #include "catalog/namespace.h"
36 : : #include "catalog/pg_am.h"
37 : : #include "funcapi.h"
38 : : #include "miscadmin.h"
39 : : #include "storage/bufmgr.h"
40 : : #include "storage/read_stream.h"
41 : : #include "utils/rel.h"
42 : : #include "utils/varlena.h"
43 : :
44 : :
45 : : /*
46 : : * Because of backward-compatibility issue, we have decided to have
47 : : * two types of interfaces, with regclass-type input arg and text-type
48 : : * input arg, for each function.
49 : : *
50 : : * Those functions which have text-type input arg will be deprecated
51 : : * in the future release.
52 : : */
53 : 1 : PG_FUNCTION_INFO_V1(pgstatindex);
54 : 1 : PG_FUNCTION_INFO_V1(pgstatindexbyid);
55 : 1 : PG_FUNCTION_INFO_V1(pg_relpages);
56 : 1 : PG_FUNCTION_INFO_V1(pg_relpagesbyid);
57 : 1 : PG_FUNCTION_INFO_V1(pgstatginindex);
58 : 2 : PG_FUNCTION_INFO_V1(pgstathashindex);
59 : :
60 : 2 : PG_FUNCTION_INFO_V1(pgstatindex_v1_5);
61 : 2 : PG_FUNCTION_INFO_V1(pgstatindexbyid_v1_5);
62 : 2 : PG_FUNCTION_INFO_V1(pg_relpages_v1_5);
63 : 2 : PG_FUNCTION_INFO_V1(pg_relpagesbyid_v1_5);
64 : 2 : PG_FUNCTION_INFO_V1(pgstatginindex_v1_5);
65 : :
66 : : Datum pgstatginindex_internal(Oid relid, FunctionCallInfo fcinfo);
67 : :
68 : : #define IS_INDEX(r) ((r)->rd_rel->relkind == RELKIND_INDEX)
69 : : #define IS_BTREE(r) ((r)->rd_rel->relam == BTREE_AM_OID)
70 : : #define IS_GIN(r) ((r)->rd_rel->relam == GIN_AM_OID)
71 : : #define IS_HASH(r) ((r)->rd_rel->relam == HASH_AM_OID)
72 : :
73 : : /* ------------------------------------------------
74 : : * A structure for a whole btree index statistics
75 : : * used by pgstatindex().
76 : : * ------------------------------------------------
77 : : */
78 : : typedef struct BTIndexStat
79 : : {
80 : : uint32 version;
81 : : uint32 level;
82 : : BlockNumber root_blkno;
83 : :
84 : : uint64 internal_pages;
85 : : uint64 leaf_pages;
86 : : uint64 empty_pages;
87 : : uint64 deleted_pages;
88 : :
89 : : uint64 max_avail;
90 : : uint64 free_space;
91 : :
92 : : uint64 fragments;
93 : : } BTIndexStat;
94 : :
95 : : /* ------------------------------------------------
96 : : * A structure for a whole GIN index statistics
97 : : * used by pgstatginindex().
98 : : * ------------------------------------------------
99 : : */
100 : : typedef struct GinIndexStat
101 : : {
102 : : int32 version;
103 : :
104 : : BlockNumber pending_pages;
105 : : int64 pending_tuples;
106 : : } GinIndexStat;
107 : :
108 : : /* ------------------------------------------------
109 : : * A structure for a whole HASH index statistics
110 : : * used by pgstathashindex().
111 : : * ------------------------------------------------
112 : : */
113 : : typedef struct HashIndexStat
114 : : {
115 : : int32 version;
116 : : int32 space_per_page;
117 : :
118 : : BlockNumber bucket_pages;
119 : : BlockNumber overflow_pages;
120 : : BlockNumber bitmap_pages;
121 : : BlockNumber unused_pages;
122 : :
123 : : int64 live_items;
124 : : int64 dead_items;
125 : : uint64 free_space;
126 : : } HashIndexStat;
127 : :
128 : : static Datum pgstatindex_impl(Relation rel, FunctionCallInfo fcinfo);
129 : : static int64 pg_relpages_impl(Relation rel);
130 : : static void GetHashPageStats(Page page, HashIndexStat *stats);
131 : :
132 : : /* ------------------------------------------------------
133 : : * pgstatindex()
134 : : *
135 : : * Usage: SELECT * FROM pgstatindex('t1_pkey');
136 : : *
137 : : * The superuser() check here must be kept as the library might be upgraded
138 : : * without the extension being upgraded, meaning that in pre-1.5 installations
139 : : * these functions could be called by any user.
140 : : * ------------------------------------------------------
141 : : */
142 : : Datum
143 : 0 : pgstatindex(PG_FUNCTION_ARGS)
144 : : {
145 : 0 : text *relname = PG_GETARG_TEXT_PP(0);
146 : : Relation rel;
147 : : RangeVar *relrv;
148 : :
149 [ # # ]: 0 : if (!superuser())
150 [ # # ]: 0 : ereport(ERROR,
151 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
152 : : errmsg("must be superuser to use pgstattuple functions")));
153 : :
154 : 0 : relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
155 : 0 : rel = relation_openrv(relrv, AccessShareLock);
156 : :
157 : 0 : PG_RETURN_DATUM(pgstatindex_impl(rel, fcinfo));
158 : : }
159 : :
160 : : /*
161 : : * As of pgstattuple version 1.5, we no longer need to check if the user
162 : : * is a superuser because we REVOKE EXECUTE on the function from PUBLIC.
163 : : * Users can then grant access to it based on their policies.
164 : : *
165 : : * Otherwise identical to pgstatindex (above).
166 : : */
167 : : Datum
168 : 11 : pgstatindex_v1_5(PG_FUNCTION_ARGS)
169 : : {
170 : 11 : text *relname = PG_GETARG_TEXT_PP(0);
171 : : Relation rel;
172 : : RangeVar *relrv;
173 : :
174 : 11 : relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
175 : 11 : rel = relation_openrv(relrv, AccessShareLock);
176 : :
177 : 11 : PG_RETURN_DATUM(pgstatindex_impl(rel, fcinfo));
178 : : }
179 : :
180 : : /*
181 : : * The superuser() check here must be kept as the library might be upgraded
182 : : * without the extension being upgraded, meaning that in pre-1.5 installations
183 : : * these functions could be called by any user.
184 : : */
185 : : Datum
186 : 0 : pgstatindexbyid(PG_FUNCTION_ARGS)
187 : : {
188 : 0 : Oid relid = PG_GETARG_OID(0);
189 : : Relation rel;
190 : :
191 [ # # ]: 0 : if (!superuser())
192 [ # # ]: 0 : ereport(ERROR,
193 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
194 : : errmsg("must be superuser to use pgstattuple functions")));
195 : :
196 : 0 : rel = relation_open(relid, AccessShareLock);
197 : :
198 : 0 : PG_RETURN_DATUM(pgstatindex_impl(rel, fcinfo));
199 : : }
200 : :
201 : : /* No need for superuser checks in v1.5, see above */
202 : : Datum
203 : 1 : pgstatindexbyid_v1_5(PG_FUNCTION_ARGS)
204 : : {
205 : 1 : Oid relid = PG_GETARG_OID(0);
206 : : Relation rel;
207 : :
208 : 1 : rel = relation_open(relid, AccessShareLock);
209 : :
210 : 1 : PG_RETURN_DATUM(pgstatindex_impl(rel, fcinfo));
211 : : }
212 : :
213 : : static Datum
214 : 12 : pgstatindex_impl(Relation rel, FunctionCallInfo fcinfo)
215 : : {
216 : : Datum result;
217 : : BlockNumber nblocks;
218 : : BlockNumber blkno;
219 : : BTIndexStat indexStat;
220 : 12 : BufferAccessStrategy bstrategy = GetAccessStrategy(BAS_BULKREAD);
221 : : BlockRangeReadStreamPrivate p;
222 : : ReadStream *stream;
223 : : BlockNumber startblk;
224 : :
225 [ + + + + ]: 12 : if (!IS_INDEX(rel) || !IS_BTREE(rel))
226 [ + - ]: 7 : ereport(ERROR,
227 : : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
228 : : errmsg("relation \"%s\" is not a btree index",
229 : : RelationGetRelationName(rel))));
230 : :
231 : : /*
232 : : * Reject attempts to read non-local temporary relations; we would be
233 : : * likely to get wrong data since we have no visibility into the owning
234 : : * session's local buffers.
235 : : */
236 [ - + - - ]: 5 : if (RELATION_IS_OTHER_TEMP(rel))
237 [ # # ]: 0 : ereport(ERROR,
238 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
239 : : errmsg("cannot access temporary tables of other sessions")));
240 : :
241 : : /*
242 : : * A !indisready index could lead to ERRCODE_DATA_CORRUPTED later, so exit
243 : : * early. We're capable of assessing an indisready&&!indisvalid index,
244 : : * but the results could be confusing. For example, the index's size
245 : : * could be too low for a valid index of the table.
246 : : */
247 [ - + ]: 5 : if (!rel->rd_index->indisvalid)
248 [ # # ]: 0 : ereport(ERROR,
249 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
250 : : errmsg("index \"%s\" is not valid",
251 : : RelationGetRelationName(rel))));
252 : :
253 : : /*
254 : : * Read metapage
255 : : */
256 : : {
257 : 5 : Buffer buffer = ReadBufferExtended(rel, MAIN_FORKNUM, 0, RBM_NORMAL, bstrategy);
258 : 5 : Page page = BufferGetPage(buffer);
259 : 5 : BTMetaPageData *metad = BTPageGetMeta(page);
260 : :
261 : 5 : indexStat.version = metad->btm_version;
262 : 5 : indexStat.level = metad->btm_level;
263 : 5 : indexStat.root_blkno = metad->btm_root;
264 : :
265 : 5 : ReleaseBuffer(buffer);
266 : : }
267 : :
268 : : /* -- init counters -- */
269 : 5 : indexStat.internal_pages = 0;
270 : 5 : indexStat.leaf_pages = 0;
271 : 5 : indexStat.empty_pages = 0;
272 : 5 : indexStat.deleted_pages = 0;
273 : :
274 : 5 : indexStat.max_avail = 0;
275 : 5 : indexStat.free_space = 0;
276 : :
277 : 5 : indexStat.fragments = 0;
278 : :
279 : : /*
280 : : * Scan all blocks except the metapage (0th page) using streaming reads
281 : : */
282 : 5 : nblocks = RelationGetNumberOfBlocks(rel);
283 : 5 : startblk = BTREE_METAPAGE + 1;
284 : :
285 : 5 : p.current_blocknum = startblk;
286 : 5 : p.last_exclusive = nblocks;
287 : :
288 : : /*
289 : : * It is safe to use batchmode as block_range_read_stream_cb takes no
290 : : * locks.
291 : : */
292 : 5 : stream = read_stream_begin_relation(READ_STREAM_FULL |
293 : : READ_STREAM_USE_BATCHING,
294 : : bstrategy,
295 : : rel,
296 : : MAIN_FORKNUM,
297 : : block_range_read_stream_cb,
298 : : &p,
299 : : 0);
300 : :
301 [ - + ]: 5 : for (blkno = startblk; blkno < nblocks; blkno++)
302 : : {
303 : : Buffer buffer;
304 : : Page page;
305 : : BTPageOpaque opaque;
306 : :
307 [ # # ]: 0 : CHECK_FOR_INTERRUPTS();
308 : :
309 : 0 : buffer = read_stream_next_buffer(stream, NULL);
310 : 0 : LockBuffer(buffer, BUFFER_LOCK_SHARE);
311 : :
312 : 0 : page = BufferGetPage(buffer);
313 : 0 : opaque = BTPageGetOpaque(page);
314 : :
315 : : /*
316 : : * Determine page type, and update totals.
317 : : *
318 : : * Note that we arbitrarily bucket deleted pages together without
319 : : * considering if they're leaf pages or internal pages.
320 : : */
321 [ # # ]: 0 : if (P_ISDELETED(opaque))
322 : 0 : indexStat.deleted_pages++;
323 [ # # ]: 0 : else if (P_IGNORE(opaque))
324 : 0 : indexStat.empty_pages++; /* this is the "half dead" state */
325 [ # # ]: 0 : else if (P_ISLEAF(opaque))
326 : : {
327 : : int max_avail;
328 : :
329 : 0 : max_avail = BLCKSZ - (BLCKSZ - ((PageHeader) page)->pd_special + SizeOfPageHeaderData);
330 : 0 : indexStat.max_avail += max_avail;
331 : 0 : indexStat.free_space += PageGetExactFreeSpace(page);
332 : :
333 : 0 : indexStat.leaf_pages++;
334 : :
335 : : /*
336 : : * If the next leaf is on an earlier block, it means a
337 : : * fragmentation.
338 : : */
339 [ # # # # ]: 0 : if (opaque->btpo_next != P_NONE && opaque->btpo_next < blkno)
340 : 0 : indexStat.fragments++;
341 : : }
342 : : else
343 : 0 : indexStat.internal_pages++;
344 : :
345 : 0 : UnlockReleaseBuffer(buffer);
346 : : }
347 : :
348 : : Assert(read_stream_next_buffer(stream, NULL) == InvalidBuffer);
349 : 5 : read_stream_end(stream);
350 : :
351 : 5 : relation_close(rel, AccessShareLock);
352 : :
353 : : /*----------------------------
354 : : * Build a result tuple
355 : : *----------------------------
356 : : */
357 : : {
358 : : TupleDesc tupleDesc;
359 : : int j;
360 : : char *values[10];
361 : : HeapTuple tuple;
362 : :
363 : : /* Build a tuple descriptor for our result type */
364 [ - + ]: 5 : if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
365 [ # # ]: 0 : elog(ERROR, "return type must be a row type");
366 : :
367 : 5 : j = 0;
368 : 5 : values[j++] = psprintf("%d", indexStat.version);
369 : 5 : values[j++] = psprintf("%d", indexStat.level);
370 : 10 : values[j++] = psprintf(INT64_FORMAT,
371 : : (1 + /* include the metapage in index_size */
372 : 5 : indexStat.leaf_pages +
373 : 5 : indexStat.internal_pages +
374 : 5 : indexStat.deleted_pages +
375 : 5 : indexStat.empty_pages) * BLCKSZ);
376 : 5 : values[j++] = psprintf("%u", indexStat.root_blkno);
377 : 5 : values[j++] = psprintf(INT64_FORMAT, indexStat.internal_pages);
378 : 5 : values[j++] = psprintf(INT64_FORMAT, indexStat.leaf_pages);
379 : 5 : values[j++] = psprintf(INT64_FORMAT, indexStat.empty_pages);
380 : 5 : values[j++] = psprintf(INT64_FORMAT, indexStat.deleted_pages);
381 [ - + ]: 5 : if (indexStat.max_avail > 0)
382 : 0 : values[j++] = psprintf("%.2f",
383 : 0 : 100.0 - (double) indexStat.free_space / (double) indexStat.max_avail * 100.0);
384 : : else
385 : 5 : values[j++] = pstrdup("NaN");
386 [ - + ]: 5 : if (indexStat.leaf_pages > 0)
387 : 0 : values[j++] = psprintf("%.2f",
388 : 0 : (double) indexStat.fragments / (double) indexStat.leaf_pages * 100.0);
389 : : else
390 : 5 : values[j++] = pstrdup("NaN");
391 : :
392 : 5 : tuple = BuildTupleFromCStrings(TupleDescGetAttInMetadata(tupleDesc),
393 : : values);
394 : :
395 : 5 : result = HeapTupleGetDatum(tuple);
396 : : }
397 : :
398 : 5 : return result;
399 : : }
400 : :
401 : : /* --------------------------------------------------------
402 : : * pg_relpages()
403 : : *
404 : : * Get the number of pages of the table/index.
405 : : *
406 : : * Usage: SELECT pg_relpages('t1');
407 : : * SELECT pg_relpages('t1_pkey');
408 : : *
409 : : * Must keep superuser() check, see above.
410 : : * --------------------------------------------------------
411 : : */
412 : : Datum
413 : 0 : pg_relpages(PG_FUNCTION_ARGS)
414 : : {
415 : 0 : text *relname = PG_GETARG_TEXT_PP(0);
416 : : Relation rel;
417 : : RangeVar *relrv;
418 : :
419 [ # # ]: 0 : if (!superuser())
420 [ # # ]: 0 : ereport(ERROR,
421 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
422 : : errmsg("must be superuser to use pgstattuple functions")));
423 : :
424 : 0 : relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
425 : 0 : rel = relation_openrv(relrv, AccessShareLock);
426 : :
427 : 0 : PG_RETURN_INT64(pg_relpages_impl(rel));
428 : : }
429 : :
430 : : /* No need for superuser checks in v1.5, see above */
431 : : Datum
432 : 10 : pg_relpages_v1_5(PG_FUNCTION_ARGS)
433 : : {
434 : 10 : text *relname = PG_GETARG_TEXT_PP(0);
435 : : Relation rel;
436 : : RangeVar *relrv;
437 : :
438 : 10 : relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
439 : 10 : rel = relation_openrv(relrv, AccessShareLock);
440 : :
441 : 10 : PG_RETURN_INT64(pg_relpages_impl(rel));
442 : : }
443 : :
444 : : /* Must keep superuser() check, see above. */
445 : : Datum
446 : 0 : pg_relpagesbyid(PG_FUNCTION_ARGS)
447 : : {
448 : 0 : Oid relid = PG_GETARG_OID(0);
449 : : Relation rel;
450 : :
451 [ # # ]: 0 : if (!superuser())
452 [ # # ]: 0 : ereport(ERROR,
453 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
454 : : errmsg("must be superuser to use pgstattuple functions")));
455 : :
456 : 0 : rel = relation_open(relid, AccessShareLock);
457 : :
458 : 0 : PG_RETURN_INT64(pg_relpages_impl(rel));
459 : : }
460 : :
461 : : /* No need for superuser checks in v1.5, see above */
462 : : Datum
463 : 3 : pg_relpagesbyid_v1_5(PG_FUNCTION_ARGS)
464 : : {
465 : 3 : Oid relid = PG_GETARG_OID(0);
466 : : Relation rel;
467 : :
468 : 3 : rel = relation_open(relid, AccessShareLock);
469 : :
470 : 3 : PG_RETURN_INT64(pg_relpages_impl(rel));
471 : : }
472 : :
473 : : static int64
474 : 13 : pg_relpages_impl(Relation rel)
475 : : {
476 : : int64 relpages;
477 : :
478 [ + + + + : 13 : if (!RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
+ + + + +
- ]
479 [ + - ]: 3 : ereport(ERROR,
480 : : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
481 : : errmsg("cannot get page count of relation \"%s\"",
482 : : RelationGetRelationName(rel)),
483 : : errdetail_relkind_not_supported(rel->rd_rel->relkind)));
484 : :
485 : : /* note: this will work OK on non-local temp tables */
486 : :
487 : 10 : relpages = RelationGetNumberOfBlocks(rel);
488 : :
489 : 10 : relation_close(rel, AccessShareLock);
490 : :
491 : 10 : return relpages;
492 : : }
493 : :
494 : : /* ------------------------------------------------------
495 : : * pgstatginindex()
496 : : *
497 : : * Usage: SELECT * FROM pgstatginindex('ginindex');
498 : : *
499 : : * Must keep superuser() check, see above.
500 : : * ------------------------------------------------------
501 : : */
502 : : Datum
503 : 0 : pgstatginindex(PG_FUNCTION_ARGS)
504 : : {
505 : 0 : Oid relid = PG_GETARG_OID(0);
506 : :
507 [ # # ]: 0 : if (!superuser())
508 [ # # ]: 0 : ereport(ERROR,
509 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
510 : : errmsg("must be superuser to use pgstattuple functions")));
511 : :
512 : 0 : PG_RETURN_DATUM(pgstatginindex_internal(relid, fcinfo));
513 : : }
514 : :
515 : : /* No need for superuser checks in v1.5, see above */
516 : : Datum
517 : 8 : pgstatginindex_v1_5(PG_FUNCTION_ARGS)
518 : : {
519 : 8 : Oid relid = PG_GETARG_OID(0);
520 : :
521 : 8 : PG_RETURN_DATUM(pgstatginindex_internal(relid, fcinfo));
522 : : }
523 : :
524 : : Datum
525 : 8 : pgstatginindex_internal(Oid relid, FunctionCallInfo fcinfo)
526 : : {
527 : : Relation rel;
528 : : Buffer buffer;
529 : : Page page;
530 : : GinMetaPageData *metadata;
531 : : GinIndexStat stats;
532 : : HeapTuple tuple;
533 : : TupleDesc tupleDesc;
534 : : Datum values[3];
535 : 8 : bool nulls[3] = {false, false, false};
536 : : Datum result;
537 : :
538 : : /*
539 : : * This uses relation_open() and not index_open(). The latter allows
540 : : * partitioned indexes, and these are forbidden here.
541 : : */
542 : 8 : rel = relation_open(relid, AccessShareLock);
543 : :
544 [ + + + + ]: 8 : if (!IS_INDEX(rel) || !IS_GIN(rel))
545 [ + - ]: 7 : ereport(ERROR,
546 : : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
547 : : errmsg("relation \"%s\" is not a GIN index",
548 : : RelationGetRelationName(rel))));
549 : :
550 : : /*
551 : : * Reject attempts to read non-local temporary relations; we would be
552 : : * likely to get wrong data since we have no visibility into the owning
553 : : * session's local buffers.
554 : : */
555 [ - + - - ]: 1 : if (RELATION_IS_OTHER_TEMP(rel))
556 [ # # ]: 0 : ereport(ERROR,
557 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
558 : : errmsg("cannot access temporary indexes of other sessions")));
559 : :
560 : : /* see pgstatindex_impl */
561 [ - + ]: 1 : if (!rel->rd_index->indisvalid)
562 [ # # ]: 0 : ereport(ERROR,
563 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
564 : : errmsg("index \"%s\" is not valid",
565 : : RelationGetRelationName(rel))));
566 : :
567 : : /*
568 : : * Read metapage
569 : : */
570 : 1 : buffer = ReadBuffer(rel, GIN_METAPAGE_BLKNO);
571 : 1 : LockBuffer(buffer, GIN_SHARE);
572 : 1 : page = BufferGetPage(buffer);
573 : 1 : metadata = GinPageGetMeta(page);
574 : :
575 : 1 : stats.version = metadata->ginVersion;
576 : 1 : stats.pending_pages = metadata->nPendingPages;
577 : 1 : stats.pending_tuples = metadata->nPendingHeapTuples;
578 : :
579 : 1 : UnlockReleaseBuffer(buffer);
580 : 1 : relation_close(rel, AccessShareLock);
581 : :
582 : : /*
583 : : * Build a tuple descriptor for our result type
584 : : */
585 [ - + ]: 1 : if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
586 [ # # ]: 0 : elog(ERROR, "return type must be a row type");
587 : :
588 : 1 : values[0] = Int32GetDatum(stats.version);
589 : 1 : values[1] = Int32GetDatum(stats.pending_pages);
590 : 1 : values[2] = Int64GetDatum(stats.pending_tuples);
591 : :
592 : : /*
593 : : * Build and return the tuple
594 : : */
595 : 1 : tuple = heap_form_tuple(tupleDesc, values, nulls);
596 : 1 : result = HeapTupleGetDatum(tuple);
597 : :
598 : 1 : return result;
599 : : }
600 : :
601 : : /* ------------------------------------------------------
602 : : * pgstathashindex()
603 : : *
604 : : * Usage: SELECT * FROM pgstathashindex('hashindex');
605 : : * ------------------------------------------------------
606 : : */
607 : : Datum
608 : 10 : pgstathashindex(PG_FUNCTION_ARGS)
609 : : {
610 : 10 : Oid relid = PG_GETARG_OID(0);
611 : : BlockNumber nblocks;
612 : : BlockNumber blkno;
613 : : Relation rel;
614 : : HashIndexStat stats;
615 : : BufferAccessStrategy bstrategy;
616 : : HeapTuple tuple;
617 : : TupleDesc tupleDesc;
618 : : Datum values[8];
619 : 10 : bool nulls[8] = {0};
620 : : Buffer metabuf;
621 : : HashMetaPage metap;
622 : : float8 free_percent;
623 : : uint64 total_space;
624 : : BlockRangeReadStreamPrivate p;
625 : : ReadStream *stream;
626 : : BlockNumber startblk;
627 : :
628 : : /*
629 : : * This uses relation_open() and not index_open(). The latter allows
630 : : * partitioned indexes, and these are forbidden here.
631 : : */
632 : 10 : rel = relation_open(relid, AccessShareLock);
633 : :
634 [ + + + + ]: 10 : if (!IS_INDEX(rel) || !IS_HASH(rel))
635 [ + - ]: 8 : ereport(ERROR,
636 : : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
637 : : errmsg("relation \"%s\" is not a hash index",
638 : : RelationGetRelationName(rel))));
639 : :
640 : : /*
641 : : * Reject attempts to read non-local temporary relations; we would be
642 : : * likely to get wrong data since we have no visibility into the owning
643 : : * session's local buffers.
644 : : */
645 [ - + - - ]: 2 : if (RELATION_IS_OTHER_TEMP(rel))
646 [ # # ]: 0 : ereport(ERROR,
647 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
648 : : errmsg("cannot access temporary indexes of other sessions")));
649 : :
650 : : /* see pgstatindex_impl */
651 [ - + ]: 2 : if (!rel->rd_index->indisvalid)
652 [ # # ]: 0 : ereport(ERROR,
653 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
654 : : errmsg("index \"%s\" is not valid",
655 : : RelationGetRelationName(rel))));
656 : :
657 : : /* Get the information we need from the metapage. */
658 : 2 : memset(&stats, 0, sizeof(stats));
659 : 2 : metabuf = _hash_getbuf(rel, HASH_METAPAGE, HASH_READ, LH_META_PAGE);
660 : 2 : metap = HashPageGetMeta(BufferGetPage(metabuf));
661 : 2 : stats.version = metap->hashm_version;
662 : 2 : stats.space_per_page = metap->hashm_bsize;
663 : 2 : _hash_relbuf(rel, metabuf);
664 : :
665 : : /* Get the current relation length */
666 : 2 : nblocks = RelationGetNumberOfBlocks(rel);
667 : :
668 : : /* prepare access strategy for this index */
669 : 2 : bstrategy = GetAccessStrategy(BAS_BULKREAD);
670 : :
671 : : /* Scan all blocks except the metapage (0th page) using streaming reads */
672 : 2 : startblk = HASH_METAPAGE + 1;
673 : :
674 : 2 : p.current_blocknum = startblk;
675 : 2 : p.last_exclusive = nblocks;
676 : :
677 : : /*
678 : : * It is safe to use batchmode as block_range_read_stream_cb takes no
679 : : * locks.
680 : : */
681 : 2 : stream = read_stream_begin_relation(READ_STREAM_FULL |
682 : : READ_STREAM_USE_BATCHING,
683 : : bstrategy,
684 : : rel,
685 : : MAIN_FORKNUM,
686 : : block_range_read_stream_cb,
687 : : &p,
688 : : 0);
689 : :
690 [ + + ]: 16 : for (blkno = startblk; blkno < nblocks; blkno++)
691 : : {
692 : : Buffer buf;
693 : : Page page;
694 : :
695 [ - + ]: 14 : CHECK_FOR_INTERRUPTS();
696 : :
697 : 14 : buf = read_stream_next_buffer(stream, NULL);
698 : 14 : LockBuffer(buf, BUFFER_LOCK_SHARE);
699 : 14 : page = BufferGetPage(buf);
700 : :
701 [ - + ]: 14 : if (PageIsNew(page))
702 : 0 : stats.unused_pages++;
703 [ - + ]: 14 : else if (PageGetSpecialSize(page) !=
704 : : MAXALIGN(sizeof(HashPageOpaqueData)))
705 [ # # ]: 0 : ereport(ERROR,
706 : : (errcode(ERRCODE_INDEX_CORRUPTED),
707 : : errmsg("index \"%s\" contains corrupted page at block %u",
708 : : RelationGetRelationName(rel),
709 : : BufferGetBlockNumber(buf))));
710 : : else
711 : : {
712 : : HashPageOpaque opaque;
713 : : int pagetype;
714 : :
715 : 14 : opaque = HashPageGetOpaque(page);
716 : 14 : pagetype = opaque->hasho_flag & LH_PAGE_TYPE;
717 : :
718 [ + + ]: 14 : if (pagetype == LH_BUCKET_PAGE)
719 : : {
720 : 12 : stats.bucket_pages++;
721 : 12 : GetHashPageStats(page, &stats);
722 : : }
723 [ - + ]: 2 : else if (pagetype == LH_OVERFLOW_PAGE)
724 : : {
725 : 0 : stats.overflow_pages++;
726 : 0 : GetHashPageStats(page, &stats);
727 : : }
728 [ + - ]: 2 : else if (pagetype == LH_BITMAP_PAGE)
729 : 2 : stats.bitmap_pages++;
730 [ # # ]: 0 : else if (pagetype == LH_UNUSED_PAGE)
731 : 0 : stats.unused_pages++;
732 : : else
733 [ # # ]: 0 : ereport(ERROR,
734 : : (errcode(ERRCODE_INDEX_CORRUPTED),
735 : : errmsg("unexpected page type 0x%04X in HASH index \"%s\" block %u",
736 : : opaque->hasho_flag, RelationGetRelationName(rel),
737 : : BufferGetBlockNumber(buf))));
738 : : }
739 : 14 : UnlockReleaseBuffer(buf);
740 : : }
741 : :
742 : : Assert(read_stream_next_buffer(stream, NULL) == InvalidBuffer);
743 : 2 : read_stream_end(stream);
744 : :
745 : : /* Done accessing the index */
746 : 2 : relation_close(rel, AccessShareLock);
747 : :
748 : : /* Count unused pages as free space. */
749 : 2 : stats.free_space += (uint64) stats.unused_pages * stats.space_per_page;
750 : :
751 : : /*
752 : : * Total space available for tuples excludes the metapage and the bitmap
753 : : * pages.
754 : : */
755 : 2 : total_space = (uint64) (nblocks - (stats.bitmap_pages + 1)) *
756 : 2 : stats.space_per_page;
757 : :
758 [ - + ]: 2 : if (total_space == 0)
759 : 0 : free_percent = 0.0;
760 : : else
761 : 2 : free_percent = 100.0 * stats.free_space / total_space;
762 : :
763 : : /*
764 : : * Build a tuple descriptor for our result type
765 : : */
766 [ - + ]: 2 : if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
767 [ # # ]: 0 : elog(ERROR, "return type must be a row type");
768 : :
769 : 2 : tupleDesc = BlessTupleDesc(tupleDesc);
770 : :
771 : : /*
772 : : * Build and return the tuple
773 : : */
774 : 2 : values[0] = Int32GetDatum(stats.version);
775 : 2 : values[1] = Int64GetDatum((int64) stats.bucket_pages);
776 : 2 : values[2] = Int64GetDatum((int64) stats.overflow_pages);
777 : 2 : values[3] = Int64GetDatum((int64) stats.bitmap_pages);
778 : 2 : values[4] = Int64GetDatum((int64) stats.unused_pages);
779 : 2 : values[5] = Int64GetDatum(stats.live_items);
780 : 2 : values[6] = Int64GetDatum(stats.dead_items);
781 : 2 : values[7] = Float8GetDatum(free_percent);
782 : 2 : tuple = heap_form_tuple(tupleDesc, values, nulls);
783 : :
784 : 2 : PG_RETURN_DATUM(HeapTupleGetDatum(tuple));
785 : : }
786 : :
787 : : /* -------------------------------------------------
788 : : * GetHashPageStats()
789 : : *
790 : : * Collect statistics of single hash page
791 : : * -------------------------------------------------
792 : : */
793 : : static void
794 : 12 : GetHashPageStats(Page page, HashIndexStat *stats)
795 : : {
796 : 12 : OffsetNumber maxoff = PageGetMaxOffsetNumber(page);
797 : : int off;
798 : :
799 : : /* count live and dead tuples, and free space */
800 [ - + ]: 12 : for (off = FirstOffsetNumber; off <= maxoff; off++)
801 : : {
802 : 0 : ItemId id = PageGetItemId(page, off);
803 : :
804 [ # # ]: 0 : if (!ItemIdIsDead(id))
805 : 0 : stats->live_items++;
806 : : else
807 : 0 : stats->dead_items++;
808 : : }
809 : 12 : stats->free_space += PageGetExactFreeSpace(page);
810 : 12 : }
|
