PostgreSQL Source Code git master
hashfuncs.c
Go to the documentation of this file.
1/*
2 * hashfuncs.c
3 * Functions to investigate the content of HASH indexes
4 *
5 * Copyright (c) 2017-2025, PostgreSQL Global Development Group
6 *
7 * IDENTIFICATION
8 * contrib/pageinspect/hashfuncs.c
9 */
10
11#include "postgres.h"
12
13#include "access/hash.h"
14#include "access/htup_details.h"
15#include "access/relation.h"
16#include "catalog/pg_am.h"
17#include "catalog/pg_type.h"
18#include "funcapi.h"
19#include "miscadmin.h"
20#include "pageinspect.h"
21#include "utils/array.h"
22#include "utils/builtins.h"
23#include "utils/rel.h"
24
30
31#define IS_INDEX(r) ((r)->rd_rel->relkind == RELKIND_INDEX)
32#define IS_HASH(r) ((r)->rd_rel->relam == HASH_AM_OID)
33
34/* ------------------------------------------------
35 * structure for single hash page statistics
36 * ------------------------------------------------
37 */
38typedef struct HashPageStat
39{
44
45 /* opaque data */
52
53
54/*
55 * Verify that the given bytea contains a HASH page, or die in the attempt.
56 * A pointer to a palloc'd, properly aligned copy of the page is returned.
57 */
58static Page
59verify_hash_page(bytea *raw_page, int flags)
60{
61 Page page = get_page_from_raw(raw_page);
62 int pagetype = LH_UNUSED_PAGE;
63
64 /* Treat new pages as unused. */
65 if (!PageIsNew(page))
66 {
67 HashPageOpaque pageopaque;
68
71 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
72 errmsg("input page is not a valid %s page", "hash"),
73 errdetail("Expected special size %d, got %d.",
74 (int) MAXALIGN(sizeof(HashPageOpaqueData)),
75 (int) PageGetSpecialSize(page))));
76
77 pageopaque = HashPageGetOpaque(page);
78 if (pageopaque->hasho_page_id != HASHO_PAGE_ID)
80 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
81 errmsg("input page is not a valid %s page", "hash"),
82 errdetail("Expected %08x, got %08x.",
83 HASHO_PAGE_ID, pageopaque->hasho_page_id)));
84
85 pagetype = pageopaque->hasho_flag & LH_PAGE_TYPE;
86 }
87
88 /* Check that page type is sane. */
89 if (pagetype != LH_OVERFLOW_PAGE && pagetype != LH_BUCKET_PAGE &&
90 pagetype != LH_BITMAP_PAGE && pagetype != LH_META_PAGE &&
91 pagetype != LH_UNUSED_PAGE)
93 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
94 errmsg("invalid hash page type %08x", pagetype)));
95
96 /* If requested, verify page type. */
97 if (flags != 0 && (pagetype & flags) == 0)
98 {
99 switch (flags)
100 {
101 case LH_META_PAGE:
103 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
104 errmsg("page is not a hash meta page")));
105 break;
108 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
109 errmsg("page is not a hash bucket or overflow page")));
110 break;
111 case LH_OVERFLOW_PAGE:
113 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
114 errmsg("page is not a hash overflow page")));
115 break;
116 default:
117 elog(ERROR,
118 "hash page of type %08x not in mask %08x",
119 pagetype, flags);
120 break;
121 }
122 }
123
124 /*
125 * If it is the metapage, also verify magic number and version.
126 */
127 if (pagetype == LH_META_PAGE)
128 {
129 HashMetaPage metap = HashPageGetMeta(page);
130
131 if (metap->hashm_magic != HASH_MAGIC)
133 (errcode(ERRCODE_INDEX_CORRUPTED),
134 errmsg("invalid magic number for metadata"),
135 errdetail("Expected 0x%08x, got 0x%08x.",
136 HASH_MAGIC, metap->hashm_magic)));
137
138 if (metap->hashm_version != HASH_VERSION)
140 (errcode(ERRCODE_INDEX_CORRUPTED),
141 errmsg("invalid version for metadata"),
142 errdetail("Expected %d, got %d.",
143 HASH_VERSION, metap->hashm_version)));
144 }
145
146 return page;
147}
148
149/* -------------------------------------------------
150 * GetHashPageStatistics()
151 *
152 * Collect statistics of single hash page
153 * -------------------------------------------------
154 */
155static void
157{
159 HashPageOpaque opaque = HashPageGetOpaque(page);
160 int off;
161
162 stat->dead_items = stat->live_items = 0;
163 stat->page_size = PageGetPageSize(page);
164
165 /* hash page opaque data */
166 stat->hasho_prevblkno = opaque->hasho_prevblkno;
167 stat->hasho_nextblkno = opaque->hasho_nextblkno;
168 stat->hasho_bucket = opaque->hasho_bucket;
169 stat->hasho_flag = opaque->hasho_flag;
170 stat->hasho_page_id = opaque->hasho_page_id;
171
172 /* count live and dead tuples, and free space */
173 for (off = FirstOffsetNumber; off <= maxoff; off++)
174 {
175 ItemId id = PageGetItemId(page, off);
176
177 if (!ItemIdIsDead(id))
178 stat->live_items++;
179 else
180 stat->dead_items++;
181 }
182 stat->free_size = PageGetFreeSpace(page);
183}
184
185/* ---------------------------------------------------
186 * hash_page_type()
187 *
188 * Usage: SELECT hash_page_type(get_raw_page('con_hash_index', 1));
189 * ---------------------------------------------------
190 */
191Datum
193{
194 bytea *raw_page = PG_GETARG_BYTEA_P(0);
195 Page page;
196 HashPageOpaque opaque;
197 int pagetype;
198 const char *type;
199
200 if (!superuser())
202 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
203 errmsg("must be superuser to use raw page functions")));
204
205 page = verify_hash_page(raw_page, 0);
206
207 if (PageIsNew(page))
208 type = "unused";
209 else
210 {
211 opaque = HashPageGetOpaque(page);
212
213 /* page type (flags) */
214 pagetype = opaque->hasho_flag & LH_PAGE_TYPE;
215 if (pagetype == LH_META_PAGE)
216 type = "metapage";
217 else if (pagetype == LH_OVERFLOW_PAGE)
218 type = "overflow";
219 else if (pagetype == LH_BUCKET_PAGE)
220 type = "bucket";
221 else if (pagetype == LH_BITMAP_PAGE)
222 type = "bitmap";
223 else
224 type = "unused";
225 }
226
228}
229
230/* ---------------------------------------------------
231 * hash_page_stats()
232 *
233 * Usage: SELECT * FROM hash_page_stats(get_raw_page('con_hash_index', 1));
234 * ---------------------------------------------------
235 */
236Datum
238{
239 bytea *raw_page = PG_GETARG_BYTEA_P(0);
240 Page page;
241 int j;
242 Datum values[9];
243 bool nulls[9] = {0};
245 HeapTuple tuple;
246 TupleDesc tupleDesc;
247
248 if (!superuser())
250 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
251 errmsg("must be superuser to use raw page functions")));
252
254
255 /* keep compiler quiet */
256 stat.hasho_prevblkno = stat.hasho_nextblkno = InvalidBlockNumber;
257 stat.hasho_flag = stat.hasho_page_id = stat.free_size = 0;
258
260
261 /* Build a tuple descriptor for our result type */
262 if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
263 elog(ERROR, "return type must be a row type");
264 tupleDesc = BlessTupleDesc(tupleDesc);
265
266 j = 0;
267 values[j++] = Int32GetDatum(stat.live_items);
268 values[j++] = Int32GetDatum(stat.dead_items);
269 values[j++] = Int32GetDatum(stat.page_size);
270 values[j++] = Int32GetDatum(stat.free_size);
271 values[j++] = Int64GetDatum((int64) stat.hasho_prevblkno);
272 values[j++] = Int64GetDatum((int64) stat.hasho_nextblkno);
273 values[j++] = Int64GetDatum((int64) stat.hasho_bucket);
274 values[j++] = Int32GetDatum((int32) stat.hasho_flag);
275 values[j++] = Int32GetDatum((int32) stat.hasho_page_id);
276
277 tuple = heap_form_tuple(tupleDesc, values, nulls);
278
280}
281
282/*
283 * cross-call data structure for SRF
284 */
286{
289};
290
291/*-------------------------------------------------------
292 * hash_page_items()
293 *
294 * Get IndexTupleData set in a hash page
295 *
296 * Usage: SELECT * FROM hash_page_items(get_raw_page('con_hash_index', 1));
297 *-------------------------------------------------------
298 */
299Datum
301{
302 bytea *raw_page = PG_GETARG_BYTEA_P(0);
303 Page page;
304 Datum result;
305 Datum values[3];
306 bool nulls[3] = {0};
307 uint32 hashkey;
308 HeapTuple tuple;
309 FuncCallContext *fctx;
310 MemoryContext mctx;
311 struct user_args *uargs;
312
313 if (!superuser())
315 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
316 errmsg("must be superuser to use raw page functions")));
317
318 if (SRF_IS_FIRSTCALL())
319 {
320 TupleDesc tupleDesc;
321
322 fctx = SRF_FIRSTCALL_INIT();
323
325
327
328 uargs = palloc(sizeof(struct user_args));
329
330 uargs->page = page;
331
332 uargs->offset = FirstOffsetNumber;
333
334 fctx->max_calls = PageGetMaxOffsetNumber(uargs->page);
335
336 /* Build a tuple descriptor for our result type */
337 if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
338 elog(ERROR, "return type must be a row type");
339 tupleDesc = BlessTupleDesc(tupleDesc);
340
341 fctx->attinmeta = TupleDescGetAttInMetadata(tupleDesc);
342
343 fctx->user_fctx = uargs;
344
346 }
347
348 fctx = SRF_PERCALL_SETUP();
349 uargs = fctx->user_fctx;
350
351 if (fctx->call_cntr < fctx->max_calls)
352 {
353 ItemId id;
354 IndexTuple itup;
355 int j;
356
357 id = PageGetItemId(uargs->page, uargs->offset);
358
359 if (!ItemIdIsValid(id))
360 elog(ERROR, "invalid ItemId");
361
362 itup = (IndexTuple) PageGetItem(uargs->page, id);
363
364 j = 0;
365 values[j++] = Int32GetDatum((int32) uargs->offset);
366 values[j++] = PointerGetDatum(&itup->t_tid);
367
368 hashkey = _hash_get_indextuple_hashkey(itup);
369 values[j] = Int64GetDatum((int64) hashkey);
370
371 tuple = heap_form_tuple(fctx->attinmeta->tupdesc, values, nulls);
372 result = HeapTupleGetDatum(tuple);
373
374 uargs->offset = uargs->offset + 1;
375
376 SRF_RETURN_NEXT(fctx, result);
377 }
378
379 SRF_RETURN_DONE(fctx);
380}
381
382/* ------------------------------------------------
383 * hash_bitmap_info()
384 *
385 * Get bitmap information for a particular overflow page
386 *
387 * Usage: SELECT * FROM hash_bitmap_info('con_hash_index'::regclass, 5);
388 * ------------------------------------------------
389 */
390Datum
392{
393 Oid indexRelid = PG_GETARG_OID(0);
394 int64 ovflblkno = PG_GETARG_INT64(1);
395 HashMetaPage metap;
396 Buffer metabuf,
397 mapbuf;
398 BlockNumber bitmapblkno;
399 Page mappage;
400 bool bit = false;
401 TupleDesc tupleDesc;
402 Relation indexRel;
403 uint32 ovflbitno;
404 int32 bitmappage,
405 bitmapbit;
406 HeapTuple tuple;
407 int i,
408 j;
409 Datum values[3];
410 bool nulls[3] = {0};
411 uint32 *freep;
412
413 if (!superuser())
415 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
416 errmsg("must be superuser to use raw page functions")));
417
418 indexRel = relation_open(indexRelid, AccessShareLock);
419
420 if (!IS_INDEX(indexRel) || !IS_HASH(indexRel))
422 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
423 errmsg("\"%s\" is not a %s index",
424 RelationGetRelationName(indexRel), "hash")));
425
426 if (RELATION_IS_OTHER_TEMP(indexRel))
428 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
429 errmsg("cannot access temporary tables of other sessions")));
430
431 if (ovflblkno < 0 || ovflblkno > MaxBlockNumber)
433 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
434 errmsg("invalid block number")));
435
436 if (ovflblkno >= RelationGetNumberOfBlocks(indexRel))
438 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
439 errmsg("block number %lld is out of range for relation \"%s\"",
440 (long long int) ovflblkno, RelationGetRelationName(indexRel))));
441
442 /* Read the metapage so we can determine which bitmap page to use */
443 metabuf = _hash_getbuf(indexRel, HASH_METAPAGE, HASH_READ, LH_META_PAGE);
444 metap = HashPageGetMeta(BufferGetPage(metabuf));
445
446 /*
447 * Reject attempt to read the bit for a metapage or bitmap page; this is
448 * only meaningful for overflow pages.
449 */
450 if (ovflblkno == 0)
452 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
453 errmsg("invalid overflow block number %u",
454 (BlockNumber) ovflblkno)));
455 for (i = 0; i < metap->hashm_nmaps; i++)
456 if (metap->hashm_mapp[i] == ovflblkno)
458 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
459 errmsg("invalid overflow block number %u",
460 (BlockNumber) ovflblkno)));
461
462 /*
463 * Identify overflow bit number. This will error out for primary bucket
464 * pages, and we've already rejected the metapage and bitmap pages above.
465 */
466 ovflbitno = _hash_ovflblkno_to_bitno(metap, (BlockNumber) ovflblkno);
467
468 bitmappage = ovflbitno >> BMPG_SHIFT(metap);
469 bitmapbit = ovflbitno & BMPG_MASK(metap);
470
471 if (bitmappage >= metap->hashm_nmaps)
473 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
474 errmsg("invalid overflow block number %u",
475 (BlockNumber) ovflblkno)));
476
477 bitmapblkno = metap->hashm_mapp[bitmappage];
478
479 _hash_relbuf(indexRel, metabuf);
480
481 /* Check the status of bitmap bit for overflow page */
482 mapbuf = _hash_getbuf(indexRel, bitmapblkno, HASH_READ, LH_BITMAP_PAGE);
483 mappage = BufferGetPage(mapbuf);
484 freep = HashPageGetBitmap(mappage);
485
486 bit = ISSET(freep, bitmapbit) != 0;
487
488 _hash_relbuf(indexRel, mapbuf);
489 index_close(indexRel, AccessShareLock);
490
491 /* Build a tuple descriptor for our result type */
492 if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
493 elog(ERROR, "return type must be a row type");
494 tupleDesc = BlessTupleDesc(tupleDesc);
495
496 j = 0;
497 values[j++] = Int64GetDatum((int64) bitmapblkno);
498 values[j++] = Int32GetDatum(bitmapbit);
499 values[j++] = BoolGetDatum(bit);
500
501 tuple = heap_form_tuple(tupleDesc, values, nulls);
502
504}
505
506/* ------------------------------------------------
507 * hash_metapage_info()
508 *
509 * Get the meta-page information for a hash index
510 *
511 * Usage: SELECT * FROM hash_metapage_info(get_raw_page('con_hash_index', 0))
512 * ------------------------------------------------
513 */
514Datum
516{
517 bytea *raw_page = PG_GETARG_BYTEA_P(0);
518 Page page;
519 HashMetaPageData *metad;
520 TupleDesc tupleDesc;
521 HeapTuple tuple;
522 int i,
523 j;
524 Datum values[16];
525 bool nulls[16] = {0};
528
529 if (!superuser())
531 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
532 errmsg("must be superuser to use raw page functions")));
533
535
536 /* Build a tuple descriptor for our result type */
537 if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
538 elog(ERROR, "return type must be a row type");
539 tupleDesc = BlessTupleDesc(tupleDesc);
540
541 metad = HashPageGetMeta(page);
542
543 j = 0;
544 values[j++] = Int64GetDatum((int64) metad->hashm_magic);
548 values[j++] = Int32GetDatum((int32) metad->hashm_bsize);
549 values[j++] = Int32GetDatum((int32) metad->hashm_bmsize);
556 values[j++] = Int64GetDatum((int64) metad->hashm_nmaps);
558
559 for (i = 0; i < HASH_MAX_SPLITPOINTS; i++)
560 spares[i] = Int64GetDatum((int64) metad->hashm_spares[i]);
562
563 for (i = 0; i < HASH_MAX_BITMAPS; i++)
564 mapp[i] = Int64GetDatum((int64) metad->hashm_mapp[i]);
566
567 tuple = heap_form_tuple(tupleDesc, values, nulls);
568
570}
ArrayType * construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
Definition: arrayfuncs.c:3381
uint32 BlockNumber
Definition: block.h:31
#define InvalidBlockNumber
Definition: block.h:33
#define MaxBlockNumber
Definition: block.h:35
static Datum values[MAXATTR]
Definition: bootstrap.c:151
int Buffer
Definition: buf.h:23
#define RelationGetNumberOfBlocks(reln)
Definition: bufmgr.h:273
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:396
Size PageGetFreeSpace(const PageData *page)
Definition: bufpage.c:896
static uint16 PageGetSpecialSize(const PageData *page)
Definition: bufpage.h:317
static Size PageGetPageSize(const PageData *page)
Definition: bufpage.h:277
static Item PageGetItem(const PageData *page, const ItemIdData *itemId)
Definition: bufpage.h:354
static bool PageIsNew(const PageData *page)
Definition: bufpage.h:234
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:244
PageData * Page
Definition: bufpage.h:82
static OffsetNumber PageGetMaxOffsetNumber(const PageData *page)
Definition: bufpage.h:372
#define MAXALIGN(LEN)
Definition: c.h:768
int64_t int64
Definition: c.h:485
int32_t int32
Definition: c.h:484
uint16_t uint16
Definition: c.h:487
uint32_t uint32
Definition: c.h:488
int errdetail(const char *fmt,...)
Definition: elog.c:1203
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
#define ereport(elevel,...)
Definition: elog.h:149
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
Definition: execTuples.c:2258
AttInMetadata * TupleDescGetAttInMetadata(TupleDesc tupdesc)
Definition: execTuples.c:2273
Datum Int64GetDatum(int64 X)
Definition: fmgr.c:1807
Datum Float8GetDatum(float8 X)
Definition: fmgr.c:1816
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
#define PG_GETARG_INT64(n)
Definition: fmgr.h:283
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:372
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:353
#define PG_GETARG_BYTEA_P(n)
Definition: fmgr.h:335
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo, Oid *resultTypeId, TupleDesc *resultTupleDesc)
Definition: funcapi.c:276
#define SRF_IS_FIRSTCALL()
Definition: funcapi.h:304
#define SRF_PERCALL_SETUP()
Definition: funcapi.h:308
@ TYPEFUNC_COMPOSITE
Definition: funcapi.h:149
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition: funcapi.h:310
#define SRF_FIRSTCALL_INIT()
Definition: funcapi.h:306
static Datum HeapTupleGetDatum(const HeapTupleData *tuple)
Definition: funcapi.h:230
#define SRF_RETURN_DONE(_funcctx)
Definition: funcapi.h:328
#define HashPageGetOpaque(page)
Definition: hash.h:88
#define LH_BUCKET_PAGE
Definition: hash.h:55
#define HASH_MAX_BITMAPS
Definition: hash.h:230
#define BMPG_MASK(metap)
Definition: hash.h:314
#define HASH_VERSION
Definition: hash.h:201
#define HASH_MAX_SPLITPOINTS
Definition: hash.h:239
#define LH_UNUSED_PAGE
Definition: hash.h:53
#define HashPageGetBitmap(page)
Definition: hash.h:316
#define LH_META_PAGE
Definition: hash.h:57
#define HASHO_PAGE_ID
Definition: hash.h:101
#define ISSET(A, N)
Definition: hash.h:334
#define HashPageGetMeta(page)
Definition: hash.h:323
#define HASH_READ
Definition: hash.h:339
#define HASH_METAPAGE
Definition: hash.h:198
#define LH_PAGE_TYPE
Definition: hash.h:63
uint32 Bucket
Definition: hash.h:35
#define LH_BITMAP_PAGE
Definition: hash.h:56
#define BMPG_SHIFT(metap)
Definition: hash.h:313
#define HASH_MAGIC
Definition: hash.h:200
#define LH_OVERFLOW_PAGE
Definition: hash.h:54
#define IS_HASH(r)
Definition: hashfuncs.c:32
Datum hash_bitmap_info(PG_FUNCTION_ARGS)
Definition: hashfuncs.c:391
Datum hash_page_stats(PG_FUNCTION_ARGS)
Definition: hashfuncs.c:237
PG_FUNCTION_INFO_V1(hash_page_type)
Datum hash_page_type(PG_FUNCTION_ARGS)
Definition: hashfuncs.c:192
#define IS_INDEX(r)
Definition: hashfuncs.c:31
Datum hash_metapage_info(PG_FUNCTION_ARGS)
Definition: hashfuncs.c:515
struct HashPageStat HashPageStat
static Page verify_hash_page(bytea *raw_page, int flags)
Definition: hashfuncs.c:59
static void GetHashPageStatistics(Page page, HashPageStat *stat)
Definition: hashfuncs.c:156
Datum hash_page_items(PG_FUNCTION_ARGS)
Definition: hashfuncs.c:300
uint32 _hash_ovflblkno_to_bitno(HashMetaPage metap, BlockNumber ovflblkno)
Definition: hashovfl.c:62
void _hash_relbuf(Relation rel, Buffer buf)
Definition: hashpage.c:266
Buffer _hash_getbuf(Relation rel, BlockNumber blkno, int access, int flags)
Definition: hashpage.c:70
uint32 _hash_get_indextuple_hashkey(IndexTuple itup)
Definition: hashutil.c:291
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: heaptuple.c:1117
void index_close(Relation relation, LOCKMODE lockmode)
Definition: indexam.c:177
int j
Definition: isn.c:73
int i
Definition: isn.c:72
#define ItemIdIsDead(itemId)
Definition: itemid.h:113
#define ItemIdIsValid(itemId)
Definition: itemid.h:86
IndexTupleData * IndexTuple
Definition: itup.h:53
#define AccessShareLock
Definition: lockdefs.h:36
void * palloc(Size size)
Definition: mcxt.c:1317
uint16 OffsetNumber
Definition: off.h:24
#define FirstOffsetNumber
Definition: off.h:27
Page get_page_from_raw(bytea *raw_page)
Definition: rawpage.c:215
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:327
uintptr_t Datum
Definition: postgres.h:69
static Datum BoolGetDatum(bool X)
Definition: postgres.h:107
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:257
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:217
unsigned int Oid
Definition: postgres_ext.h:32
#define RelationGetRelationName(relation)
Definition: rel.h:546
#define RELATION_IS_OTHER_TEMP(relation)
Definition: rel.h:665
Relation relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:47
TupleDesc tupdesc
Definition: funcapi.h:38
void * user_fctx
Definition: funcapi.h:82
uint64 max_calls
Definition: funcapi.h:74
uint64 call_cntr
Definition: funcapi.h:65
AttInMetadata * attinmeta
Definition: funcapi.h:91
MemoryContext multi_call_memory_ctx
Definition: funcapi.h:101
uint32 hashm_version
Definition: hash.h:247
BlockNumber hashm_mapp[HASH_MAX_BITMAPS]
Definition: hash.h:264
uint32 hashm_lowmask
Definition: hash.h:256
uint32 hashm_maxbucket
Definition: hash.h:254
RegProcedure hashm_procid
Definition: hash.h:261
uint32 hashm_spares[HASH_MAX_SPLITPOINTS]
Definition: hash.h:262
double hashm_ntuples
Definition: hash.h:248
uint32 hashm_firstfree
Definition: hash.h:259
uint16 hashm_bmsize
Definition: hash.h:251
uint16 hashm_bsize
Definition: hash.h:250
uint32 hashm_ovflpoint
Definition: hash.h:257
uint32 hashm_highmask
Definition: hash.h:255
uint32 hashm_magic
Definition: hash.h:246
uint16 hashm_bmshift
Definition: hash.h:253
uint32 hashm_nmaps
Definition: hash.h:260
uint16 hashm_ffactor
Definition: hash.h:249
BlockNumber hasho_nextblkno
Definition: hash.h:80
uint16 hasho_flag
Definition: hash.h:82
BlockNumber hasho_prevblkno
Definition: hash.h:79
uint16 hasho_page_id
Definition: hash.h:83
Bucket hasho_bucket
Definition: hash.h:81
BlockNumber hasho_prevblkno
Definition: hashfuncs.c:46
int page_size
Definition: hashfuncs.c:42
int dead_items
Definition: hashfuncs.c:41
uint16 hasho_page_id
Definition: hashfuncs.c:50
int live_items
Definition: hashfuncs.c:40
Bucket hasho_bucket
Definition: hashfuncs.c:48
int free_size
Definition: hashfuncs.c:43
uint16 hasho_flag
Definition: hashfuncs.c:49
BlockNumber hasho_nextblkno
Definition: hashfuncs.c:47
ItemPointerData t_tid
Definition: itup.h:37
OffsetNumber offset
Definition: hashfuncs.c:288
Page page
Definition: hashfuncs.c:287
Definition: c.h:644
bool superuser(void)
Definition: superuser.c:46
Datum bit(PG_FUNCTION_ARGS)
Definition: varbit.c:391
text * cstring_to_text(const char *s)
Definition: varlena.c:184
const char * type
#define stat
Definition: win32_port.h:274