Line data Source code
1 : /*
2 : * hashfuncs.c
3 : * Functions to investigate the content of HASH indexes
4 : *
5 : * Copyright (c) 2017-2026, 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 :
25 8 : PG_FUNCTION_INFO_V1(hash_page_type);
26 8 : PG_FUNCTION_INFO_V1(hash_page_stats);
27 8 : PG_FUNCTION_INFO_V1(hash_page_items);
28 8 : PG_FUNCTION_INFO_V1(hash_bitmap_info);
29 8 : PG_FUNCTION_INFO_V1(hash_metapage_info);
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 : */
38 : typedef struct HashPageStat
39 : {
40 : int live_items;
41 : int dead_items;
42 : int page_size;
43 : int free_size;
44 :
45 : /* opaque data */
46 : BlockNumber hasho_prevblkno;
47 : BlockNumber hasho_nextblkno;
48 : Bucket hasho_bucket;
49 : uint16 hasho_flag;
50 : uint16 hasho_page_id;
51 : } HashPageStat;
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 : */
58 : static Page
59 36 : verify_hash_page(bytea *raw_page, int flags)
60 : {
61 36 : Page page = get_page_from_raw(raw_page);
62 32 : int pagetype = LH_UNUSED_PAGE;
63 :
64 : /* Treat new pages as unused. */
65 32 : if (!PageIsNew(page))
66 : {
67 : HashPageOpaque pageopaque;
68 :
69 28 : if (PageGetSpecialSize(page) != MAXALIGN(sizeof(HashPageOpaqueData)))
70 4 : ereport(ERROR,
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 24 : pageopaque = HashPageGetOpaque(page);
78 24 : if (pageopaque->hasho_page_id != HASHO_PAGE_ID)
79 0 : ereport(ERROR,
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 24 : pagetype = pageopaque->hasho_flag & LH_PAGE_TYPE;
86 : }
87 :
88 : /* Check that page type is sane. */
89 28 : if (pagetype != LH_OVERFLOW_PAGE && pagetype != LH_BUCKET_PAGE &&
90 8 : pagetype != LH_BITMAP_PAGE && pagetype != LH_META_PAGE &&
91 : pagetype != LH_UNUSED_PAGE)
92 0 : ereport(ERROR,
93 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
94 : errmsg("invalid hash page type %08x", pagetype)));
95 :
96 : /* If requested, verify page type. */
97 28 : if (flags != 0 && (pagetype & flags) == 0)
98 : {
99 12 : switch (flags)
100 : {
101 6 : case LH_META_PAGE:
102 6 : ereport(ERROR,
103 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
104 : errmsg("page is not a hash meta page")));
105 : break;
106 6 : case LH_BUCKET_PAGE | LH_OVERFLOW_PAGE:
107 6 : ereport(ERROR,
108 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
109 : errmsg("page is not a hash bucket or overflow page")));
110 : break;
111 0 : case LH_OVERFLOW_PAGE:
112 0 : ereport(ERROR,
113 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
114 : errmsg("page is not a hash overflow page")));
115 : break;
116 0 : default:
117 0 : 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 16 : if (pagetype == LH_META_PAGE)
128 : {
129 2 : HashMetaPage metap = HashPageGetMeta(page);
130 :
131 2 : if (metap->hashm_magic != HASH_MAGIC)
132 0 : ereport(ERROR,
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 2 : if (metap->hashm_version != HASH_VERSION)
139 0 : ereport(ERROR,
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 16 : return page;
147 : }
148 :
149 : /* -------------------------------------------------
150 : * GetHashPageStatistics()
151 : *
152 : * Collect statistics of single hash page
153 : * -------------------------------------------------
154 : */
155 : static void
156 4 : GetHashPageStatistics(Page page, HashPageStat *stat)
157 : {
158 4 : OffsetNumber maxoff = PageGetMaxOffsetNumber(page);
159 4 : HashPageOpaque opaque = HashPageGetOpaque(page);
160 : int off;
161 :
162 4 : stat->dead_items = stat->live_items = 0;
163 4 : stat->page_size = PageGetPageSize(page);
164 :
165 : /* hash page opaque data */
166 4 : stat->hasho_prevblkno = opaque->hasho_prevblkno;
167 4 : stat->hasho_nextblkno = opaque->hasho_nextblkno;
168 4 : stat->hasho_bucket = opaque->hasho_bucket;
169 4 : stat->hasho_flag = opaque->hasho_flag;
170 4 : stat->hasho_page_id = opaque->hasho_page_id;
171 :
172 : /* count live and dead tuples, and free space */
173 5 : for (off = FirstOffsetNumber; off <= maxoff; off++)
174 : {
175 1 : ItemId id = PageGetItemId(page, off);
176 :
177 1 : if (!ItemIdIsDead(id))
178 1 : stat->live_items++;
179 : else
180 0 : stat->dead_items++;
181 : }
182 4 : stat->free_size = PageGetFreeSpace(page);
183 4 : }
184 :
185 : /* ---------------------------------------------------
186 : * hash_page_type()
187 : *
188 : * Usage: SELECT hash_page_type(get_raw_page('con_hash_index', 1));
189 : * ---------------------------------------------------
190 : */
191 : Datum
192 9 : hash_page_type(PG_FUNCTION_ARGS)
193 : {
194 9 : bytea *raw_page = PG_GETARG_BYTEA_P(0);
195 : Page page;
196 : HashPageOpaque opaque;
197 : int pagetype;
198 : const char *type;
199 :
200 9 : if (!superuser())
201 0 : ereport(ERROR,
202 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
203 : errmsg("must be superuser to use raw page functions")));
204 :
205 9 : page = verify_hash_page(raw_page, 0);
206 :
207 7 : if (PageIsNew(page))
208 1 : type = "unused";
209 : else
210 : {
211 6 : opaque = HashPageGetOpaque(page);
212 :
213 : /* page type (flags) */
214 6 : pagetype = opaque->hasho_flag & LH_PAGE_TYPE;
215 6 : if (pagetype == LH_META_PAGE)
216 1 : type = "metapage";
217 5 : else if (pagetype == LH_OVERFLOW_PAGE)
218 0 : type = "overflow";
219 5 : else if (pagetype == LH_BUCKET_PAGE)
220 4 : type = "bucket";
221 1 : else if (pagetype == LH_BITMAP_PAGE)
222 1 : type = "bitmap";
223 : else
224 0 : type = "unused";
225 : }
226 :
227 7 : PG_RETURN_TEXT_P(cstring_to_text(type));
228 : }
229 :
230 : /* ---------------------------------------------------
231 : * hash_page_stats()
232 : *
233 : * Usage: SELECT * FROM hash_page_stats(get_raw_page('con_hash_index', 1));
234 : * ---------------------------------------------------
235 : */
236 : Datum
237 9 : hash_page_stats(PG_FUNCTION_ARGS)
238 : {
239 9 : bytea *raw_page = PG_GETARG_BYTEA_P(0);
240 : Page page;
241 : int j;
242 : Datum values[9];
243 9 : bool nulls[9] = {0};
244 : HashPageStat stat;
245 : HeapTuple tuple;
246 : TupleDesc tupleDesc;
247 :
248 9 : if (!superuser())
249 0 : ereport(ERROR,
250 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
251 : errmsg("must be superuser to use raw page functions")));
252 :
253 9 : page = verify_hash_page(raw_page, LH_BUCKET_PAGE | LH_OVERFLOW_PAGE);
254 :
255 : /* keep compiler quiet */
256 4 : stat.hasho_prevblkno = stat.hasho_nextblkno = InvalidBlockNumber;
257 4 : stat.hasho_flag = stat.hasho_page_id = stat.free_size = 0;
258 :
259 4 : GetHashPageStatistics(page, &stat);
260 :
261 : /* Build a tuple descriptor for our result type */
262 4 : if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
263 0 : elog(ERROR, "return type must be a row type");
264 4 : tupleDesc = BlessTupleDesc(tupleDesc);
265 :
266 4 : j = 0;
267 4 : values[j++] = Int32GetDatum(stat.live_items);
268 4 : values[j++] = Int32GetDatum(stat.dead_items);
269 4 : values[j++] = Int32GetDatum(stat.page_size);
270 4 : values[j++] = Int32GetDatum(stat.free_size);
271 4 : values[j++] = Int64GetDatum((int64) stat.hasho_prevblkno);
272 4 : values[j++] = Int64GetDatum((int64) stat.hasho_nextblkno);
273 4 : values[j++] = Int64GetDatum((int64) stat.hasho_bucket);
274 4 : values[j++] = Int32GetDatum((int32) stat.hasho_flag);
275 4 : values[j++] = Int32GetDatum((int32) stat.hasho_page_id);
276 :
277 4 : tuple = heap_form_tuple(tupleDesc, values, nulls);
278 :
279 4 : PG_RETURN_DATUM(HeapTupleGetDatum(tuple));
280 : }
281 :
282 : /*
283 : * cross-call data structure for SRF
284 : */
285 : struct user_args
286 : {
287 : Page page;
288 : OffsetNumber offset;
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 : */
299 : Datum
300 10 : hash_page_items(PG_FUNCTION_ARGS)
301 : {
302 10 : bytea *raw_page = PG_GETARG_BYTEA_P(0);
303 : Page page;
304 : Datum result;
305 : Datum values[3];
306 10 : bool nulls[3] = {0};
307 : uint32 hashkey;
308 : HeapTuple tuple;
309 : FuncCallContext *fctx;
310 : MemoryContext mctx;
311 : struct user_args *uargs;
312 :
313 10 : if (!superuser())
314 0 : ereport(ERROR,
315 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
316 : errmsg("must be superuser to use raw page functions")));
317 :
318 10 : if (SRF_IS_FIRSTCALL())
319 : {
320 : TupleDesc tupleDesc;
321 :
322 9 : fctx = SRF_FIRSTCALL_INIT();
323 :
324 9 : mctx = MemoryContextSwitchTo(fctx->multi_call_memory_ctx);
325 :
326 9 : page = verify_hash_page(raw_page, LH_BUCKET_PAGE | LH_OVERFLOW_PAGE);
327 :
328 4 : uargs = palloc_object(struct user_args);
329 :
330 4 : uargs->page = page;
331 :
332 4 : uargs->offset = FirstOffsetNumber;
333 :
334 4 : fctx->max_calls = PageGetMaxOffsetNumber(uargs->page);
335 :
336 : /* Build a tuple descriptor for our result type */
337 4 : if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
338 0 : elog(ERROR, "return type must be a row type");
339 4 : tupleDesc = BlessTupleDesc(tupleDesc);
340 :
341 4 : fctx->attinmeta = TupleDescGetAttInMetadata(tupleDesc);
342 :
343 4 : fctx->user_fctx = uargs;
344 :
345 4 : MemoryContextSwitchTo(mctx);
346 : }
347 :
348 5 : fctx = SRF_PERCALL_SETUP();
349 5 : uargs = fctx->user_fctx;
350 :
351 5 : if (fctx->call_cntr < fctx->max_calls)
352 : {
353 : ItemId id;
354 : IndexTuple itup;
355 : int j;
356 :
357 1 : id = PageGetItemId(uargs->page, uargs->offset);
358 :
359 1 : if (!ItemIdIsValid(id))
360 0 : elog(ERROR, "invalid ItemId");
361 :
362 1 : itup = (IndexTuple) PageGetItem(uargs->page, id);
363 :
364 1 : j = 0;
365 1 : values[j++] = Int32GetDatum((int32) uargs->offset);
366 1 : values[j++] = PointerGetDatum(&itup->t_tid);
367 :
368 1 : hashkey = _hash_get_indextuple_hashkey(itup);
369 1 : values[j] = Int64GetDatum((int64) hashkey);
370 :
371 1 : tuple = heap_form_tuple(fctx->attinmeta->tupdesc, values, nulls);
372 1 : result = HeapTupleGetDatum(tuple);
373 :
374 1 : uargs->offset = uargs->offset + 1;
375 :
376 1 : SRF_RETURN_NEXT(fctx, result);
377 : }
378 :
379 4 : 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 : */
390 : Datum
391 10 : hash_bitmap_info(PG_FUNCTION_ARGS)
392 : {
393 10 : Oid indexRelid = PG_GETARG_OID(0);
394 10 : int64 ovflblkno = PG_GETARG_INT64(1);
395 : HashMetaPage metap;
396 : Buffer metabuf,
397 : mapbuf;
398 : BlockNumber bitmapblkno;
399 : Page mappage;
400 10 : 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 10 : bool nulls[3] = {0};
411 : uint32 *freep;
412 :
413 10 : if (!superuser())
414 0 : ereport(ERROR,
415 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
416 : errmsg("must be superuser to use raw page functions")));
417 :
418 : /*
419 : * This uses relation_open() and not index_open(). The latter allows
420 : * partitioned indexes, and these are forbidden here.
421 : */
422 10 : indexRel = relation_open(indexRelid, AccessShareLock);
423 :
424 10 : if (!IS_INDEX(indexRel) || !IS_HASH(indexRel))
425 2 : ereport(ERROR,
426 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
427 : errmsg("\"%s\" is not a %s index",
428 : RelationGetRelationName(indexRel), "hash")));
429 :
430 8 : if (RELATION_IS_OTHER_TEMP(indexRel))
431 0 : ereport(ERROR,
432 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
433 : errmsg("cannot access temporary tables of other sessions")));
434 :
435 8 : if (ovflblkno < 0 || ovflblkno > MaxBlockNumber)
436 1 : ereport(ERROR,
437 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
438 : errmsg("invalid block number")));
439 :
440 7 : if (ovflblkno >= RelationGetNumberOfBlocks(indexRel))
441 1 : ereport(ERROR,
442 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
443 : errmsg("block number %" PRId64 " is out of range for relation \"%s\"",
444 : ovflblkno, RelationGetRelationName(indexRel))));
445 :
446 : /* Read the metapage so we can determine which bitmap page to use */
447 6 : metabuf = _hash_getbuf(indexRel, HASH_METAPAGE, HASH_READ, LH_META_PAGE);
448 6 : metap = HashPageGetMeta(BufferGetPage(metabuf));
449 :
450 : /*
451 : * Reject attempt to read the bit for a metapage or bitmap page; this is
452 : * only meaningful for overflow pages.
453 : */
454 6 : if (ovflblkno == 0)
455 1 : ereport(ERROR,
456 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
457 : errmsg("invalid overflow block number %u",
458 : (BlockNumber) ovflblkno)));
459 9 : for (i = 0; i < metap->hashm_nmaps; i++)
460 5 : if (metap->hashm_mapp[i] == ovflblkno)
461 1 : ereport(ERROR,
462 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
463 : errmsg("invalid overflow block number %u",
464 : (BlockNumber) ovflblkno)));
465 :
466 : /*
467 : * Identify overflow bit number. This will error out for primary bucket
468 : * pages, and we've already rejected the metapage and bitmap pages above.
469 : */
470 4 : ovflbitno = _hash_ovflblkno_to_bitno(metap, (BlockNumber) ovflblkno);
471 :
472 0 : bitmappage = ovflbitno >> BMPG_SHIFT(metap);
473 0 : bitmapbit = ovflbitno & BMPG_MASK(metap);
474 :
475 0 : if (bitmappage >= metap->hashm_nmaps)
476 0 : ereport(ERROR,
477 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
478 : errmsg("invalid overflow block number %u",
479 : (BlockNumber) ovflblkno)));
480 :
481 0 : bitmapblkno = metap->hashm_mapp[bitmappage];
482 :
483 0 : _hash_relbuf(indexRel, metabuf);
484 :
485 : /* Check the status of bitmap bit for overflow page */
486 0 : mapbuf = _hash_getbuf(indexRel, bitmapblkno, HASH_READ, LH_BITMAP_PAGE);
487 0 : mappage = BufferGetPage(mapbuf);
488 0 : freep = HashPageGetBitmap(mappage);
489 :
490 0 : bit = ISSET(freep, bitmapbit) != 0;
491 :
492 0 : _hash_relbuf(indexRel, mapbuf);
493 0 : relation_close(indexRel, AccessShareLock);
494 :
495 : /* Build a tuple descriptor for our result type */
496 0 : if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
497 0 : elog(ERROR, "return type must be a row type");
498 0 : tupleDesc = BlessTupleDesc(tupleDesc);
499 :
500 0 : j = 0;
501 0 : values[j++] = Int64GetDatum((int64) bitmapblkno);
502 0 : values[j++] = Int32GetDatum(bitmapbit);
503 0 : values[j++] = BoolGetDatum(bit);
504 :
505 0 : tuple = heap_form_tuple(tupleDesc, values, nulls);
506 :
507 0 : PG_RETURN_DATUM(HeapTupleGetDatum(tuple));
508 : }
509 :
510 : /* ------------------------------------------------
511 : * hash_metapage_info()
512 : *
513 : * Get the meta-page information for a hash index
514 : *
515 : * Usage: SELECT * FROM hash_metapage_info(get_raw_page('con_hash_index', 0))
516 : * ------------------------------------------------
517 : */
518 : Datum
519 9 : hash_metapage_info(PG_FUNCTION_ARGS)
520 : {
521 9 : bytea *raw_page = PG_GETARG_BYTEA_P(0);
522 : Page page;
523 : HashMetaPageData *metad;
524 : TupleDesc tupleDesc;
525 : HeapTuple tuple;
526 : int i,
527 : j;
528 : Datum values[16];
529 9 : bool nulls[16] = {0};
530 : Datum spares[HASH_MAX_SPLITPOINTS];
531 : Datum mapp[HASH_MAX_BITMAPS];
532 :
533 9 : if (!superuser())
534 0 : ereport(ERROR,
535 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
536 : errmsg("must be superuser to use raw page functions")));
537 :
538 9 : page = verify_hash_page(raw_page, LH_META_PAGE);
539 :
540 : /* Build a tuple descriptor for our result type */
541 1 : if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
542 0 : elog(ERROR, "return type must be a row type");
543 1 : tupleDesc = BlessTupleDesc(tupleDesc);
544 :
545 1 : metad = HashPageGetMeta(page);
546 :
547 1 : j = 0;
548 1 : values[j++] = Int64GetDatum((int64) metad->hashm_magic);
549 1 : values[j++] = Int64GetDatum((int64) metad->hashm_version);
550 1 : values[j++] = Float8GetDatum(metad->hashm_ntuples);
551 1 : values[j++] = Int32GetDatum((int32) metad->hashm_ffactor);
552 1 : values[j++] = Int32GetDatum((int32) metad->hashm_bsize);
553 1 : values[j++] = Int32GetDatum((int32) metad->hashm_bmsize);
554 1 : values[j++] = Int32GetDatum((int32) metad->hashm_bmshift);
555 1 : values[j++] = Int64GetDatum((int64) metad->hashm_maxbucket);
556 1 : values[j++] = Int64GetDatum((int64) metad->hashm_highmask);
557 1 : values[j++] = Int64GetDatum((int64) metad->hashm_lowmask);
558 1 : values[j++] = Int64GetDatum((int64) metad->hashm_ovflpoint);
559 1 : values[j++] = Int64GetDatum((int64) metad->hashm_firstfree);
560 1 : values[j++] = Int64GetDatum((int64) metad->hashm_nmaps);
561 1 : values[j++] = ObjectIdGetDatum((Oid) metad->hashm_procid);
562 :
563 99 : for (i = 0; i < HASH_MAX_SPLITPOINTS; i++)
564 98 : spares[i] = Int64GetDatum((int64) metad->hashm_spares[i]);
565 1 : values[j++] = PointerGetDatum(construct_array_builtin(spares, HASH_MAX_SPLITPOINTS, INT8OID));
566 :
567 1025 : for (i = 0; i < HASH_MAX_BITMAPS; i++)
568 1024 : mapp[i] = Int64GetDatum((int64) metad->hashm_mapp[i]);
569 1 : values[j++] = PointerGetDatum(construct_array_builtin(mapp, HASH_MAX_BITMAPS, INT8OID));
570 :
571 1 : tuple = heap_form_tuple(tupleDesc, values, nulls);
572 :
573 1 : PG_RETURN_DATUM(HeapTupleGetDatum(tuple));
574 : }
|
