Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * pgstatapprox.c
4 : : * Bloat estimation functions
5 : : *
6 : : * Copyright (c) 2014-2024, PostgreSQL Global Development Group
7 : : *
8 : : * IDENTIFICATION
9 : : * contrib/pgstattuple/pgstatapprox.c
10 : : *
11 : : *-------------------------------------------------------------------------
12 : : */
13 : : #include "postgres.h"
14 : :
15 : : #include "access/heapam.h"
16 : : #include "access/htup_details.h"
17 : : #include "access/multixact.h"
18 : : #include "access/relation.h"
19 : : #include "access/transam.h"
20 : : #include "access/visibilitymap.h"
21 : : #include "access/xact.h"
22 : : #include "catalog/namespace.h"
23 : : #include "catalog/pg_am_d.h"
24 : : #include "commands/vacuum.h"
25 : : #include "funcapi.h"
26 : : #include "miscadmin.h"
27 : : #include "storage/bufmgr.h"
28 : : #include "storage/freespace.h"
29 : : #include "storage/lmgr.h"
30 : : #include "storage/procarray.h"
31 : : #include "utils/builtins.h"
32 : :
3259 andres@anarazel.de 33 :CBC 1 : PG_FUNCTION_INFO_V1(pgstattuple_approx);
2754 sfrost@snowman.net 34 : 2 : PG_FUNCTION_INFO_V1(pgstattuple_approx_v1_5);
35 : :
36 : : Datum pgstattuple_approx_internal(Oid relid, FunctionCallInfo fcinfo);
37 : :
38 : : typedef struct output_type
39 : : {
40 : : uint64 table_len;
41 : : double scanned_percent;
42 : : uint64 tuple_count;
43 : : uint64 tuple_len;
44 : : double tuple_percent;
45 : : uint64 dead_tuple_count;
46 : : uint64 dead_tuple_len;
47 : : double dead_tuple_percent;
48 : : uint64 free_space;
49 : : double free_percent;
50 : : } output_type;
51 : :
52 : : #define NUM_OUTPUT_COLUMNS 10
53 : :
54 : : /*
55 : : * This function takes an already open relation and scans its pages,
56 : : * skipping those that have the corresponding visibility map bit set.
57 : : * For pages we skip, we find the free space from the free space map
58 : : * and approximate tuple_len on that basis. For the others, we count
59 : : * the exact number of dead tuples etc.
60 : : *
61 : : * This scan is loosely based on vacuumlazy.c:lazy_scan_heap(), but
62 : : * we do not try to avoid skipping single pages.
63 : : */
64 : : static void
3259 andres@anarazel.de 65 : 2 : statapprox_heap(Relation rel, output_type *stat)
66 : : {
67 : : BlockNumber scanned,
68 : : nblocks,
69 : : blkno;
70 : 2 : Buffer vmbuffer = InvalidBuffer;
71 : : BufferAccessStrategy bstrategy;
72 : : TransactionId OldestXmin;
73 : :
1341 74 : 2 : OldestXmin = GetOldestNonRemovableTransactionId(rel);
3259 75 : 2 : bstrategy = GetAccessStrategy(BAS_BULKREAD);
76 : :
77 : 2 : nblocks = RelationGetNumberOfBlocks(rel);
78 : 2 : scanned = 0;
79 : :
80 [ - + ]: 2 : for (blkno = 0; blkno < nblocks; blkno++)
81 : : {
82 : : Buffer buf;
83 : : Page page;
84 : : OffsetNumber offnum,
85 : : maxoff;
86 : : Size freespace;
87 : :
3259 andres@anarazel.de 88 [ # # ]:UBC 0 : CHECK_FOR_INTERRUPTS();
89 : :
90 : : /*
91 : : * If the page has only visible tuples, then we can find out the free
92 : : * space from the FSM and move on.
93 : : */
2966 rhaas@postgresql.org 94 [ # # ]: 0 : if (VM_ALL_VISIBLE(rel, blkno, &vmbuffer))
95 : : {
3259 andres@anarazel.de 96 : 0 : freespace = GetRecordedFreeSpace(rel, blkno);
97 : 0 : stat->tuple_len += BLCKSZ - freespace;
98 : 0 : stat->free_space += freespace;
99 : 0 : continue;
100 : : }
101 : :
102 : 0 : buf = ReadBufferExtended(rel, MAIN_FORKNUM, blkno,
103 : : RBM_NORMAL, bstrategy);
104 : :
105 : 0 : LockBuffer(buf, BUFFER_LOCK_SHARE);
106 : :
2916 kgrittn@postgresql.o 107 : 0 : page = BufferGetPage(buf);
108 : :
109 : : /*
110 : : * It's not safe to call PageGetHeapFreeSpace() on new pages, so we
111 : : * treat them as being free space for our purposes.
112 : : */
3259 andres@anarazel.de 113 [ # # ]: 0 : if (!PageIsNew(page))
114 : 0 : stat->free_space += PageGetHeapFreeSpace(page);
115 : : else
116 : 0 : stat->free_space += BLCKSZ - SizeOfPageHeaderData;
117 : :
118 : : /* We may count the page as scanned even if it's new/empty */
2215 tgl@sss.pgh.pa.us 119 : 0 : scanned++;
120 : :
3259 andres@anarazel.de 121 [ # # # # ]: 0 : if (PageIsNew(page) || PageIsEmpty(page))
122 : : {
123 : 0 : UnlockReleaseBuffer(buf);
124 : 0 : continue;
125 : : }
126 : :
127 : : /*
128 : : * Look at each tuple on the page and decide whether it's live or
129 : : * dead, then count it and its size. Unlike lazy_scan_heap, we can
130 : : * afford to ignore problems and special cases.
131 : : */
132 : 0 : maxoff = PageGetMaxOffsetNumber(page);
133 : :
134 : 0 : for (offnum = FirstOffsetNumber;
135 [ # # ]: 0 : offnum <= maxoff;
136 : 0 : offnum = OffsetNumberNext(offnum))
137 : : {
138 : : ItemId itemid;
139 : : HeapTupleData tuple;
140 : :
141 : 0 : itemid = PageGetItemId(page, offnum);
142 : :
143 [ # # # # ]: 0 : if (!ItemIdIsUsed(itemid) || ItemIdIsRedirected(itemid) ||
144 [ # # ]: 0 : ItemIdIsDead(itemid))
145 : : {
146 : 0 : continue;
147 : : }
148 : :
149 [ # # ]: 0 : Assert(ItemIdIsNormal(itemid));
150 : :
151 : 0 : ItemPointerSet(&(tuple.t_self), blkno, offnum);
152 : :
153 : 0 : tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
154 : 0 : tuple.t_len = ItemIdGetLength(itemid);
155 : 0 : tuple.t_tableOid = RelationGetRelid(rel);
156 : :
157 : : /*
158 : : * We follow VACUUM's lead in counting INSERT_IN_PROGRESS tuples
159 : : * as "dead" while DELETE_IN_PROGRESS tuples are "live". We don't
160 : : * bother distinguishing tuples inserted/deleted by our own
161 : : * transaction.
162 : : */
163 [ # # # ]: 0 : switch (HeapTupleSatisfiesVacuum(&tuple, OldestXmin, buf))
164 : : {
165 : 0 : case HEAPTUPLE_LIVE:
166 : : case HEAPTUPLE_DELETE_IN_PROGRESS:
167 : 0 : stat->tuple_len += tuple.t_len;
168 : 0 : stat->tuple_count++;
169 : 0 : break;
2215 tgl@sss.pgh.pa.us 170 : 0 : case HEAPTUPLE_DEAD:
171 : : case HEAPTUPLE_RECENTLY_DEAD:
172 : : case HEAPTUPLE_INSERT_IN_PROGRESS:
173 : 0 : stat->dead_tuple_len += tuple.t_len;
174 : 0 : stat->dead_tuple_count++;
3259 andres@anarazel.de 175 : 0 : break;
176 : 0 : default:
177 [ # # ]: 0 : elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result");
178 : : break;
179 : : }
180 : : }
181 : :
182 : 0 : UnlockReleaseBuffer(buf);
183 : : }
184 : :
2489 tgl@sss.pgh.pa.us 185 :CBC 2 : stat->table_len = (uint64) nblocks * BLCKSZ;
186 : :
187 : : /*
188 : : * We don't know how many tuples are in the pages we didn't scan, so
189 : : * extrapolate the live-tuple count to the whole table in the same way
190 : : * that VACUUM does. (Like VACUUM, we're not taking a random sample, so
191 : : * just extrapolating linearly seems unsafe.) There should be no dead
192 : : * tuples in all-visible pages, so no correction is needed for that, and
193 : : * we already accounted for the space in those pages, too.
194 : : */
2224 195 : 4 : stat->tuple_count = vac_estimate_reltuples(rel, nblocks, scanned,
2215 196 : 2 : stat->tuple_count);
197 : :
198 : : /* It's not clear if we could get -1 here, but be safe. */
1323 199 : 2 : stat->tuple_count = Max(stat->tuple_count, 0);
200 : :
201 : : /*
202 : : * Calculate percentages if the relation has one or more pages.
203 : : */
3259 andres@anarazel.de 204 [ - + ]: 2 : if (nblocks != 0)
205 : : {
580 peter@eisentraut.org 206 :UBC 0 : stat->scanned_percent = 100.0 * scanned / nblocks;
3259 andres@anarazel.de 207 : 0 : stat->tuple_percent = 100.0 * stat->tuple_len / stat->table_len;
208 : 0 : stat->dead_tuple_percent = 100.0 * stat->dead_tuple_len / stat->table_len;
209 : 0 : stat->free_percent = 100.0 * stat->free_space / stat->table_len;
210 : : }
211 : :
3259 andres@anarazel.de 212 [ - + ]:CBC 2 : if (BufferIsValid(vmbuffer))
213 : : {
3259 andres@anarazel.de 214 :UBC 0 : ReleaseBuffer(vmbuffer);
215 : 0 : vmbuffer = InvalidBuffer;
216 : : }
3259 andres@anarazel.de 217 :CBC 2 : }
218 : :
219 : : /*
220 : : * Returns estimated live/dead tuple statistics for the given relid.
221 : : *
222 : : * The superuser() check here must be kept as the library might be upgraded
223 : : * without the extension being upgraded, meaning that in pre-1.5 installations
224 : : * these functions could be called by any user.
225 : : */
226 : : Datum
3259 andres@anarazel.de 227 :UBC 0 : pgstattuple_approx(PG_FUNCTION_ARGS)
228 : : {
229 : 0 : Oid relid = PG_GETARG_OID(0);
230 : :
2754 sfrost@snowman.net 231 [ # # ]: 0 : if (!superuser())
232 [ # # ]: 0 : ereport(ERROR,
233 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
234 : : errmsg("must be superuser to use pgstattuple functions")));
235 : :
236 : 0 : PG_RETURN_DATUM(pgstattuple_approx_internal(relid, fcinfo));
237 : : }
238 : :
239 : : /*
240 : : * As of pgstattuple version 1.5, we no longer need to check if the user
241 : : * is a superuser because we REVOKE EXECUTE on the SQL function from PUBLIC.
242 : : * Users can then grant access to it based on their policies.
243 : : *
244 : : * Otherwise identical to pgstattuple_approx (above).
245 : : */
246 : : Datum
2754 sfrost@snowman.net 247 :CBC 5 : pgstattuple_approx_v1_5(PG_FUNCTION_ARGS)
248 : : {
249 : 5 : Oid relid = PG_GETARG_OID(0);
250 : :
251 : 5 : PG_RETURN_DATUM(pgstattuple_approx_internal(relid, fcinfo));
252 : : }
253 : :
254 : : Datum
255 : 5 : pgstattuple_approx_internal(Oid relid, FunctionCallInfo fcinfo)
256 : : {
257 : : Relation rel;
3259 andres@anarazel.de 258 : 5 : output_type stat = {0};
259 : : TupleDesc tupdesc;
260 : : bool nulls[NUM_OUTPUT_COLUMNS];
261 : : Datum values[NUM_OUTPUT_COLUMNS];
262 : : HeapTuple ret;
263 : 5 : int i = 0;
264 : :
265 [ - + ]: 5 : if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
3259 andres@anarazel.de 266 [ # # ]:UBC 0 : elog(ERROR, "return type must be a row type");
267 : :
3259 andres@anarazel.de 268 [ - + ]:CBC 5 : if (tupdesc->natts != NUM_OUTPUT_COLUMNS)
3259 andres@anarazel.de 269 [ # # ]:UBC 0 : elog(ERROR, "incorrect number of output arguments");
270 : :
3259 andres@anarazel.de 271 :CBC 5 : rel = relation_open(relid, AccessShareLock);
272 : :
273 : : /*
274 : : * Reject attempts to read non-local temporary relations; we would be
275 : : * likely to get wrong data since we have no visibility into the owning
276 : : * session's local buffers.
277 : : */
278 [ - + - - ]: 5 : if (RELATION_IS_OTHER_TEMP(rel))
3259 andres@anarazel.de 279 [ # # ]:UBC 0 : ereport(ERROR,
280 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
281 : : errmsg("cannot access temporary tables of other sessions")));
282 : :
283 : : /*
284 : : * We support only relation kinds with a visibility map and a free space
285 : : * map.
286 : : */
3259 andres@anarazel.de 287 [ + + ]:CBC 5 : if (!(rel->rd_rel->relkind == RELKIND_RELATION ||
1384 peter@eisentraut.org 288 [ + - ]: 4 : rel->rd_rel->relkind == RELKIND_MATVIEW ||
289 [ + + ]: 4 : rel->rd_rel->relkind == RELKIND_TOASTVALUE))
3259 andres@anarazel.de 290 [ + - ]: 3 : ereport(ERROR,
291 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
292 : : errmsg("relation \"%s\" is of wrong relation kind",
293 : : RelationGetRelationName(rel)),
294 : : errdetail_relkind_not_supported(rel->rd_rel->relkind)));
295 : :
1840 296 [ - + ]: 2 : if (rel->rd_rel->relam != HEAP_TABLE_AM_OID)
1840 andres@anarazel.de 297 [ # # ]:UBC 0 : ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
298 : : errmsg("only heap AM is supported")));
299 : :
3259 andres@anarazel.de 300 :CBC 2 : statapprox_heap(rel, &stat);
301 : :
302 : 2 : relation_close(rel, AccessShareLock);
303 : :
304 : 2 : memset(nulls, 0, sizeof(nulls));
305 : :
306 : 2 : values[i++] = Int64GetDatum(stat.table_len);
307 : 2 : values[i++] = Float8GetDatum(stat.scanned_percent);
308 : 2 : values[i++] = Int64GetDatum(stat.tuple_count);
309 : 2 : values[i++] = Int64GetDatum(stat.tuple_len);
310 : 2 : values[i++] = Float8GetDatum(stat.tuple_percent);
311 : 2 : values[i++] = Int64GetDatum(stat.dead_tuple_count);
312 : 2 : values[i++] = Int64GetDatum(stat.dead_tuple_len);
313 : 2 : values[i++] = Float8GetDatum(stat.dead_tuple_percent);
314 : 2 : values[i++] = Int64GetDatum(stat.free_space);
315 : 2 : values[i++] = Float8GetDatum(stat.free_percent);
316 : :
3249 bruce@momjian.us 317 : 2 : ret = heap_form_tuple(tupdesc, values, nulls);
3259 andres@anarazel.de 318 : 2 : return HeapTupleGetDatum(ret);
319 : : }
|
