44 #include "catalog/pg_database_d.h"
61 bool all_visible_cleared,
bool new_all_visible_cleared);
62 #ifdef USE_ASSERT_CHECKING
63 static void check_lock_if_inplace_updateable_rel(
Relation relation,
66 static void check_inplace_rel_lock(
HeapTuple oldtup);
75 bool *have_tuple_lock);
151 #define LOCKMODE_from_mxstatus(status) \
152 (tupleLockExtraInfo[TUPLOCK_from_mxstatus((status))].hwlock)
159 #define LockTupleTuplock(rel, tup, mode) \
160 LockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock)
161 #define UnlockTupleTuplock(rel, tup, mode) \
162 UnlockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock)
163 #define ConditionalLockTupleTuplock(rel, tup, mode) \
164 ConditionalLockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock)
177 } IndexDeletePrefetchState;
181 #define BOTTOMUP_MAX_NBLOCKS 6
182 #define BOTTOMUP_TOLERANCE_NBLOCKS 3
210 #define TUPLOCK_from_mxstatus(status) \
211 (MultiXactStatusLock[(status)])
224 void *callback_private_data,
225 void *per_buffer_data)
262 void *callback_private_data,
263 void *per_buffer_data)
329 allow_strat = allow_sync =
false;
352 else if (keep_startblock)
422 Assert(startBlk == 0 || startBlk < scan->rs_nblocks);
438 bool all_visible,
bool check_serializable)
462 if (check_serializable)
464 &loctup, buffer, snapshot);
494 bool check_serializable;
549 if (
likely(!check_serializable))
551 block, lines,
true,
false);
554 block, lines,
true,
true);
558 if (
likely(!check_serializable))
560 block, lines,
false,
false);
563 block, lines,
false,
true);
723 *linesleft = *lineoff;
872 for (; linesleft > 0; linesleft--, lineoff += dir)
981 linesleft = scan->rs_ntuples;
987 for (; linesleft > 0; linesleft--, lineindex += dir)
992 lineoff = scan->rs_vistuples[lineindex];
1006 scan->rs_cindex = lineindex;
1096 if (parallel_scan != NULL)
1144 bool allow_strat,
bool allow_sync,
bool allow_pagemode)
1256 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1267 elog(
ERROR,
"unexpected heap_getnext call during logical decoding");
1624 bool *all_dead,
bool first_call)
1630 bool at_chain_start;
1637 *all_dead = first_call;
1641 at_chain_start = first_call;
1667 at_chain_start =
false;
1734 if (all_dead && *all_dead)
1752 at_chain_start =
false;
1992 bool all_visible_cleared =
false;
2040 all_visible_cleared =
true;
2091 if (all_visible_cleared)
2185 (
errcode(ERRCODE_INVALID_TRANSACTION_STATE),
2186 errmsg(
"cannot insert tuples in a parallel worker")));
2203 if (relation->
rd_rel->relkind != RELKIND_RELATION &&
2204 relation->
rd_rel->relkind != RELKIND_MATVIEW)
2227 for (
int i = done;
i < ntuples;
i++)
2231 if (page_avail < tup_sz)
2236 page_avail -= tup_sz;
2268 bool starting_with_empty_page =
false;
2270 int npages_used = 0;
2281 for (
i = 0;
i < ntuples;
i++)
2318 while (ndone < ntuples)
2321 bool all_visible_cleared =
false;
2322 bool all_frozen_set =
false;
2337 if (ndone == 0 || !starting_with_empty_page)
2356 npages - npages_used);
2362 all_frozen_set =
true;
2377 if (needwal && need_cids)
2380 for (nthispage = 1; ndone + nthispage < ntuples; nthispage++)
2382 HeapTuple heaptup = heaptuples[ndone + nthispage];
2393 if (needwal && need_cids)
2406 all_visible_cleared =
true;
2412 else if (all_frozen_set)
2429 char *scratchptr = scratch.
data;
2437 init = starting_with_empty_page;
2453 tupledata = scratchptr;
2456 Assert(!(all_visible_cleared && all_frozen_set));
2459 if (all_visible_cleared)
2470 for (
i = 0;
i < nthispage;
i++)
2492 scratchptr += datalen;
2494 totaldatalen = scratchptr - tupledata;
2495 Assert((scratchptr - scratch.
data) < BLCKSZ);
2497 if (need_tuple_data)
2505 if (ndone + nthispage == ntuples)
2518 if (need_tuple_data)
2595 for (
i = 0;
i < ntuples;
i++)
2600 for (
i = 0;
i < ntuples;
i++)
2601 slots[
i]->tts_tid = heaptuples[
i]->t_self;
2653 const uint16 interesting =
2656 if ((new_infomask & interesting) != (old_infomask & interesting))
2689 bool have_tuple_lock =
false;
2691 bool all_visible_cleared =
false;
2693 bool old_key_copied =
false;
2704 (
errcode(ERRCODE_INVALID_TRANSACTION_STATE),
2705 errmsg(
"cannot delete tuples during a parallel operation")));
2751 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
2752 errmsg(
"attempted to delete invisible tuple")));
2778 bool current_is_member =
false;
2789 if (!current_is_member)
2869 if (result !=
TM_Ok)
2887 if (result !=
TM_Ok)
2896 if (have_tuple_lock)
2936 &new_xmax, &new_infomask, &new_infomask2);
2951 all_visible_cleared =
true;
2994 if (all_visible_cleared)
3001 xlrec.
xmax = new_xmax;
3003 if (old_key_tuple != NULL)
3005 if (relation->
rd_rel->relreplident == REPLICA_IDENTITY_FULL)
3019 if (old_key_tuple != NULL)
3028 old_key_tuple->
t_len
3053 if (relation->
rd_rel->relkind != RELKIND_RELATION &&
3054 relation->
rd_rel->relkind != RELKIND_MATVIEW)
3075 if (have_tuple_lock)
3080 if (old_key_tuple != NULL && old_key_copied)
3108 elog(
ERROR,
"tuple already updated by self");
3116 elog(
ERROR,
"tuple concurrently updated");
3120 elog(
ERROR,
"tuple concurrently deleted");
3124 elog(
ERROR,
"unrecognized heap_delete status: %u", result);
3158 bool old_key_copied =
false;
3169 bool have_tuple_lock =
false;
3171 bool use_hot_update =
false;
3172 bool summarized_update =
false;
3174 bool all_visible_cleared =
false;
3175 bool all_visible_cleared_new =
false;
3176 bool checked_lockers;
3177 bool locker_remains;
3178 bool id_has_external =
false;
3181 uint16 infomask_old_tuple,
3182 infomask2_old_tuple,
3184 infomask2_new_tuple;
3199 (
errcode(ERRCODE_INVALID_TRANSACTION_STATE),
3200 errmsg(
"cannot update tuples during a parallel operation")));
3202 #ifdef USE_ASSERT_CHECKING
3203 check_lock_if_inplace_updateable_rel(relation, otid, newtup);
3229 interesting_attrs = NULL;
3275 newtup, &id_has_external);
3320 checked_lockers =
false;
3321 locker_remains =
false;
3331 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
3332 errmsg(
"attempted to update invisible tuple")));
3338 bool can_continue =
false;
3383 bool current_is_member =
false;
3386 *lockmode, ¤t_is_member))
3394 if (!current_is_member)
3402 checked_lockers =
true;
3403 locker_remains = remain != 0;
3450 can_continue =
true;
3458 checked_lockers =
true;
3459 locker_remains =
true;
3460 can_continue =
true;
3469 checked_lockers =
true;
3470 locker_remains =
true;
3471 can_continue =
true;
3484 checked_lockers =
true;
3500 can_continue =
true;
3512 if (result !=
TM_Ok)
3530 if (result !=
TM_Ok)
3539 if (have_tuple_lock)
3580 xid, *lockmode,
true,
3581 &xmax_old_tuple, &infomask_old_tuple,
3582 &infomask2_old_tuple);
3593 (checked_lockers && !locker_remains))
3601 infomask2_new_tuple = 0;
3614 &infomask2_new_tuple);
3619 infomask2_new_tuple = 0;
3652 if (relation->
rd_rel->relkind != RELKIND_RELATION &&
3653 relation->
rd_rel->relkind != RELKIND_MATVIEW)
3669 if (need_toast || newtupsize > pagefree)
3672 uint16 infomask_lock_old_tuple,
3673 infomask2_lock_old_tuple;
3674 bool cleared_all_frozen =
false;
3697 xid, *lockmode,
false,
3698 &xmax_lock_old_tuple, &infomask_lock_old_tuple,
3699 &infomask2_lock_old_tuple);
3728 cleared_all_frozen =
true;
3741 xlrec.
xmax = xmax_lock_old_tuple;
3796 if (newtupsize > pagefree)
3801 &vmbuffer_new, &vmbuffer,
3813 if (newtupsize > pagefree ||
3861 if (newbuf == buffer)
3870 use_hot_update =
true;
3880 summarized_update =
true;
3954 all_visible_cleared =
true;
3961 all_visible_cleared_new =
true;
3967 if (newbuf != buffer)
3987 newbuf, &oldtup, heaptup,
3989 all_visible_cleared,
3990 all_visible_cleared_new);
3991 if (newbuf != buffer)
4000 if (newbuf != buffer)
4015 if (newbuf != buffer)
4026 if (have_tuple_lock)
4035 if (heaptup != newtup)
4049 if (summarized_update)
4055 *update_indexes =
TU_All;
4057 if (old_key_tuple != NULL && old_key_copied)
4070 #ifdef USE_ASSERT_CHECKING
4076 check_lock_if_inplace_updateable_rel(
Relation relation,
4083 case RelationRelationId:
4084 case DatabaseRelationId:
4104 case RelationRelationId:
4108 Oid relid = classForm->oid;
4117 if (classForm->relkind == RELKIND_INDEX)
4130 "missing lock for relation \"%s\" (OID %u, relkind %c) @ TID (%u,%u)",
4138 case DatabaseRelationId:
4144 "missing lock on database \"%s\" (OID %u) @ TID (%u,%u)",
4159 check_inplace_rel_lock(
HeapTuple oldtup)
4162 Oid relid = classForm->oid;
4171 if (classForm->relkind == RELKIND_INDEX)
4183 "missing lock for relation \"%s\" (OID %u, relkind %c) @ TID (%u,%u)",
4198 bool isnull1,
bool isnull2)
4206 if (isnull1 != isnull2)
4231 Assert(attrnum <= tupdesc->natts);
4233 return datumIsEqual(value1, value2, att->attbyval, att->attlen);
4299 value1 =
heap_getattr(oldtup, attrnum, tupdesc, &isnull1);
4300 value2 =
heap_getattr(newtup, attrnum, tupdesc, &isnull2);
4303 value2, isnull1, isnull2))
4313 if (attrnum < 0 || isnull1 ||
4323 *has_external =
true;
4348 &tmfd, &lockmode, update_indexes);
4353 elog(
ERROR,
"tuple already updated by self");
4361 elog(
ERROR,
"tuple concurrently updated");
4365 elog(
ERROR,
"tuple concurrently deleted");
4369 elog(
ERROR,
"unrecognized heap_update status: %u", result);
4390 is_update ?
"true" :
"false");
4429 bool follow_updates,
4443 bool first_time =
true;
4444 bool skip_tuple_lock =
false;
4445 bool have_tuple_lock =
false;
4446 bool cleared_all_frozen =
false;
4533 for (
i = 0;
i < nmembers;
i++)
4558 skip_tuple_lock =
true;
4607 require_sleep =
true;
4641 if (follow_updates && updated)
4672 require_sleep =
false;
4701 require_sleep =
false;
4727 require_sleep =
false;
4740 require_sleep =
false;
4766 require_sleep =
false;
4785 else if (require_sleep)
4797 if (!skip_tuple_lock &&
4817 elog(
ERROR,
"invalid lock mode in heap_lock_tuple");
4820 switch (wait_policy)
4828 status, infomask, relation,
4839 status, infomask, relation,
4842 (
errcode(ERRCODE_LOCK_NOT_AVAILABLE),
4843 errmsg(
"could not obtain lock on row in relation \"%s\"",
4862 switch (wait_policy)
4880 (
errcode(ERRCODE_LOCK_NOT_AVAILABLE),
4881 errmsg(
"could not obtain lock on row in relation \"%s\"",
4937 if (!require_sleep ||
4949 if (result !=
TM_Ok)
5011 &xid, &new_infomask, &new_infomask2);
5047 cleared_all_frozen =
true;
5106 if (have_tuple_lock)
5128 if (*have_tuple_lock)
5131 switch (wait_policy)
5145 (
errcode(ERRCODE_LOCK_NOT_AVAILABLE),
5146 errmsg(
"could not obtain lock on row in relation \"%s\"",
5150 *have_tuple_lock =
true;
5178 uint16 *result_infomask2)
5201 new_xmax = add_to_xmax;
5211 new_xmax = add_to_xmax;
5215 new_xmax = add_to_xmax;
5219 new_xmax = add_to_xmax;
5223 new_xmax = add_to_xmax;
5347 elog(
WARNING,
"LOCK_ONLY found for Xid in progress %u", xmax);
5369 if (xmax == add_to_xmax)
5383 if (
mode < old_mode)
5394 add_to_xmax, new_status);
5434 *result_infomask = new_infomask;
5435 *result_infomask2 = new_infomask2;
5436 *result_xmax = new_xmax;
5560 bool cleared_all_frozen =
false;
5561 bool pinned_desired_page;
5599 pinned_desired_page =
true;
5602 pinned_desired_page =
false;
5682 for (
i = 0;
i < nmembers;
i++)
5715 if (result !=
TM_Ok)
5752 elog(
ERROR,
"invalid lock status in tuple");
5786 if (result !=
TM_Ok)
5796 &new_xmax, &new_infomask, &new_infomask2);
5801 cleared_all_frozen =
true;
5825 xlrec.
xmax = new_xmax;
6059 elog(
ERROR,
"attempted to kill a tuple inserted by another transaction");
6061 elog(
ERROR,
"attempted to kill a non-speculative tuple");
6088 prune_xid = relfrozenxid;
6204 void (*release_callback) (
void *),
void *
arg)
6210 #ifdef USE_ASSERT_CHECKING
6212 check_inplace_rel_lock(oldtup_ptr);
6247 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
6259 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
6260 errmsg(
"tuple to be updated was already modified by an operation triggered by the current command")));
6280 release_callback(
arg);
6296 release_callback(
arg);
6304 ret = (result ==
TM_Ok);
6308 release_callback(
arg);
6349 bool RelcacheInitFileInval =
false;
6357 dst = (
char *) htup + htup->
t_hoff;
6363 &RelcacheInitFileInval);
6411 uintptr_t dst_offset_in_block;
6421 xlrec.
nmsgs = nmsgs;
6430 memcpy(copied_buffer.
data, origdata,
lower);
6432 dst_offset_in_block = dst - origdata;
6433 memcpy(copied_buffer.
data + dst_offset_in_block, src, newlen);
6447 memcpy(dst, src, newlen);
6491 #define FRM_NOOP 0x0001
6492 #define FRM_INVALIDATE_XMAX 0x0002
6493 #define FRM_RETURN_IS_XID 0x0004
6494 #define FRM_RETURN_IS_MULTI 0x0008
6495 #define FRM_MARK_COMMITTED 0x0010
6556 bool update_committed;
6590 errmsg_internal(
"multixact %u from before multi freeze cutoff %u found to be still running",
6605 errmsg_internal(
"multixact %u contains update XID %u from before relfrozenxid %u",
6618 errmsg_internal(
"multixact %u contains committed update XID %u from before removable cutoff %u",
6666 need_replace =
false;
6668 for (
int i = 0;
i < nmembers;
i++)
6677 need_replace =
true;
6681 FreezePageRelfrozenXid = xid;
6713 has_lockers =
false;
6715 update_committed =
false;
6720 for (
int i = 0;
i < nmembers;
i++)
6739 errmsg_internal(
"multixact %u contains running locker XID %u from before removable cutoff %u",
6742 newmembers[nnewmembers++] = members[
i];
6783 update_committed =
true;
6802 errmsg_internal(
"multixact %u contains committed update XID %u from before removable cutoff %u",
6804 newmembers[nnewmembers++] = members[
i];
6813 if (nnewmembers == 0)
6828 Assert(nnewmembers == 1);
6830 if (update_committed)
6832 newxmax = update_xid;
6899 bool xmin_already_frozen =
false,
6900 xmax_already_frozen =
false;
6901 bool freeze_xmin =
false,
6902 replace_xvac =
false,
6903 replace_xmax =
false,
6904 freeze_xmax =
false;
6920 xmin_already_frozen =
true;
7013 frz->
xmax = newxmax;
7016 replace_xmax =
true;
7040 frz->
xmax = newxmax;
7041 replace_xmax =
true;
7083 xmax_already_frozen =
true;
7088 errmsg_internal(
"found raw xmax %u (infomask 0x%04x) not invalid and not multi",
7093 Assert(!xmin_already_frozen);
7112 Assert(!xmax_already_frozen && !freeze_xmax);
7119 Assert(!xmax_already_frozen && !replace_xmax);
7138 *totally_frozen = ((freeze_xmin || xmin_already_frozen) &&
7139 (freeze_xmax || xmax_already_frozen));
7142 xmax_already_frozen))
7155 return freeze_xmin || replace_xvac || replace_xmax || freeze_xmax;
7172 for (
int i = 0;
i < ntuples;
i++)
7224 for (
int i = 0;
i < ntuples;
i++)
7248 bool totally_frozen;
7259 pagefrz.freeze_required =
true;
7266 &pagefrz, &frz, &totally_frozen);
7294 bool has_update =
false;
7303 for (
i = 0;
i < nmembers;
i++)
7312 if (
mode > strongest)
7316 switch (members[
i].status)
7352 *new_infomask = bits;
7353 *new_infomask2 = bits2;
7386 for (
i = 0;
i < nmembers;
i++)
7394 update_xact = members[
i].
xid;
7395 #ifndef USE_ASSERT_CHECKING
7440 bool result =
false;
7452 for (
i = 0;
i < nmembers;
i++)
7457 if (result && (current_is_member == NULL || *current_is_member))
7463 memxid = members[
i].
xid;
7466 if (current_is_member != NULL)
7467 *current_is_member =
true;
7535 uint16 infomask,
bool nowait,
7553 for (
i = 0;
i < nmembers;
i++)
7710 bool freeze =
false;
7718 *NoFreezePageRelfrozenXid = xid;
7736 *NoFreezePageRelfrozenXid = xid;
7748 *NoFreezePageRelminMxid = multi;
7760 *NoFreezePageRelminMxid = multi;
7768 for (
int i = 0;
i < nmembers;
i++)
7770 xid = members[
i].
xid;
7773 *NoFreezePageRelfrozenXid = xid;
7788 *NoFreezePageRelfrozenXid = xid;
7821 *snapshotConflictHorizon = xvac;
7835 *snapshotConflictHorizon = xmax;
7851 index_delete_prefetch_buffer(
Relation rel,
7852 IndexDeletePrefetchState *prefetch_state,
7855 BlockNumber cur_hblkno = prefetch_state->cur_hblkno;
7858 int ndeltids = prefetch_state->ndeltids;
7861 for (
i = prefetch_state->next_item;
7862 i < ndeltids && count < prefetch_count;
7880 prefetch_state->next_item =
i;
7881 prefetch_state->cur_hblkno = cur_hblkno;
7905 if (
unlikely(indexpagehoffnum > maxoff))
7907 (
errcode(ERRCODE_INDEX_CORRUPTED),
7908 errmsg_internal(
"heap tid from index tuple (%u,%u) points past end of heap page line pointer array at offset %u of block %u in index \"%s\"",
7917 (
errcode(ERRCODE_INDEX_CORRUPTED),
7918 errmsg_internal(
"heap tid from index tuple (%u,%u) points to unused heap page item at offset %u of block %u in index \"%s\"",
7933 (
errcode(ERRCODE_INDEX_CORRUPTED),
7934 errmsg_internal(
"heap tid from index tuple (%u,%u) points to heap-only tuple at offset %u of block %u in index \"%s\"",
7966 IndexDeletePrefetchState prefetch_state;
7967 int prefetch_distance;
7970 int finalndeltids = 0,
7971 nblocksaccessed = 0;
7974 int nblocksfavorable = 0;
7977 actualfreespace = 0;
7978 bool bottomup_final_block =
false;
7998 prefetch_state.next_item = 0;
7999 prefetch_state.ndeltids = delstate->
ndeltids;
8000 prefetch_state.deltids = delstate->
deltids;
8018 Assert(nblocksfavorable >= 1);
8020 prefetch_distance =
Min(prefetch_distance, nblocksfavorable);
8024 index_delete_prefetch_buffer(rel, &prefetch_state, prefetch_distance);
8067 if (bottomup_final_block)
8076 if (nblocksaccessed >= 1 && actualfreespace == lastfreespace)
8078 lastfreespace = actualfreespace;
8104 Assert(nblocksaccessed > 0 || nblocksfavorable > 0);
8105 if (nblocksfavorable > 0)
8108 curtargetfreespace /= 2;
8127 index_delete_prefetch_buffer(rel, &prefetch_state, 1);
8153 &heapTuple, NULL,
true))
8164 if (actualfreespace >= curtargetfreespace)
8165 bottomup_final_block =
true;
8189 if (offnum > maxoff)
8226 &snapshotConflictHorizon);
8244 finalndeltids =
i + 1;
8256 delstate->
ndeltids = finalndeltids;
8258 return snapshotConflictHorizon;
8275 return (blk1 < blk2) ? -1 : 1;
8282 return (pos1 < pos2) ? -1 : 1;
8312 const int gaps[9] = {1968, 861, 336, 112, 48, 21, 7, 3, 1};
8316 "element size exceeds 8 bytes");
8318 for (
int g = 0; g <
lengthof(gaps); g++)
8320 for (
int hi = gaps[g],
i = hi;
i < ndeltids;
i++)
8327 deltids[
j] = deltids[
j - hi];
8400 int64 lastblock = -1;
8401 int nblocksfavorable = 0;
8403 Assert(nblockgroups >= 1);
8415 for (
int b = 0;
b < nblockgroups;
b++)
8421 if (lastblock != -1 &&
8431 Assert(nblocksfavorable >= 1);
8433 return nblocksfavorable;
8468 if (ntids1 > ntids2)
8470 if (ntids1 < ntids2)
8518 int nblockgroups = 0;
8520 int nblocksfavorable = 0;
8544 blockgroups[nblockgroups - 1].
ntids = 1;
8549 blockgroups[nblockgroups - 1].
ntids++;
8584 for (
int b = 0;
b < nblockgroups;
b++)
8606 for (
int b = 0;
b < nblockgroups;
b++)
8611 memcpy(reordereddeltids + ncopied, firstdtid,
8613 ncopied += group->
ntids;
8617 memcpy(delstate->
deltids, reordereddeltids,
8621 pfree(reordereddeltids);
8624 return nblocksfavorable;
8653 xlrec.
flags = vmflags;
8679 bool all_visible_cleared,
bool new_all_visible_cleared)
8724 if (oldbuf == newbuf && !need_tuple_data &&
8733 for (prefixlen = 0; prefixlen <
Min(oldlen, newlen); prefixlen++)
8735 if (newp[prefixlen] != oldp[prefixlen])
8747 for (suffixlen = 0; suffixlen <
Min(oldlen, newlen) - prefixlen; suffixlen++)
8749 if (newp[newlen - suffixlen - 1] != oldp[oldlen - suffixlen - 1])
8758 if (all_visible_cleared)
8760 if (new_all_visible_cleared)
8766 if (need_tuple_data)
8771 if (reln->
rd_rel->relreplident == REPLICA_IDENTITY_FULL)
8801 if (need_tuple_data)
8805 if (oldbuf != newbuf)
8813 if (prefixlen > 0 || suffixlen > 0)
8815 if (prefixlen > 0 && suffixlen > 0)
8817 prefix_suffix[0] = prefixlen;
8818 prefix_suffix[1] = suffixlen;
8821 else if (prefixlen > 0)
8869 if (need_tuple_data && old_key_tuple)
8983 char replident = relation->
rd_rel->relreplident;
8994 if (replident == REPLICA_IDENTITY_NOTHING)
8997 if (replident == REPLICA_IDENTITY_FULL)
9035 for (
int i = 0;
i < desc->
natts;
i++)
9139 elog(
ERROR,
"unrecognized return value from HeapTupleSatisfiesVacuum: %u", htsvResult);
int bms_next_member(const Bitmapset *a, int prevbit)
void bms_free(Bitmapset *a)
bool bms_is_member(int x, const Bitmapset *a)
Bitmapset * bms_add_member(Bitmapset *a, int x)
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
bool bms_overlap(const Bitmapset *a, const Bitmapset *b)
#define InvalidBlockNumber
static bool BlockNumberIsValid(BlockNumber blockNumber)
static Datum values[MAXATTR]
BlockNumber BufferGetBlockNumber(Buffer buffer)
PrefetchBufferResult PrefetchBuffer(Relation reln, ForkNumber forkNum, BlockNumber blockNum)
void BufferGetTag(Buffer buffer, RelFileLocator *rlocator, ForkNumber *forknum, BlockNumber *blknum)
void ReleaseBuffer(Buffer buffer)
void UnlockReleaseBuffer(Buffer buffer)
void MarkBufferDirty(Buffer buffer)
void LockBuffer(Buffer buffer, int mode)
int maintenance_io_concurrency
Buffer ReadBuffer(Relation reln, BlockNumber blockNum)
#define BUFFER_LOCK_UNLOCK
#define BUFFER_LOCK_SHARE
#define RelationGetNumberOfBlocks(reln)
static Page BufferGetPage(Buffer buffer)
static Block BufferGetBlock(Buffer buffer)
#define BUFFER_LOCK_EXCLUSIVE
static bool BufferIsValid(Buffer bufnum)
Size PageGetHeapFreeSpace(Page page)
PageHeaderData * PageHeader
static Item PageGetItem(Page page, ItemId itemId)
static void PageClearAllVisible(Page page)
#define SizeOfPageHeaderData
static void PageSetAllVisible(Page page)
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
static bool PageIsAllVisible(Page page)
static void PageSetFull(Page page)
static void PageSetLSN(Page page, XLogRecPtr lsn)
static OffsetNumber PageGetMaxOffsetNumber(Page page)
#define PageSetPrunable(page, xid)
#define Assert(condition)
TransactionId MultiXactId
#define pg_attribute_always_inline
#define StaticAssertDecl(condition, errmessage)
bool IsToastRelation(Relation relation)
bool IsCatalogRelation(Relation relation)
bool IsSharedRelation(Oid relationId)
bool IsInplaceUpdateRelation(Relation relation)
void HeapTupleHeaderAdjustCmax(HeapTupleHeader tup, CommandId *cmax, bool *iscombo)
CommandId HeapTupleHeaderGetCmin(HeapTupleHeader tup)
CommandId HeapTupleHeaderGetCmax(HeapTupleHeader tup)
bool datumIsEqual(Datum value1, Datum value2, bool typByVal, int typLen)
static void PGresult * res
int errmsg_internal(const char *fmt,...)
int errdetail_internal(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
TupleTableSlot * ExecStoreBufferHeapTuple(HeapTuple tuple, TupleTableSlot *slot, Buffer buffer)
HeapTuple ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
BufferAccessStrategy GetAccessStrategy(BufferAccessStrategyType btype)
void FreeAccessStrategy(BufferAccessStrategy strategy)
static bool DoesMultiXactIdConflict(MultiXactId multi, uint16 infomask, LockTupleMode lockmode, bool *current_is_member)
void heap_finish_speculative(Relation relation, ItemPointer tid)
void heap_insert(Relation relation, HeapTuple tup, CommandId cid, int options, BulkInsertState bistate)
static XLogRecPtr log_heap_new_cid(Relation relation, HeapTuple tup)
XLogRecPtr log_heap_visible(Relation rel, Buffer heap_buffer, Buffer vm_buffer, TransactionId snapshotConflictHorizon, uint8 vmflags)
static void compute_new_xmax_infomask(TransactionId xmax, uint16 old_infomask, uint16 old_infomask2, TransactionId add_to_xmax, LockTupleMode mode, bool is_update, TransactionId *result_xmax, uint16 *result_infomask, uint16 *result_infomask2)
struct IndexDeleteCounts IndexDeleteCounts
static void heap_fetch_next_buffer(HeapScanDesc scan, ScanDirection dir)
bool heap_inplace_lock(Relation relation, HeapTuple oldtup_ptr, Buffer buffer, void(*release_callback)(void *), void *arg)
bool heap_fetch(Relation relation, Snapshot snapshot, HeapTuple tuple, Buffer *userbuf, bool keep_buf)
static bool Do_MultiXactIdWait(MultiXactId multi, MultiXactStatus status, uint16 infomask, bool nowait, Relation rel, ItemPointer ctid, XLTW_Oper oper, int *remaining)
#define BOTTOMUP_TOLERANCE_NBLOCKS
static HeapTuple heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid, CommandId cid, int options)
static BlockNumber heap_scan_stream_read_next_parallel(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
static int bottomup_sort_and_shrink(TM_IndexDeleteOp *delstate)
static int heap_multi_insert_pages(HeapTuple *heaptuples, int done, int ntuples, Size saveFreeSpace)
static pg_attribute_always_inline int page_collect_tuples(HeapScanDesc scan, Snapshot snapshot, Page page, Buffer buffer, BlockNumber block, int lines, bool all_visible, bool check_serializable)
void simple_heap_delete(Relation relation, ItemPointer tid)
static BlockNumber heap_scan_stream_read_next_serial(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
static void GetMultiXactIdHintBits(MultiXactId multi, uint16 *new_infomask, uint16 *new_infomask2)
TM_Result heap_delete(Relation relation, ItemPointer tid, CommandId cid, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, bool changingPart)
void HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple, TransactionId *snapshotConflictHorizon)
bool heap_getnextslot(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
#define LOCKMODE_from_mxstatus(status)
void heap_endscan(TableScanDesc sscan)
TransactionId HeapTupleGetUpdateXid(HeapTupleHeader tuple)
static void index_delete_check_htid(TM_IndexDeleteOp *delstate, Page page, OffsetNumber maxoff, ItemPointer htid, TM_IndexStatus *istatus)
#define FRM_RETURN_IS_XID
#define TUPLOCK_from_mxstatus(status)
void heap_rescan(TableScanDesc sscan, ScanKey key, bool set_params, bool allow_strat, bool allow_sync, bool allow_pagemode)
void heap_inplace_unlock(Relation relation, HeapTuple oldtup, Buffer buffer)
static int index_delete_sort_cmp(TM_IndexDelete *deltid1, TM_IndexDelete *deltid2)
TM_Result heap_update(Relation relation, ItemPointer otid, HeapTuple newtup, CommandId cid, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, LockTupleMode *lockmode, TU_UpdateIndexes *update_indexes)
#define ConditionalLockTupleTuplock(rel, tup, mode)
bool heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple)
static TransactionId FreezeMultiXactId(MultiXactId multi, uint16 t_infomask, const struct VacuumCutoffs *cutoffs, uint16 *flags, HeapPageFreeze *pagefrz)
static HeapTuple ExtractReplicaIdentity(Relation relation, HeapTuple tp, bool key_required, bool *copy)
static pg_noinline BlockNumber heapgettup_initial_block(HeapScanDesc scan, ScanDirection dir)
#define LockTupleTuplock(rel, tup, mode)
bool heap_tuple_should_freeze(HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, TransactionId *NoFreezePageRelfrozenXid, MultiXactId *NoFreezePageRelminMxid)
bool heap_freeze_tuple(HeapTupleHeader tuple, TransactionId relfrozenxid, TransactionId relminmxid, TransactionId FreezeLimit, TransactionId MultiXactCutoff)
void heap_inplace_update_and_unlock(Relation relation, HeapTuple oldtup, HeapTuple tuple, Buffer buffer)
static BlockNumber heapgettup_advance_block(HeapScanDesc scan, BlockNumber block, ScanDirection dir)
static TransactionId MultiXactIdGetUpdateXid(TransactionId xmax, uint16 t_infomask)
static bool heap_acquire_tuplock(Relation relation, ItemPointer tid, LockTupleMode mode, LockWaitPolicy wait_policy, bool *have_tuple_lock)
static TM_Result heap_lock_updated_tuple(Relation rel, HeapTuple tuple, ItemPointer ctid, TransactionId xid, LockTupleMode mode)
#define BOTTOMUP_MAX_NBLOCKS
void ReleaseBulkInsertStatePin(BulkInsertState bistate)
static void MultiXactIdWait(MultiXactId multi, MultiXactStatus status, uint16 infomask, Relation rel, ItemPointer ctid, XLTW_Oper oper, int *remaining)
#define FRM_MARK_COMMITTED
HeapTuple heap_getnext(TableScanDesc sscan, ScanDirection direction)
bool heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer, Snapshot snapshot, HeapTuple heapTuple, bool *all_dead, bool first_call)
void simple_heap_update(Relation relation, ItemPointer otid, HeapTuple tup, TU_UpdateIndexes *update_indexes)
void heap_freeze_prepared_tuples(Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
bool heap_getnextslot_tidrange(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
void heap_set_tidrange(TableScanDesc sscan, ItemPointer mintid, ItemPointer maxtid)
void heap_abort_speculative(Relation relation, ItemPointer tid)
TableScanDesc heap_beginscan(Relation relation, Snapshot snapshot, int nkeys, ScanKey key, ParallelTableScanDesc parallel_scan, uint32 flags)
static void heapgettup(HeapScanDesc scan, ScanDirection dir, int nkeys, ScanKey key)
static Page heapgettup_continue_page(HeapScanDesc scan, ScanDirection dir, int *linesleft, OffsetNumber *lineoff)
static uint8 compute_infobits(uint16 infomask, uint16 infomask2)
#define FRM_RETURN_IS_MULTI
#define FRM_INVALIDATE_XMAX
static bool ConditionalMultiXactIdWait(MultiXactId multi, MultiXactStatus status, uint16 infomask, Relation rel, int *remaining)
static bool heap_attr_equals(TupleDesc tupdesc, int attrnum, Datum value1, Datum value2, bool isnull1, bool isnull2)
static void index_delete_sort(TM_IndexDeleteOp *delstate)
void heap_prepare_pagescan(TableScanDesc sscan)
static Bitmapset * HeapDetermineColumnsInfo(Relation relation, Bitmapset *interesting_cols, Bitmapset *external_cols, HeapTuple oldtup, HeapTuple newtup, bool *has_external)
static const int MultiXactStatusLock[MaxMultiXactStatus+1]
void simple_heap_insert(Relation relation, HeapTuple tup)
static bool xmax_infomask_changed(uint16 new_infomask, uint16 old_infomask)
#define UnlockTupleTuplock(rel, tup, mode)
static TM_Result test_lockmode_for_conflict(MultiXactStatus status, TransactionId xid, LockTupleMode mode, HeapTuple tup, bool *needwait)
bool heap_prepare_freeze_tuple(HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, HeapPageFreeze *pagefrz, HeapTupleFreeze *frz, bool *totally_frozen)
static XLogRecPtr log_heap_update(Relation reln, Buffer oldbuf, Buffer newbuf, HeapTuple oldtup, HeapTuple newtup, HeapTuple old_key_tuple, bool all_visible_cleared, bool new_all_visible_cleared)
TransactionId heap_index_delete_tuples(Relation rel, TM_IndexDeleteOp *delstate)
void heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples, CommandId cid, int options, BulkInsertState bistate)
static void initscan(HeapScanDesc scan, ScanKey key, bool keep_startblock)
static int bottomup_nblocksfavorable(IndexDeleteCounts *blockgroups, int nblockgroups, TM_IndexDelete *deltids)
static void heapgettup_pagemode(HeapScanDesc scan, ScanDirection dir, int nkeys, ScanKey key)
TM_Result heap_lock_tuple(Relation relation, HeapTuple tuple, CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy, bool follow_updates, Buffer *buffer, TM_FailureData *tmfd)
static void UpdateXmaxHintBits(HeapTupleHeader tuple, Buffer buffer, TransactionId xid)
static int bottomup_sort_and_shrink_cmp(const void *arg1, const void *arg2)
void heap_get_latest_tid(TableScanDesc sscan, ItemPointer tid)
void heap_setscanlimits(TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlks)
void HeapCheckForSerializableConflictOut(bool visible, Relation relation, HeapTuple tuple, Buffer buffer, Snapshot snapshot)
static Page heapgettup_start_page(HeapScanDesc scan, ScanDirection dir, int *linesleft, OffsetNumber *lineoff)
static MultiXactStatus get_mxact_status_for_lock(LockTupleMode mode, bool is_update)
void heap_pre_freeze_checks(Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
BulkInsertState GetBulkInsertState(void)
void FreeBulkInsertState(BulkInsertState bistate)
static TM_Result heap_lock_updated_tuple_rec(Relation rel, ItemPointer tid, TransactionId xid, LockTupleMode mode)
static const struct @15 tupleLockExtraInfo[MaxLockTupleMode+1]
#define HEAP_INSERT_SPECULATIVE
#define HEAP_FREEZE_CHECK_XMAX_ABORTED
struct HeapScanDescData * HeapScanDesc
@ HEAPTUPLE_RECENTLY_DEAD
@ HEAPTUPLE_INSERT_IN_PROGRESS
@ HEAPTUPLE_DELETE_IN_PROGRESS
#define HEAP_INSERT_FROZEN
static void heap_execute_freeze_tuple(HeapTupleHeader tuple, HeapTupleFreeze *frz)
#define HEAP_FREEZE_CHECK_XMIN_COMMITTED
#define HEAP_INSERT_NO_LOGICAL
struct BulkInsertStateData * BulkInsertState
const TableAmRoutine * GetHeapamTableAmRoutine(void)
void HeapTupleSetHintBits(HeapTupleHeader tuple, Buffer buffer, uint16 infomask, TransactionId xid)
bool HeapTupleSatisfiesVisibility(HeapTuple htup, Snapshot snapshot, Buffer buffer)
bool HeapTupleIsSurelyDead(HeapTuple htup, GlobalVisState *vistest)
HTSV_Result HeapTupleSatisfiesVacuum(HeapTuple htup, TransactionId OldestXmin, Buffer buffer)
bool HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
TM_Result HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid, Buffer buffer)
#define XLH_INSERT_ON_TOAST_RELATION
#define SizeOfHeapMultiInsert
#define XLOG_HEAP2_MULTI_INSERT
#define XLH_UPDATE_NEW_ALL_VISIBLE_CLEARED
#define SizeOfHeapVisible
#define XLOG_HEAP_HOT_UPDATE
#define XLH_INSERT_IS_SPECULATIVE
#define XLH_LOCK_ALL_FROZEN_CLEARED
#define XLH_DELETE_CONTAINS_OLD_KEY
#define XLH_UPDATE_CONTAINS_NEW_TUPLE
#define XLH_INSERT_LAST_IN_MULTI
#define XLH_INSERT_ALL_FROZEN_SET
#define XLHL_XMAX_KEYSHR_LOCK
#define XLH_DELETE_ALL_VISIBLE_CLEARED
#define XLH_UPDATE_CONTAINS_OLD_TUPLE
#define SizeOfHeapLockUpdated
#define XLHL_XMAX_IS_MULTI
#define XLH_INSERT_ALL_VISIBLE_CLEARED
#define XLH_DELETE_IS_PARTITION_MOVE
#define MinSizeOfHeapInplace
#define XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED
#define XLHL_XMAX_LOCK_ONLY
#define XLOG_HEAP_INPLACE
#define XLOG_HEAP2_LOCK_UPDATED
#define XLH_UPDATE_SUFFIX_FROM_OLD
#define XLH_UPDATE_PREFIX_FROM_OLD
#define SizeOfMultiInsertTuple
#define XLHL_XMAX_EXCL_LOCK
#define XLOG_HEAP2_NEW_CID
#define XLH_DELETE_CONTAINS_OLD_TUPLE
#define XLH_DELETE_IS_SUPER
#define XLH_UPDATE_CONTAINS_OLD_KEY
#define XLHL_KEYS_UPDATED
#define XLOG_HEAP2_VISIBLE
#define XLH_INSERT_CONTAINS_NEW_TUPLE
#define XLOG_HEAP_INIT_PAGE
#define SizeOfHeapConfirm
#define XLOG_HEAP_CONFIRM
void heap_toast_delete(Relation rel, HeapTuple oldtup, bool is_speculative)
HeapTuple heap_toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup, int options)
HeapTuple toast_flatten_tuple(HeapTuple tup, TupleDesc tupleDesc)
#define TOAST_TUPLE_THRESHOLD
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
void heap_freetuple(HeapTuple htup)
void RelationPutHeapTuple(Relation relation, Buffer buffer, HeapTuple tuple, bool token)
Buffer RelationGetBufferForTuple(Relation relation, Size len, Buffer otherBuffer, int options, BulkInsertState bistate, Buffer *vmbuffer, Buffer *vmbuffer_other, int num_pages)
HeapTupleHeaderData * HeapTupleHeader
#define HEAP_XMAX_IS_EXCL_LOCKED(infomask)
#define HeapTupleHeaderSetXminFrozen(tup)
#define HEAP_XMAX_SHR_LOCK
static Datum heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
#define HEAP_XMAX_IS_LOCKED_ONLY(infomask)
#define HeapTupleHeaderGetNatts(tup)
#define SizeofHeapTupleHeader
#define HEAP_XMAX_IS_KEYSHR_LOCKED(infomask)
#define HEAP_KEYS_UPDATED
#define HeapTupleHeaderIsHeapOnly(tup)
#define HeapTupleHeaderIndicatesMovedPartitions(tup)
#define HeapTupleSetHotUpdated(tuple)
#define HeapTupleHeaderGetXvac(tup)
#define HeapTupleHeaderSetXmin(tup, xid)
#define HeapTupleHeaderSetXmax(tup, xid)
#define HEAP_XMAX_LOCK_ONLY
#define HeapTupleHeaderGetXmin(tup)
#define HeapTupleHasExternal(tuple)
#define HeapTupleHeaderClearHotUpdated(tup)
#define HeapTupleHeaderSetCmin(tup, cid)
#define HEAP_XMAX_IS_MULTI
#define HEAP_XMAX_COMMITTED
#define HeapTupleIsHeapOnly(tuple)
#define HeapTupleHeaderGetRawXmin(tup)
#define HeapTupleHeaderXminFrozen(tup)
#define HEAP_XMAX_EXCL_LOCK
#define HEAP_XMAX_INVALID
#define HeapTupleHeaderXminCommitted(tup)
#define MaxHeapAttributeNumber
#define HeapTupleHeaderSetMovedPartitions(tup)
#define HeapTupleIsHotUpdated(tuple)
#define HeapTupleHeaderGetRawXmax(tup)
#define MaxHeapTuplesPerPage
#define HeapTupleSetHeapOnly(tuple)
#define HEAP_XMAX_IS_SHR_LOCKED(infomask)
#define HeapTupleClearHeapOnly(tuple)
#define HEAP_XMAX_KEYSHR_LOCK
#define HeapTupleHeaderGetUpdateXid(tup)
#define HeapTupleClearHotUpdated(tuple)
#define HeapTupleHeaderGetRawCommandId(tup)
#define HEAP_LOCKED_UPGRADED(infomask)
#define HeapTupleHeaderIsSpeculative(tup)
#define HeapTupleHeaderIsHotUpdated(tup)
#define HeapTupleHeaderXminInvalid(tup)
#define HeapTupleHeaderSetCmax(tup, cid, iscombo)
#define IsParallelWorker()
void index_close(Relation relation, LOCKMODE lockmode)
Relation index_open(Oid relationId, LOCKMODE lockmode)
void CacheInvalidateHeapTupleInplace(Relation relation, HeapTuple tuple, HeapTuple newtuple)
void AcceptInvalidationMessages(void)
int inplaceGetInvalidationMessages(SharedInvalidationMessage **msgs, bool *RelcacheInitFileInval)
void PreInplace_Inval(void)
void AtInplace_Inval(void)
void ForgetInplace_Inval(void)
void CacheInvalidateHeapTuple(Relation relation, HeapTuple tuple, HeapTuple newtuple)
if(TABLE==NULL||TABLE_index==NULL)
#define ItemIdGetLength(itemId)
#define ItemIdIsNormal(itemId)
struct ItemIdData ItemIdData
#define ItemIdGetRedirect(itemId)
#define ItemIdIsUsed(itemId)
#define ItemIdIsRedirected(itemId)
#define ItemIdHasStorage(itemId)
int32 ItemPointerCompare(ItemPointer arg1, ItemPointer arg2)
bool ItemPointerEquals(ItemPointer pointer1, ItemPointer pointer2)
static void ItemPointerSet(ItemPointerData *pointer, BlockNumber blockNumber, OffsetNumber offNum)
static void ItemPointerSetInvalid(ItemPointerData *pointer)
static void ItemPointerSetOffsetNumber(ItemPointerData *pointer, OffsetNumber offsetNumber)
static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
static BlockNumber ItemPointerGetBlockNumberNoCheck(const ItemPointerData *pointer)
static void ItemPointerCopy(const ItemPointerData *fromPointer, ItemPointerData *toPointer)
static bool ItemPointerIsValid(const ItemPointerData *pointer)
void XactLockTableWait(TransactionId xid, Relation rel, ItemPointer ctid, XLTW_Oper oper)
void LockTuple(Relation relation, ItemPointer tid, LOCKMODE lockmode)
bool ConditionalXactLockTableWait(TransactionId xid)
void UnlockTuple(Relation relation, ItemPointer tid, LOCKMODE lockmode)
bool LockHeldByMe(const LOCKTAG *locktag, LOCKMODE lockmode, bool orstronger)
bool DoLockModesConflict(LOCKMODE mode1, LOCKMODE mode2)
#define SET_LOCKTAG_RELATION(locktag, dboid, reloid)
#define SET_LOCKTAG_TUPLE(locktag, dboid, reloid, blocknum, offnum)
#define AccessExclusiveLock
#define ShareRowExclusiveLock
#define InplaceUpdateTupleLock
#define ShareUpdateExclusiveLock
@ LockTupleNoKeyExclusive
void pfree(void *pointer)
#define IsBootstrapProcessingMode()
#define START_CRIT_SECTION()
#define CHECK_FOR_INTERRUPTS()
#define END_CRIT_SECTION()
MultiXactId MultiXactIdExpand(MultiXactId multi, TransactionId xid, MultiXactStatus status)
bool MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
bool MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)
bool MultiXactIdIsRunning(MultiXactId multi, bool isLockOnly)
void MultiXactIdSetOldestMember(void)
MultiXactId MultiXactIdCreateFromMembers(int nmembers, MultiXactMember *members)
MultiXactId MultiXactIdCreate(TransactionId xid1, MultiXactStatus status1, TransactionId xid2, MultiXactStatus status2)
int GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members, bool from_pgupgrade, bool isLockOnly)
#define MultiXactIdIsValid(multi)
@ MultiXactStatusForShare
@ MultiXactStatusForNoKeyUpdate
@ MultiXactStatusNoKeyUpdate
@ MultiXactStatusForUpdate
@ MultiXactStatusForKeyShare
#define ISUPDATE_from_mxstatus(status)
#define InvalidMultiXactId
#define MaxMultiXactStatus
#define InvalidOffsetNumber
#define OffsetNumberIsValid(offsetNumber)
#define OffsetNumberNext(offsetNumber)
#define FirstOffsetNumber
#define OffsetNumberPrev(offsetNumber)
Datum lower(PG_FUNCTION_ARGS)
Datum upper(PG_FUNCTION_ARGS)
Operator oper(ParseState *pstate, List *opname, Oid ltypeId, Oid rtypeId, bool noError, int location)
FormData_pg_attribute * Form_pg_attribute
#define ERRCODE_DATA_CORRUPTED
static uint32 pg_nextpower2_32(uint32 num)
static PgChecksumMode mode
static const struct exclude_list_item skip[]
FormData_pg_class * Form_pg_class
FormData_pg_database * Form_pg_database
#define pgstat_count_heap_getnext(rel)
#define pgstat_count_heap_scan(rel)
void pgstat_count_heap_update(Relation rel, bool hot, bool newpage)
void pgstat_count_heap_delete(Relation rel)
void pgstat_count_heap_insert(Relation rel, PgStat_Counter n)
#define qsort(a, b, c, d)
static Oid DatumGetObjectId(Datum X)
static Pointer DatumGetPointer(Datum X)
void CheckForSerializableConflictOut(Relation relation, TransactionId xid, Snapshot snapshot)
void CheckForSerializableConflictIn(Relation relation, ItemPointer tid, BlockNumber blkno)
void PredicateLockTID(Relation relation, ItemPointer tid, Snapshot snapshot, TransactionId tuple_xid)
void PredicateLockRelation(Relation relation, Snapshot snapshot)
bool CheckForSerializableConflictOutNeeded(Relation relation, Snapshot snapshot)
#define DELAY_CHKPT_START
GlobalVisState * GlobalVisTestFor(Relation rel)
bool TransactionIdIsInProgress(TransactionId xid)
void heap_page_prune_opt(Relation relation, Buffer buffer)
ReadStream * read_stream_begin_relation(int flags, BufferAccessStrategy strategy, Relation rel, ForkNumber forknum, ReadStreamBlockNumberCB callback, void *callback_private_data, size_t per_buffer_data_size)
void read_stream_reset(ReadStream *stream)
Buffer read_stream_next_buffer(ReadStream *stream, void **per_buffer_data)
void read_stream_end(ReadStream *stream)
BlockNumber(* ReadStreamBlockNumberCB)(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
#define READ_STREAM_SEQUENTIAL
#define RelationGetRelid(relation)
#define RelationIsLogicallyLogged(relation)
#define RelationGetTargetPageFreeSpace(relation, defaultff)
#define RelationGetDescr(relation)
#define RelationGetNumberOfAttributes(relation)
#define RelationGetRelationName(relation)
#define RelationIsAccessibleInLogicalDecoding(relation)
#define RelationNeedsWAL(relation)
#define RelationUsesLocalBuffers(relation)
#define HEAP_DEFAULT_FILLFACTOR
void RelationDecrementReferenceCount(Relation rel)
void RelationIncrementReferenceCount(Relation rel)
Bitmapset * RelationGetIndexAttrBitmap(Relation relation, IndexAttrBitmapKind attrKind)
@ INDEX_ATTR_BITMAP_HOT_BLOCKING
@ INDEX_ATTR_BITMAP_SUMMARIZED
@ INDEX_ATTR_BITMAP_IDENTITY_KEY
struct ParallelBlockTableScanDescData * ParallelBlockTableScanDesc
#define ScanDirectionIsForward(direction)
#define ScanDirectionIsBackward(direction)
void UnregisterSnapshot(Snapshot snapshot)
TransactionId TransactionXmin
void InvalidateCatalogSnapshot(void)
#define InitNonVacuumableSnapshot(snapshotdata, vistestp)
#define IsMVCCSnapshot(snapshot)
int get_tablespace_maintenance_io_concurrency(Oid spcid)
BufferAccessStrategy strategy
uint32 already_extended_by
MultiXactId NoFreezePageRelminMxid
TransactionId FreezePageRelfrozenXid
MultiXactId FreezePageRelminMxid
TransactionId NoFreezePageRelfrozenXid
BufferAccessStrategy rs_strategy
ParallelBlockTableScanWorkerData * rs_parallelworkerdata
BlockNumber rs_startblock
OffsetNumber rs_vistuples[MaxHeapTuplesPerPage]
ReadStream * rs_read_stream
int rs_empty_tuples_pending
BlockNumber rs_prefetch_block
TableScanDescData rs_base
const struct TableAmRoutine * rd_tableam
RelFileLocator rd_locator
union TableScanDescData::@48 st
struct ScanKeyData * rs_key
struct SnapshotData * rs_snapshot
struct ParallelTableScanDescData * rs_parallel
struct TableScanDescData::@48::@50 tidrange
TransactionId FreezeLimit
TransactionId relfrozenxid
MultiXactId MultiXactCutoff
bool relcacheInitFileInval
OffsetNumber offsets[FLEXIBLE_ARRAY_MEMBER]
ItemPointerData target_tid
RelFileLocator target_locator
TransactionId snapshotConflictHorizon
TransactionId SubTransGetTopmostTransaction(TransactionId xid)
void ss_report_location(Relation rel, BlockNumber location)
BlockNumber ss_get_location(Relation rel, BlockNumber relnblocks)
#define FirstLowInvalidHeapAttributeNumber
#define TableOidAttributeNumber
void table_block_parallelscan_startblock_init(Relation rel, ParallelBlockTableScanWorker pbscanwork, ParallelBlockTableScanDesc pbscan)
BlockNumber table_block_parallelscan_nextpage(Relation rel, ParallelBlockTableScanWorker pbscanwork, ParallelBlockTableScanDesc pbscan)
bool synchronize_seqscans
bool TransactionIdDidCommit(TransactionId transactionId)
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
bool TransactionIdDidAbort(TransactionId transactionId)
bool TransactionIdFollows(TransactionId id1, TransactionId id2)
bool TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2)
#define InvalidTransactionId
#define TransactionIdEquals(id1, id2)
#define TransactionIdIsValid(xid)
#define TransactionIdIsNormal(xid)
#define TupleDescAttr(tupdesc, i)
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
static bool HeapKeyTest(HeapTuple tuple, TupleDesc tupdesc, int nkeys, ScanKey keys)
#define VARATT_IS_EXTERNAL(PTR)
void visibilitymap_set(Relation rel, BlockNumber heapBlk, Buffer heapBuf, XLogRecPtr recptr, Buffer vmBuf, TransactionId cutoff_xid, uint8 flags)
bool visibilitymap_pin_ok(BlockNumber heapBlk, Buffer vmbuf)
bool visibilitymap_clear(Relation rel, BlockNumber heapBlk, Buffer vmbuf, uint8 flags)
void visibilitymap_pin(Relation rel, BlockNumber heapBlk, Buffer *vmbuf)
#define VISIBILITYMAP_VALID_BITS
#define VISIBILITYMAP_ALL_FROZEN
#define VISIBILITYMAP_XLOG_CATALOG_REL
#define VISIBILITYMAP_ALL_VISIBLE
TransactionId GetTopTransactionId(void)
TransactionId CheckXidAlive
TransactionId GetTopTransactionIdIfAny(void)
bool TransactionIdIsCurrentTransactionId(TransactionId xid)
bool IsInParallelMode(void)
TransactionId GetCurrentTransactionId(void)
CommandId GetCurrentCommandId(bool used)
#define XLOG_INCLUDE_ORIGIN
#define XLogHintBitIsNeeded()
#define XLogStandbyInfoActive()
#define InvalidXLogRecPtr
void XLogRegisterBufData(uint8 block_id, const char *data, uint32 len)
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
bool XLogCheckBufferNeedsBackup(Buffer buffer)
void XLogSetRecordFlags(uint8 flags)
void XLogRegisterBlock(uint8 block_id, RelFileLocator *rlocator, ForkNumber forknum, BlockNumber blknum, const char *page, uint8 flags)
void XLogRegisterData(const char *data, uint32 len)
void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
void XLogBeginInsert(void)