#include "/build/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pgrx-pg-sys-0.17.0/include/pg18.h"

// Static wrappers

void initReadOnlyStringInfo__pgrx_cshim(StringInfo str, char *data, int len) { initReadOnlyStringInfo(str, data, len); }
void initStringInfoFromString__pgrx_cshim(StringInfo str, char *data, int len) { initStringInfoFromString(str, data, len); }
bool DatumGetBool__pgrx_cshim(Datum X) { return DatumGetBool(X); }
Datum BoolGetDatum__pgrx_cshim(bool X) { return BoolGetDatum(X); }
char DatumGetChar__pgrx_cshim(Datum X) { return DatumGetChar(X); }
Datum CharGetDatum__pgrx_cshim(char X) { return CharGetDatum(X); }
Datum Int8GetDatum__pgrx_cshim(int8 X) { return Int8GetDatum(X); }
uint8 DatumGetUInt8__pgrx_cshim(Datum X) { return DatumGetUInt8(X); }
Datum UInt8GetDatum__pgrx_cshim(uint8 X) { return UInt8GetDatum(X); }
int16 DatumGetInt16__pgrx_cshim(Datum X) { return DatumGetInt16(X); }
Datum Int16GetDatum__pgrx_cshim(int16 X) { return Int16GetDatum(X); }
uint16 DatumGetUInt16__pgrx_cshim(Datum X) { return DatumGetUInt16(X); }
Datum UInt16GetDatum__pgrx_cshim(uint16 X) { return UInt16GetDatum(X); }
int32 DatumGetInt32__pgrx_cshim(Datum X) { return DatumGetInt32(X); }
Datum Int32GetDatum__pgrx_cshim(int32 X) { return Int32GetDatum(X); }
uint32 DatumGetUInt32__pgrx_cshim(Datum X) { return DatumGetUInt32(X); }
Datum UInt32GetDatum__pgrx_cshim(uint32 X) { return UInt32GetDatum(X); }
Oid DatumGetObjectId__pgrx_cshim(Datum X) { return DatumGetObjectId(X); }
Datum ObjectIdGetDatum__pgrx_cshim(Oid X) { return ObjectIdGetDatum(X); }
TransactionId DatumGetTransactionId__pgrx_cshim(Datum X) { return DatumGetTransactionId(X); }
Datum TransactionIdGetDatum__pgrx_cshim(TransactionId X) { return TransactionIdGetDatum(X); }
Datum MultiXactIdGetDatum__pgrx_cshim(MultiXactId X) { return MultiXactIdGetDatum(X); }
CommandId DatumGetCommandId__pgrx_cshim(Datum X) { return DatumGetCommandId(X); }
Datum CommandIdGetDatum__pgrx_cshim(CommandId X) { return CommandIdGetDatum(X); }
Pointer DatumGetPointer__pgrx_cshim(Datum X) { return DatumGetPointer(X); }
Datum PointerGetDatum__pgrx_cshim(const void *X) { return PointerGetDatum(X); }
char * DatumGetCString__pgrx_cshim(Datum X) { return DatumGetCString(X); }
Datum CStringGetDatum__pgrx_cshim(const char *X) { return CStringGetDatum(X); }
Name DatumGetName__pgrx_cshim(Datum X) { return DatumGetName(X); }
Datum NameGetDatum__pgrx_cshim(const NameData *X) { return NameGetDatum(X); }
int64 DatumGetInt64__pgrx_cshim(Datum X) { return DatumGetInt64(X); }
Datum Int64GetDatum__pgrx_cshim(int64 X) { return Int64GetDatum(X); }
uint64 DatumGetUInt64__pgrx_cshim(Datum X) { return DatumGetUInt64(X); }
Datum UInt64GetDatum__pgrx_cshim(uint64 X) { return UInt64GetDatum(X); }
float4 DatumGetFloat4__pgrx_cshim(Datum X) { return DatumGetFloat4(X); }
Datum Float4GetDatum__pgrx_cshim(float4 X) { return Float4GetDatum(X); }
float8 DatumGetFloat8__pgrx_cshim(Datum X) { return DatumGetFloat8(X); }
Datum Float8GetDatum__pgrx_cshim(float8 X) { return Float8GetDatum(X); }
Node * newNode__pgrx_cshim(size_t size, NodeTag tag) { return newNode(size, tag); }
ListCell * list_head__pgrx_cshim(const List *l) { return list_head(l); }
ListCell * list_tail__pgrx_cshim(const List *l) { return list_tail(l); }
ListCell * list_second_cell__pgrx_cshim(const List *l) { return list_second_cell(l); }
int list_length__pgrx_cshim(const List *l) { return list_length(l); }
ListCell * list_nth_cell__pgrx_cshim(const List *list, int n) { return list_nth_cell(list, n); }
ListCell * list_last_cell__pgrx_cshim(const List *list) { return list_last_cell(list); }
void * list_nth__pgrx_cshim(const List *list, int n) { return list_nth(list, n); }
int list_nth_int__pgrx_cshim(const List *list, int n) { return list_nth_int(list, n); }
Oid list_nth_oid__pgrx_cshim(const List *list, int n) { return list_nth_oid(list, n); }
int list_cell_number__pgrx_cshim(const List *l, const ListCell *c) { return list_cell_number(l, c); }
ListCell * lnext__pgrx_cshim(const List *l, const ListCell *c) { return lnext(l, c); }
ForEachState for_each_from_setup__pgrx_cshim(const List *lst, int N) { return for_each_from_setup(lst, N); }
ForEachState for_each_cell_setup__pgrx_cshim(const List *lst, const ListCell *initcell) { return for_each_cell_setup(lst, initcell); }
ForBothCellState for_both_cell_setup__pgrx_cshim(const List *list1, const ListCell *initcell1, const List *list2, const ListCell *initcell2) { return for_both_cell_setup(list1, initcell1, list2, initcell2); }
FormData_pg_attribute * TupleDescAttr__pgrx_cshim(TupleDesc tupdesc, int i) { return TupleDescAttr(tupdesc, i); }
CompactAttribute * TupleDescCompactAttr__pgrx_cshim(TupleDesc tupdesc, int i) { return TupleDescCompactAttr(tupdesc, i); }
bool BlockNumberIsValid__pgrx_cshim(BlockNumber blockNumber) { return BlockNumberIsValid(blockNumber); }
void BlockIdSet__pgrx_cshim(BlockIdData *blockId, BlockNumber blockNumber) { BlockIdSet(blockId, blockNumber); }
bool BlockIdEquals__pgrx_cshim(const BlockIdData *blockId1, const BlockIdData *blockId2) { return BlockIdEquals(blockId1, blockId2); }
BlockNumber BlockIdGetBlockNumber__pgrx_cshim(const BlockIdData *blockId) { return BlockIdGetBlockNumber(blockId); }
bool ItemPointerIsValid__pgrx_cshim(const ItemPointerData *pointer) { return ItemPointerIsValid(pointer); }
BlockNumber ItemPointerGetBlockNumberNoCheck__pgrx_cshim(const ItemPointerData *pointer) { return ItemPointerGetBlockNumberNoCheck(pointer); }
BlockNumber ItemPointerGetBlockNumber__pgrx_cshim(const ItemPointerData *pointer) { return ItemPointerGetBlockNumber(pointer); }
OffsetNumber ItemPointerGetOffsetNumberNoCheck__pgrx_cshim(const ItemPointerData *pointer) { return ItemPointerGetOffsetNumberNoCheck(pointer); }
OffsetNumber ItemPointerGetOffsetNumber__pgrx_cshim(const ItemPointerData *pointer) { return ItemPointerGetOffsetNumber(pointer); }
void ItemPointerSet__pgrx_cshim(ItemPointerData *pointer, BlockNumber blockNumber, OffsetNumber offNum) { ItemPointerSet(pointer, blockNumber, offNum); }
void ItemPointerSetBlockNumber__pgrx_cshim(ItemPointerData *pointer, BlockNumber blockNumber) { ItemPointerSetBlockNumber(pointer, blockNumber); }
void ItemPointerSetOffsetNumber__pgrx_cshim(ItemPointerData *pointer, OffsetNumber offsetNumber) { ItemPointerSetOffsetNumber(pointer, offsetNumber); }
void ItemPointerCopy__pgrx_cshim(const ItemPointerData *fromPointer, ItemPointerData *toPointer) { ItemPointerCopy(fromPointer, toPointer); }
void ItemPointerSetInvalid__pgrx_cshim(ItemPointerData *pointer) { ItemPointerSetInvalid(pointer); }
bool ItemPointerIndicatesMovedPartitions__pgrx_cshim(const ItemPointerData *pointer) { return ItemPointerIndicatesMovedPartitions(pointer); }
void ItemPointerSetMovedPartitions__pgrx_cshim(ItemPointerData *pointer) { ItemPointerSetMovedPartitions(pointer); }
ItemPointer DatumGetItemPointer__pgrx_cshim(Datum X) { return DatumGetItemPointer(X); }
Datum ItemPointerGetDatum__pgrx_cshim(const ItemPointerData *X) { return ItemPointerGetDatum(X); }
FullTransactionId FullTransactionIdFromEpochAndXid__pgrx_cshim(uint32 epoch, TransactionId xid) { return FullTransactionIdFromEpochAndXid(epoch, xid); }
FullTransactionId FullTransactionIdFromU64__pgrx_cshim(uint64 value) { return FullTransactionIdFromU64(value); }
void FullTransactionIdRetreat__pgrx_cshim(FullTransactionId *dest) { FullTransactionIdRetreat(dest); }
void FullTransactionIdAdvance__pgrx_cshim(FullTransactionId *dest) { FullTransactionIdAdvance(dest); }
TransactionId ReadNextTransactionId__pgrx_cshim(void) { return ReadNextTransactionId(); }
TransactionId TransactionIdRetreatedBy__pgrx_cshim(TransactionId xid, uint32 amount) { return TransactionIdRetreatedBy(xid, amount); }
TransactionId TransactionIdOlder__pgrx_cshim(TransactionId a, TransactionId b) { return TransactionIdOlder(a, b); }
TransactionId NormalTransactionIdOlder__pgrx_cshim(TransactionId a, TransactionId b) { return NormalTransactionIdOlder(a, b); }
FullTransactionId FullTransactionIdNewer__pgrx_cshim(FullTransactionId a, FullTransactionId b) { return FullTransactionIdNewer(a, b); }
FullTransactionId FullTransactionIdFromAllowableAt__pgrx_cshim(FullTransactionId nextFullXid, TransactionId xid) { return FullTransactionIdFromAllowableAt(nextFullXid, xid); }
bool att_isnull__pgrx_cshim(int ATT, const bits8 *BITS) { return att_isnull(ATT, BITS); }
Datum fetch_att__pgrx_cshim(const void *T, bool attbyval, int attlen) { return fetch_att(T, attbyval, attlen); }
void store_att_byval__pgrx_cshim(void *T, Datum newdatum, int attlen) { store_att_byval(T, newdatum, attlen); }
XLogRecPtr PageXLogRecPtrGet__pgrx_cshim(PageXLogRecPtr val) { return PageXLogRecPtrGet(val); }
bool PageIsEmpty__pgrx_cshim(const PageData *page) { return PageIsEmpty(page); }
bool PageIsNew__pgrx_cshim(const PageData *page) { return PageIsNew(page); }
ItemId PageGetItemId__pgrx_cshim(Page page, OffsetNumber offsetNumber) { return PageGetItemId(page, offsetNumber); }
char * PageGetContents__pgrx_cshim(Page page) { return PageGetContents(page); }
Size PageGetPageSize__pgrx_cshim(const PageData *page) { return PageGetPageSize(page); }
uint8 PageGetPageLayoutVersion__pgrx_cshim(const PageData *page) { return PageGetPageLayoutVersion(page); }
void PageSetPageSizeAndVersion__pgrx_cshim(Page page, Size size, uint8 version) { PageSetPageSizeAndVersion(page, size, version); }
uint16 PageGetSpecialSize__pgrx_cshim(const PageData *page) { return PageGetSpecialSize(page); }
Item PageGetItem__pgrx_cshim(const PageData *page, const ItemIdData *itemId) { return PageGetItem(page, itemId); }
OffsetNumber PageGetMaxOffsetNumber__pgrx_cshim(const PageData *page) { return PageGetMaxOffsetNumber(page); }
XLogRecPtr PageGetLSN__pgrx_cshim(const PageData *page) { return PageGetLSN(page); }
void PageSetLSN__pgrx_cshim(Page page, XLogRecPtr lsn) { PageSetLSN(page, lsn); }
bool PageHasFreeLinePointers__pgrx_cshim(const PageData *page) { return PageHasFreeLinePointers(page); }
void PageSetHasFreeLinePointers__pgrx_cshim(Page page) { PageSetHasFreeLinePointers(page); }
void PageClearHasFreeLinePointers__pgrx_cshim(Page page) { PageClearHasFreeLinePointers(page); }
bool PageIsFull__pgrx_cshim(const PageData *page) { return PageIsFull(page); }
void PageSetFull__pgrx_cshim(Page page) { PageSetFull(page); }
void PageClearFull__pgrx_cshim(Page page) { PageClearFull(page); }
bool PageIsAllVisible__pgrx_cshim(const PageData *page) { return PageIsAllVisible(page); }
void PageSetAllVisible__pgrx_cshim(Page page) { PageSetAllVisible(page); }
void PageClearAllVisible__pgrx_cshim(Page page) { PageClearAllVisible(page); }
bool HEAP_XMAX_IS_LOCKED_ONLY__pgrx_cshim(uint16 infomask) { return HEAP_XMAX_IS_LOCKED_ONLY(infomask); }
bool HEAP_LOCKED_UPGRADED__pgrx_cshim(uint16 infomask) { return HEAP_LOCKED_UPGRADED(infomask); }
bool HEAP_XMAX_IS_SHR_LOCKED__pgrx_cshim(int16 infomask) { return HEAP_XMAX_IS_SHR_LOCKED(infomask); }
bool HEAP_XMAX_IS_EXCL_LOCKED__pgrx_cshim(int16 infomask) { return HEAP_XMAX_IS_EXCL_LOCKED(infomask); }
bool HEAP_XMAX_IS_KEYSHR_LOCKED__pgrx_cshim(int16 infomask) { return HEAP_XMAX_IS_KEYSHR_LOCKED(infomask); }
bool HeapTupleHeaderXminFrozen__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderXminFrozen(tup); }
TransactionId HeapTupleHeaderGetRawXmin__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderGetRawXmin(tup); }
TransactionId HeapTupleHeaderGetXmin__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderGetXmin(tup); }
void HeapTupleHeaderSetXmin__pgrx_cshim(HeapTupleHeaderData *tup, TransactionId xid) { HeapTupleHeaderSetXmin(tup, xid); }
bool HeapTupleHeaderXminCommitted__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderXminCommitted(tup); }
bool HeapTupleHeaderXminInvalid__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderXminInvalid(tup); }
void HeapTupleHeaderSetXminCommitted__pgrx_cshim(HeapTupleHeaderData *tup) { HeapTupleHeaderSetXminCommitted(tup); }
void HeapTupleHeaderSetXminInvalid__pgrx_cshim(HeapTupleHeaderData *tup) { HeapTupleHeaderSetXminInvalid(tup); }
void HeapTupleHeaderSetXminFrozen__pgrx_cshim(HeapTupleHeaderData *tup) { HeapTupleHeaderSetXminFrozen(tup); }
TransactionId HeapTupleHeaderGetRawXmax__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderGetRawXmax(tup); }
void HeapTupleHeaderSetXmax__pgrx_cshim(HeapTupleHeaderData *tup, TransactionId xid) { HeapTupleHeaderSetXmax(tup, xid); }
TransactionId HeapTupleHeaderGetUpdateXid__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderGetUpdateXid(tup); }
CommandId HeapTupleHeaderGetRawCommandId__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderGetRawCommandId(tup); }
void HeapTupleHeaderSetCmin__pgrx_cshim(HeapTupleHeaderData *tup, CommandId cid) { HeapTupleHeaderSetCmin(tup, cid); }
void HeapTupleHeaderSetCmax__pgrx_cshim(HeapTupleHeaderData *tup, CommandId cid, bool iscombo) { HeapTupleHeaderSetCmax(tup, cid, iscombo); }
TransactionId HeapTupleHeaderGetXvac__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderGetXvac(tup); }
void HeapTupleHeaderSetXvac__pgrx_cshim(HeapTupleHeaderData *tup, TransactionId xid) { HeapTupleHeaderSetXvac(tup, xid); }
bool HeapTupleHeaderIsSpeculative__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderIsSpeculative(tup); }
BlockNumber HeapTupleHeaderGetSpeculativeToken__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderGetSpeculativeToken(tup); }
void HeapTupleHeaderSetSpeculativeToken__pgrx_cshim(HeapTupleHeaderData *tup, BlockNumber token) { HeapTupleHeaderSetSpeculativeToken(tup, token); }
bool HeapTupleHeaderIndicatesMovedPartitions__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderIndicatesMovedPartitions(tup); }
void HeapTupleHeaderSetMovedPartitions__pgrx_cshim(HeapTupleHeaderData *tup) { HeapTupleHeaderSetMovedPartitions(tup); }
uint32 HeapTupleHeaderGetDatumLength__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderGetDatumLength(tup); }
void HeapTupleHeaderSetDatumLength__pgrx_cshim(HeapTupleHeaderData *tup, uint32 len) { HeapTupleHeaderSetDatumLength(tup, len); }
Oid HeapTupleHeaderGetTypeId__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderGetTypeId(tup); }
void HeapTupleHeaderSetTypeId__pgrx_cshim(HeapTupleHeaderData *tup, Oid datum_typeid) { HeapTupleHeaderSetTypeId(tup, datum_typeid); }
int32 HeapTupleHeaderGetTypMod__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderGetTypMod(tup); }
void HeapTupleHeaderSetTypMod__pgrx_cshim(HeapTupleHeaderData *tup, int32 typmod) { HeapTupleHeaderSetTypMod(tup, typmod); }
bool HeapTupleHeaderIsHotUpdated__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderIsHotUpdated(tup); }
void HeapTupleHeaderSetHotUpdated__pgrx_cshim(HeapTupleHeaderData *tup) { HeapTupleHeaderSetHotUpdated(tup); }
void HeapTupleHeaderClearHotUpdated__pgrx_cshim(HeapTupleHeaderData *tup) { HeapTupleHeaderClearHotUpdated(tup); }
bool HeapTupleHeaderIsHeapOnly__pgrx_cshim(const HeapTupleHeaderData *tup) { return HeapTupleHeaderIsHeapOnly(tup); }
void HeapTupleHeaderSetHeapOnly__pgrx_cshim(HeapTupleHeaderData *tup) { HeapTupleHeaderSetHeapOnly(tup); }
void HeapTupleHeaderClearHeapOnly__pgrx_cshim(HeapTupleHeaderData *tup) { HeapTupleHeaderClearHeapOnly(tup); }
int BITMAPLEN__pgrx_cshim(int NATTS) { return BITMAPLEN(NATTS); }
bool HeapTupleHeaderHasMatch__pgrx_cshim(const MinimalTupleData *tup) { return HeapTupleHeaderHasMatch(tup); }
void HeapTupleHeaderSetMatch__pgrx_cshim(MinimalTupleData *tup) { HeapTupleHeaderSetMatch(tup); }
void HeapTupleHeaderClearMatch__pgrx_cshim(MinimalTupleData *tup) { HeapTupleHeaderClearMatch(tup); }
bool HeapTupleHasNulls__pgrx_cshim(const HeapTupleData *tuple) { return HeapTupleHasNulls(tuple); }
bool HeapTupleNoNulls__pgrx_cshim(const HeapTupleData *tuple) { return HeapTupleNoNulls(tuple); }
bool HeapTupleHasVarWidth__pgrx_cshim(const HeapTupleData *tuple) { return HeapTupleHasVarWidth(tuple); }
bool HeapTupleAllFixed__pgrx_cshim(const HeapTupleData *tuple) { return HeapTupleAllFixed(tuple); }
bool HeapTupleHasExternal__pgrx_cshim(const HeapTupleData *tuple) { return HeapTupleHasExternal(tuple); }
bool HeapTupleIsHotUpdated__pgrx_cshim(const HeapTupleData *tuple) { return HeapTupleIsHotUpdated(tuple); }
void HeapTupleSetHotUpdated__pgrx_cshim(const HeapTupleData *tuple) { HeapTupleSetHotUpdated(tuple); }
void HeapTupleClearHotUpdated__pgrx_cshim(const HeapTupleData *tuple) { HeapTupleClearHotUpdated(tuple); }
bool HeapTupleIsHeapOnly__pgrx_cshim(const HeapTupleData *tuple) { return HeapTupleIsHeapOnly(tuple); }
void HeapTupleSetHeapOnly__pgrx_cshim(const HeapTupleData *tuple) { HeapTupleSetHeapOnly(tuple); }
void HeapTupleClearHeapOnly__pgrx_cshim(const HeapTupleData *tuple) { HeapTupleClearHeapOnly(tuple); }
Datum fastgetattr__pgrx_cshim(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull) { return fastgetattr(tup, attnum, tupleDesc, isnull); }
void slot_getsomeattrs__pgrx_cshim(TupleTableSlot *slot, int attnum) { slot_getsomeattrs(slot, attnum); }
void slot_getallattrs__pgrx_cshim(TupleTableSlot *slot) { slot_getallattrs(slot); }
bool slot_attisnull__pgrx_cshim(TupleTableSlot *slot, int attnum) { return slot_attisnull(slot, attnum); }
Datum slot_getattr__pgrx_cshim(TupleTableSlot *slot, int attnum, bool *isnull) { return slot_getattr(slot, attnum, isnull); }
Datum slot_getsysattr__pgrx_cshim(TupleTableSlot *slot, int attnum, bool *isnull) { return slot_getsysattr(slot, attnum, isnull); }
bool slot_is_current_xact_tuple__pgrx_cshim(TupleTableSlot *slot) { return slot_is_current_xact_tuple(slot); }
TupleTableSlot * ExecClearTuple__pgrx_cshim(TupleTableSlot *slot) { return ExecClearTuple(slot); }
void ExecMaterializeSlot__pgrx_cshim(TupleTableSlot *slot) { ExecMaterializeSlot(slot); }
HeapTuple ExecCopySlotHeapTuple__pgrx_cshim(TupleTableSlot *slot) { return ExecCopySlotHeapTuple(slot); }
MinimalTuple ExecCopySlotMinimalTuple__pgrx_cshim(TupleTableSlot *slot) { return ExecCopySlotMinimalTuple(slot); }
MinimalTuple ExecCopySlotMinimalTupleExtra__pgrx_cshim(TupleTableSlot *slot, Size extra) { return ExecCopySlotMinimalTupleExtra(slot, extra); }
TupleTableSlot * ExecCopySlot__pgrx_cshim(TupleTableSlot *dstslot, TupleTableSlot *srcslot) { return ExecCopySlot(dstslot, srcslot); }
instr_time pg_clock_gettime_ns__pgrx_cshim(void) { return pg_clock_gettime_ns(); }
void dlist_init__pgrx_cshim(dlist_head *head) { dlist_init(head); }
void dlist_node_init__pgrx_cshim(dlist_node *node) { dlist_node_init(node); }
bool dlist_is_empty__pgrx_cshim(const dlist_head *head) { return dlist_is_empty(head); }
void dlist_push_head__pgrx_cshim(dlist_head *head, dlist_node *node) { dlist_push_head(head, node); }
void dlist_push_tail__pgrx_cshim(dlist_head *head, dlist_node *node) { dlist_push_tail(head, node); }
void dlist_insert_after__pgrx_cshim(dlist_node *after, dlist_node *node) { dlist_insert_after(after, node); }
void dlist_insert_before__pgrx_cshim(dlist_node *before, dlist_node *node) { dlist_insert_before(before, node); }
void dlist_delete__pgrx_cshim(dlist_node *node) { dlist_delete(node); }
void dlist_delete_thoroughly__pgrx_cshim(dlist_node *node) { dlist_delete_thoroughly(node); }
void dlist_delete_from__pgrx_cshim(dlist_head *head, dlist_node *node) { dlist_delete_from(head, node); }
void dlist_delete_from_thoroughly__pgrx_cshim(dlist_head *head, dlist_node *node) { dlist_delete_from_thoroughly(head, node); }
dlist_node * dlist_pop_head_node__pgrx_cshim(dlist_head *head) { return dlist_pop_head_node(head); }
void dlist_move_head__pgrx_cshim(dlist_head *head, dlist_node *node) { dlist_move_head(head, node); }
void dlist_move_tail__pgrx_cshim(dlist_head *head, dlist_node *node) { dlist_move_tail(head, node); }
bool dlist_has_next__pgrx_cshim(const dlist_head *head, const dlist_node *node) { return dlist_has_next(head, node); }
bool dlist_has_prev__pgrx_cshim(const dlist_head *head, const dlist_node *node) { return dlist_has_prev(head, node); }
bool dlist_node_is_detached__pgrx_cshim(const dlist_node *node) { return dlist_node_is_detached(node); }
dlist_node * dlist_next_node__pgrx_cshim(dlist_head *head, dlist_node *node) { return dlist_next_node(head, node); }
dlist_node * dlist_prev_node__pgrx_cshim(dlist_head *head, dlist_node *node) { return dlist_prev_node(head, node); }
void * dlist_head_element_off__pgrx_cshim(dlist_head *head, size_t off) { return dlist_head_element_off(head, off); }
dlist_node * dlist_head_node__pgrx_cshim(dlist_head *head) { return dlist_head_node(head); }
void * dlist_tail_element_off__pgrx_cshim(dlist_head *head, size_t off) { return dlist_tail_element_off(head, off); }
dlist_node * dlist_tail_node__pgrx_cshim(dlist_head *head) { return dlist_tail_node(head); }
void dclist_init__pgrx_cshim(dclist_head *head) { dclist_init(head); }
bool dclist_is_empty__pgrx_cshim(const dclist_head *head) { return dclist_is_empty(head); }
void dclist_push_head__pgrx_cshim(dclist_head *head, dlist_node *node) { dclist_push_head(head, node); }
void dclist_push_tail__pgrx_cshim(dclist_head *head, dlist_node *node) { dclist_push_tail(head, node); }
void dclist_insert_after__pgrx_cshim(dclist_head *head, dlist_node *after, dlist_node *node) { dclist_insert_after(head, after, node); }
void dclist_insert_before__pgrx_cshim(dclist_head *head, dlist_node *before, dlist_node *node) { dclist_insert_before(head, before, node); }
void dclist_delete_from__pgrx_cshim(dclist_head *head, dlist_node *node) { dclist_delete_from(head, node); }
void dclist_delete_from_thoroughly__pgrx_cshim(dclist_head *head, dlist_node *node) { dclist_delete_from_thoroughly(head, node); }
dlist_node * dclist_pop_head_node__pgrx_cshim(dclist_head *head) { return dclist_pop_head_node(head); }
void dclist_move_head__pgrx_cshim(dclist_head *head, dlist_node *node) { dclist_move_head(head, node); }
void dclist_move_tail__pgrx_cshim(dclist_head *head, dlist_node *node) { dclist_move_tail(head, node); }
bool dclist_has_next__pgrx_cshim(const dclist_head *head, const dlist_node *node) { return dclist_has_next(head, node); }
bool dclist_has_prev__pgrx_cshim(const dclist_head *head, const dlist_node *node) { return dclist_has_prev(head, node); }
dlist_node * dclist_next_node__pgrx_cshim(dclist_head *head, dlist_node *node) { return dclist_next_node(head, node); }
dlist_node * dclist_prev_node__pgrx_cshim(dclist_head *head, dlist_node *node) { return dclist_prev_node(head, node); }
void * dclist_head_element_off__pgrx_cshim(dclist_head *head, size_t off) { return dclist_head_element_off(head, off); }
dlist_node * dclist_head_node__pgrx_cshim(dclist_head *head) { return dclist_head_node(head); }
void * dclist_tail_element_off__pgrx_cshim(dclist_head *head, size_t off) { return dclist_tail_element_off(head, off); }
dlist_node * dclist_tail_node__pgrx_cshim(dclist_head *head) { return dclist_tail_node(head); }
uint32 dclist_count__pgrx_cshim(const dclist_head *head) { return dclist_count(head); }
void slist_init__pgrx_cshim(slist_head *head) { slist_init(head); }
bool slist_is_empty__pgrx_cshim(const slist_head *head) { return slist_is_empty(head); }
void slist_push_head__pgrx_cshim(slist_head *head, slist_node *node) { slist_push_head(head, node); }
void slist_insert_after__pgrx_cshim(slist_node *after, slist_node *node) { slist_insert_after(after, node); }
slist_node * slist_pop_head_node__pgrx_cshim(slist_head *head) { return slist_pop_head_node(head); }
bool slist_has_next__pgrx_cshim(const slist_head *head, const slist_node *node) { return slist_has_next(head, node); }
slist_node * slist_next_node__pgrx_cshim(slist_head *head, slist_node *node) { return slist_next_node(head, node); }
void * slist_head_element_off__pgrx_cshim(slist_head *head, size_t off) { return slist_head_element_off(head, off); }
slist_node * slist_head_node__pgrx_cshim(slist_head *head) { return slist_head_node(head); }
void slist_delete_current__pgrx_cshim(slist_mutable_iter *iter) { slist_delete_current(iter); }
void pg_spin_delay_impl__pgrx_cshim(void) { pg_spin_delay_impl(); }
bool pg_atomic_test_set_flag_impl__pgrx_cshim(pg_atomic_flag *ptr) { return pg_atomic_test_set_flag_impl(ptr); }
void pg_atomic_clear_flag_impl__pgrx_cshim(pg_atomic_flag *ptr) { pg_atomic_clear_flag_impl(ptr); }
bool pg_atomic_compare_exchange_u32_impl__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 *expected, uint32 newval) { return pg_atomic_compare_exchange_u32_impl(ptr, expected, newval); }
uint32 pg_atomic_fetch_add_u32_impl__pgrx_cshim(pg_atomic_uint32 *ptr, int32 add_) { return pg_atomic_fetch_add_u32_impl(ptr, add_); }
bool pg_atomic_compare_exchange_u64_impl__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 *expected, uint64 newval) { return pg_atomic_compare_exchange_u64_impl(ptr, expected, newval); }
uint64 pg_atomic_fetch_add_u64_impl__pgrx_cshim(pg_atomic_uint64 *ptr, int64 add_) { return pg_atomic_fetch_add_u64_impl(ptr, add_); }
bool pg_atomic_unlocked_test_flag_impl__pgrx_cshim(pg_atomic_flag *ptr) { return pg_atomic_unlocked_test_flag_impl(ptr); }
void pg_atomic_init_flag_impl__pgrx_cshim(pg_atomic_flag *ptr) { pg_atomic_init_flag_impl(ptr); }
uint32 pg_atomic_exchange_u32_impl__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 newval) { return pg_atomic_exchange_u32_impl(ptr, newval); }
uint32 pg_atomic_fetch_sub_u32_impl__pgrx_cshim(pg_atomic_uint32 *ptr, int32 sub_) { return pg_atomic_fetch_sub_u32_impl(ptr, sub_); }
uint32 pg_atomic_fetch_and_u32_impl__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 and_) { return pg_atomic_fetch_and_u32_impl(ptr, and_); }
uint32 pg_atomic_fetch_or_u32_impl__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 or_) { return pg_atomic_fetch_or_u32_impl(ptr, or_); }
uint64 pg_atomic_exchange_u64_impl__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 newval) { return pg_atomic_exchange_u64_impl(ptr, newval); }
uint64 pg_atomic_fetch_sub_u64_impl__pgrx_cshim(pg_atomic_uint64 *ptr, int64 sub_) { return pg_atomic_fetch_sub_u64_impl(ptr, sub_); }
uint64 pg_atomic_fetch_and_u64_impl__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 and_) { return pg_atomic_fetch_and_u64_impl(ptr, and_); }
uint64 pg_atomic_fetch_or_u64_impl__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 or_) { return pg_atomic_fetch_or_u64_impl(ptr, or_); }
uint32 pg_atomic_read_u32_impl__pgrx_cshim(pg_atomic_uint32 *ptr) { return pg_atomic_read_u32_impl(ptr); }
void pg_atomic_write_u32_impl__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 val) { pg_atomic_write_u32_impl(ptr, val); }
void pg_atomic_unlocked_write_u32_impl__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 val) { pg_atomic_unlocked_write_u32_impl(ptr, val); }
void pg_atomic_init_u32_impl__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 val_) { pg_atomic_init_u32_impl(ptr, val_); }
uint32 pg_atomic_add_fetch_u32_impl__pgrx_cshim(pg_atomic_uint32 *ptr, int32 add_) { return pg_atomic_add_fetch_u32_impl(ptr, add_); }
uint32 pg_atomic_sub_fetch_u32_impl__pgrx_cshim(pg_atomic_uint32 *ptr, int32 sub_) { return pg_atomic_sub_fetch_u32_impl(ptr, sub_); }
uint32 pg_atomic_read_membarrier_u32_impl__pgrx_cshim(pg_atomic_uint32 *ptr) { return pg_atomic_read_membarrier_u32_impl(ptr); }
void pg_atomic_write_membarrier_u32_impl__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 val) { pg_atomic_write_membarrier_u32_impl(ptr, val); }
void pg_atomic_write_u64_impl__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 val) { pg_atomic_write_u64_impl(ptr, val); }
uint64 pg_atomic_read_u64_impl__pgrx_cshim(pg_atomic_uint64 *ptr) { return pg_atomic_read_u64_impl(ptr); }
void pg_atomic_init_u64_impl__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 val_) { pg_atomic_init_u64_impl(ptr, val_); }
uint64 pg_atomic_add_fetch_u64_impl__pgrx_cshim(pg_atomic_uint64 *ptr, int64 add_) { return pg_atomic_add_fetch_u64_impl(ptr, add_); }
uint64 pg_atomic_sub_fetch_u64_impl__pgrx_cshim(pg_atomic_uint64 *ptr, int64 sub_) { return pg_atomic_sub_fetch_u64_impl(ptr, sub_); }
uint64 pg_atomic_read_membarrier_u64_impl__pgrx_cshim(pg_atomic_uint64 *ptr) { return pg_atomic_read_membarrier_u64_impl(ptr); }
void pg_atomic_write_membarrier_u64_impl__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 val) { pg_atomic_write_membarrier_u64_impl(ptr, val); }
void pg_atomic_init_flag__pgrx_cshim(pg_atomic_flag *ptr) { pg_atomic_init_flag(ptr); }
bool pg_atomic_test_set_flag__pgrx_cshim(pg_atomic_flag *ptr) { return pg_atomic_test_set_flag(ptr); }
bool pg_atomic_unlocked_test_flag__pgrx_cshim(pg_atomic_flag *ptr) { return pg_atomic_unlocked_test_flag(ptr); }
void pg_atomic_clear_flag__pgrx_cshim(pg_atomic_flag *ptr) { pg_atomic_clear_flag(ptr); }
void pg_atomic_init_u32__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 val) { pg_atomic_init_u32(ptr, val); }
uint32 pg_atomic_read_u32__pgrx_cshim(pg_atomic_uint32 *ptr) { return pg_atomic_read_u32(ptr); }
uint32 pg_atomic_read_membarrier_u32__pgrx_cshim(pg_atomic_uint32 *ptr) { return pg_atomic_read_membarrier_u32(ptr); }
void pg_atomic_write_u32__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 val) { pg_atomic_write_u32(ptr, val); }
void pg_atomic_unlocked_write_u32__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 val) { pg_atomic_unlocked_write_u32(ptr, val); }
void pg_atomic_write_membarrier_u32__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 val) { pg_atomic_write_membarrier_u32(ptr, val); }
uint32 pg_atomic_exchange_u32__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 newval) { return pg_atomic_exchange_u32(ptr, newval); }
bool pg_atomic_compare_exchange_u32__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 *expected, uint32 newval) { return pg_atomic_compare_exchange_u32(ptr, expected, newval); }
uint32 pg_atomic_fetch_add_u32__pgrx_cshim(pg_atomic_uint32 *ptr, int32 add_) { return pg_atomic_fetch_add_u32(ptr, add_); }
uint32 pg_atomic_fetch_sub_u32__pgrx_cshim(pg_atomic_uint32 *ptr, int32 sub_) { return pg_atomic_fetch_sub_u32(ptr, sub_); }
uint32 pg_atomic_fetch_and_u32__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 and_) { return pg_atomic_fetch_and_u32(ptr, and_); }
uint32 pg_atomic_fetch_or_u32__pgrx_cshim(pg_atomic_uint32 *ptr, uint32 or_) { return pg_atomic_fetch_or_u32(ptr, or_); }
uint32 pg_atomic_add_fetch_u32__pgrx_cshim(pg_atomic_uint32 *ptr, int32 add_) { return pg_atomic_add_fetch_u32(ptr, add_); }
uint32 pg_atomic_sub_fetch_u32__pgrx_cshim(pg_atomic_uint32 *ptr, int32 sub_) { return pg_atomic_sub_fetch_u32(ptr, sub_); }
void pg_atomic_init_u64__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 val) { pg_atomic_init_u64(ptr, val); }
uint64 pg_atomic_read_u64__pgrx_cshim(pg_atomic_uint64 *ptr) { return pg_atomic_read_u64(ptr); }
uint64 pg_atomic_read_membarrier_u64__pgrx_cshim(pg_atomic_uint64 *ptr) { return pg_atomic_read_membarrier_u64(ptr); }
void pg_atomic_write_u64__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 val) { pg_atomic_write_u64(ptr, val); }
void pg_atomic_write_membarrier_u64__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 val) { pg_atomic_write_membarrier_u64(ptr, val); }
uint64 pg_atomic_exchange_u64__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 newval) { return pg_atomic_exchange_u64(ptr, newval); }
bool pg_atomic_compare_exchange_u64__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 *expected, uint64 newval) { return pg_atomic_compare_exchange_u64(ptr, expected, newval); }
uint64 pg_atomic_fetch_add_u64__pgrx_cshim(pg_atomic_uint64 *ptr, int64 add_) { return pg_atomic_fetch_add_u64(ptr, add_); }
uint64 pg_atomic_fetch_sub_u64__pgrx_cshim(pg_atomic_uint64 *ptr, int64 sub_) { return pg_atomic_fetch_sub_u64(ptr, sub_); }
uint64 pg_atomic_fetch_and_u64__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 and_) { return pg_atomic_fetch_and_u64(ptr, and_); }
uint64 pg_atomic_fetch_or_u64__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 or_) { return pg_atomic_fetch_or_u64(ptr, or_); }
uint64 pg_atomic_add_fetch_u64__pgrx_cshim(pg_atomic_uint64 *ptr, int64 add_) { return pg_atomic_add_fetch_u64(ptr, add_); }
uint64 pg_atomic_sub_fetch_u64__pgrx_cshim(pg_atomic_uint64 *ptr, int64 sub_) { return pg_atomic_sub_fetch_u64(ptr, sub_); }
uint64 pg_atomic_monotonic_advance_u64__pgrx_cshim(pg_atomic_uint64 *ptr, uint64 target) { return pg_atomic_monotonic_advance_u64(ptr, target); }
bool tbm_exhausted__pgrx_cshim(TBMIterator *iterator) { return tbm_exhausted(iterator); }
int tas__pgrx_cshim(slock_t *lock) { return tas(lock); }
void spin_delay__pgrx_cshim(void) { spin_delay(); }
void init_spin_delay__pgrx_cshim(SpinDelayStatus *status, const char *file, int line, const char *func) { init_spin_delay(status, file, line, func); }
ssize_t pg_preadv__pgrx_cshim(int fd, const struct iovec *iov, int iovcnt, off_t offset) { return pg_preadv(fd, iov, iovcnt, offset); }
ssize_t pg_pwritev__pgrx_cshim(int fd, const struct iovec *iov, int iovcnt, off_t offset) { return pg_pwritev(fd, iov, iovcnt, offset); }
ssize_t FileRead__pgrx_cshim(File file, void *buffer, size_t amount, off_t offset, uint32 wait_event_info) { return FileRead(file, buffer, amount, offset, wait_event_info); }
ssize_t FileWrite__pgrx_cshim(File file, const void *buffer, size_t amount, off_t offset, uint32 wait_event_info) { return FileWrite(file, buffer, amount, offset, wait_event_info); }
void AssertCouldGetRelation__pgrx_cshim(void) { AssertCouldGetRelation(); }
int ApplySortComparator__pgrx_cshim(Datum datum1, bool isNull1, Datum datum2, bool isNull2, SortSupport ssup) { return ApplySortComparator(datum1, isNull1, datum2, isNull2, ssup); }
int ApplyUnsignedSortComparator__pgrx_cshim(Datum datum1, bool isNull1, Datum datum2, bool isNull2, SortSupport ssup) { return ApplyUnsignedSortComparator(datum1, isNull1, datum2, isNull2, ssup); }
int ApplySignedSortComparator__pgrx_cshim(Datum datum1, bool isNull1, Datum datum2, bool isNull2, SortSupport ssup) { return ApplySignedSortComparator(datum1, isNull1, datum2, isNull2, ssup); }
int ApplyInt32SortComparator__pgrx_cshim(Datum datum1, bool isNull1, Datum datum2, bool isNull2, SortSupport ssup) { return ApplyInt32SortComparator(datum1, isNull1, datum2, isNull2, ssup); }
int ApplySortAbbrevFullComparator__pgrx_cshim(Datum datum1, bool isNull1, Datum datum2, bool isNull2, SortSupport ssup) { return ApplySortAbbrevFullComparator(datum1, isNull1, datum2, isNull2, ssup); }
ItemPointer GinTupleGetFirst__pgrx_cshim(GinTuple *tup) { return GinTupleGetFirst(tup); }
Size IndexTupleSize__pgrx_cshim(const IndexTupleData *itup) { return IndexTupleSize(itup); }
bool IndexTupleHasNulls__pgrx_cshim(const IndexTupleData *itup) { return IndexTupleHasNulls(itup); }
bool IndexTupleHasVarwidths__pgrx_cshim(const IndexTupleData *itup) { return IndexTupleHasVarwidths(itup); }
Size IndexInfoFindDataOffset__pgrx_cshim(unsigned short t_info) { return IndexInfoFindDataOffset(t_info); }
Datum index_getattr__pgrx_cshim(IndexTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull) { return index_getattr(tup, attnum, tupleDesc, isnull); }
int pg_leftmost_one_pos32__pgrx_cshim(uint32 word) { return pg_leftmost_one_pos32(word); }
int pg_leftmost_one_pos64__pgrx_cshim(uint64 word) { return pg_leftmost_one_pos64(word); }
int pg_rightmost_one_pos32__pgrx_cshim(uint32 word) { return pg_rightmost_one_pos32(word); }
int pg_rightmost_one_pos64__pgrx_cshim(uint64 word) { return pg_rightmost_one_pos64(word); }
uint32 pg_nextpower2_32__pgrx_cshim(uint32 num) { return pg_nextpower2_32(num); }
uint64 pg_nextpower2_64__pgrx_cshim(uint64 num) { return pg_nextpower2_64(num); }
uint32 pg_prevpower2_32__pgrx_cshim(uint32 num) { return pg_prevpower2_32(num); }
uint64 pg_prevpower2_64__pgrx_cshim(uint64 num) { return pg_prevpower2_64(num); }
uint32 pg_ceil_log2_32__pgrx_cshim(uint32 num) { return pg_ceil_log2_32(num); }
uint64 pg_ceil_log2_64__pgrx_cshim(uint64 num) { return pg_ceil_log2_64(num); }
uint64 pg_popcount__pgrx_cshim(const char *buf, int bytes) { return pg_popcount(buf, bytes); }
uint64 pg_popcount_masked__pgrx_cshim(const char *buf, int bytes, bits8 mask) { return pg_popcount_masked(buf, bytes, mask); }
uint32 pg_rotate_right32__pgrx_cshim(uint32 word, int n) { return pg_rotate_right32(word, n); }
uint32 pg_rotate_left32__pgrx_cshim(uint32 word, int n) { return pg_rotate_left32(word, n); }
void SetQueryCompletion__pgrx_cshim(QueryCompletion *qc, CommandTag commandTag, uint64 nprocessed) { SetQueryCompletion(qc, commandTag, nprocessed); }
void CopyQueryCompletion__pgrx_cshim(QueryCompletion *dst, const QueryCompletion *src) { CopyQueryCompletion(dst, src); }
bool pg_memory_is_all_zeros__pgrx_cshim(const void *ptr, size_t len) { return pg_memory_is_all_zeros(ptr, len); }
size_t TupleHashEntrySize__pgrx_cshim(void) { return TupleHashEntrySize(); }
MinimalTuple TupleHashEntryGetTuple__pgrx_cshim(TupleHashEntry entry) { return TupleHashEntryGetTuple(entry); }
void * TupleHashEntryGetAdditional__pgrx_cshim(TupleHashTable hashtable, TupleHashEntry entry) { return TupleHashEntryGetAdditional(hashtable, entry); }
Datum ExecGetJunkAttribute__pgrx_cshim(TupleTableSlot *slot, AttrNumber attno, bool *isNull) { return ExecGetJunkAttribute(slot, attno, isNull); }
TupleTableSlot * ExecProcNode__pgrx_cshim(PlanState *node) { return ExecProcNode(node); }
Datum ExecEvalExpr__pgrx_cshim(ExprState *state, ExprContext *econtext, bool *isNull) { return ExecEvalExpr(state, econtext, isNull); }
void ExecEvalExprNoReturn__pgrx_cshim(ExprState *state, ExprContext *econtext) { ExecEvalExprNoReturn(state, econtext); }
Datum ExecEvalExprSwitchContext__pgrx_cshim(ExprState *state, ExprContext *econtext, bool *isNull) { return ExecEvalExprSwitchContext(state, econtext, isNull); }
void ExecEvalExprNoReturnSwitchContext__pgrx_cshim(ExprState *state, ExprContext *econtext) { ExecEvalExprNoReturnSwitchContext(state, econtext); }
TupleTableSlot * ExecProject__pgrx_cshim(ProjectionInfo *projInfo) { return ExecProject(projInfo); }
bool ExecQual__pgrx_cshim(ExprState *state, ExprContext *econtext) { return ExecQual(state, econtext); }
bool ExecQualAndReset__pgrx_cshim(ExprState *state, ExprContext *econtext) { return ExecQualAndReset(state, econtext); }
RangeTblEntry * exec_rt_fetch__pgrx_cshim(Index rti, EState *estate) { return exec_rt_fetch(rti, estate); }
Datum HeapTupleGetDatum__pgrx_cshim(const HeapTupleData *tuple) { return HeapTupleGetDatum(tuple); }
Timestamp DatumGetTimestamp__pgrx_cshim(Datum X) { return DatumGetTimestamp(X); }
TimestampTz DatumGetTimestampTz__pgrx_cshim(Datum X) { return DatumGetTimestampTz(X); }
Interval * DatumGetIntervalP__pgrx_cshim(Datum X) { return DatumGetIntervalP(X); }
Datum TimestampGetDatum__pgrx_cshim(Timestamp X) { return TimestampGetDatum(X); }
Datum TimestampTzGetDatum__pgrx_cshim(TimestampTz X) { return TimestampTzGetDatum(X); }
Datum IntervalPGetDatum__pgrx_cshim(const Interval *X) { return IntervalPGetDatum(X); }
uint64 TimestampDifferenceMicroseconds__pgrx_cshim(TimestampTz start_time, TimestampTz stop_time) { return TimestampDifferenceMicroseconds(start_time, stop_time); }
bool is_unixsock_path__pgrx_cshim(const char *path) { return is_unixsock_path(path); }
bool pgstat_is_kind_builtin__pgrx_cshim(uint32 kind) { return pgstat_is_kind_builtin(kind); }
bool pgstat_is_kind_custom__pgrx_cshim(uint32 kind) { return pgstat_is_kind_custom(kind); }
void pgstat_report_wait_start__pgrx_cshim(uint32 wait_event_info) { pgstat_report_wait_start(wait_event_info); }
void pgstat_report_wait_end__pgrx_cshim(void) { pgstat_report_wait_end(); }
bool RmgrIdIsBuiltin__pgrx_cshim(int rmid) { return RmgrIdIsBuiltin(rmid); }
bool RmgrIdIsCustom__pgrx_cshim(int rmid) { return RmgrIdIsCustom(rmid); }
bool XLogReaderHasQueuedRecordOrError__pgrx_cshim(XLogReaderState *state) { return XLogReaderHasQueuedRecordOrError(state); }
void smgrread__pgrx_cshim(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, void *buffer) { smgrread(reln, forknum, blocknum, buffer); }
void smgrwrite__pgrx_cshim(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, const void *buffer, bool skipFsync) { smgrwrite(reln, forknum, blocknum, buffer, skipFsync); }
SMgrRelation RelationGetSmgr__pgrx_cshim(Relation rel) { return RelationGetSmgr(rel); }
void RelationCloseSmgr__pgrx_cshim(Relation relation) { RelationCloseSmgr(relation); }
GinTernaryValue DatumGetGinTernaryValue__pgrx_cshim(Datum X) { return DatumGetGinTernaryValue(X); }
Datum GinTernaryValueGetDatum__pgrx_cshim(GinTernaryValue X) { return GinTernaryValueGetDatum(X); }
void GistPageSetDeleted__pgrx_cshim(Page page, FullTransactionId deletexid) { GistPageSetDeleted(page, deletexid); }
FullTransactionId GistPageGetDeleteXid__pgrx_cshim(Page page) { return GistPageGetDeleteXid(page); }
bool BufferIsValid__pgrx_cshim(Buffer bufnum) { return BufferIsValid(bufnum); }
Size BufferGetPageSize__pgrx_cshim(Buffer buffer) { return BufferGetPageSize(buffer); }
TableScanDesc table_beginscan__pgrx_cshim(Relation rel, Snapshot snapshot, int nkeys, struct ScanKeyData *key) { return table_beginscan(rel, snapshot, nkeys, key); }
TableScanDesc table_beginscan_strat__pgrx_cshim(Relation rel, Snapshot snapshot, int nkeys, struct ScanKeyData *key, bool allow_strat, bool allow_sync) { return table_beginscan_strat(rel, snapshot, nkeys, key, allow_strat, allow_sync); }
TableScanDesc table_beginscan_bm__pgrx_cshim(Relation rel, Snapshot snapshot, int nkeys, struct ScanKeyData *key) { return table_beginscan_bm(rel, snapshot, nkeys, key); }
TableScanDesc table_beginscan_sampling__pgrx_cshim(Relation rel, Snapshot snapshot, int nkeys, struct ScanKeyData *key, bool allow_strat, bool allow_sync, bool allow_pagemode) { return table_beginscan_sampling(rel, snapshot, nkeys, key, allow_strat, allow_sync, allow_pagemode); }
TableScanDesc table_beginscan_tid__pgrx_cshim(Relation rel, Snapshot snapshot) { return table_beginscan_tid(rel, snapshot); }
TableScanDesc table_beginscan_analyze__pgrx_cshim(Relation rel) { return table_beginscan_analyze(rel); }
void table_endscan__pgrx_cshim(TableScanDesc scan) { table_endscan(scan); }
void table_rescan__pgrx_cshim(TableScanDesc scan, struct ScanKeyData *key) { table_rescan(scan, key); }
void table_rescan_set_params__pgrx_cshim(TableScanDesc scan, struct ScanKeyData *key, bool allow_strat, bool allow_sync, bool allow_pagemode) { table_rescan_set_params(scan, key, allow_strat, allow_sync, allow_pagemode); }
bool table_scan_getnextslot__pgrx_cshim(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot) { return table_scan_getnextslot(sscan, direction, slot); }
TableScanDesc table_beginscan_tidrange__pgrx_cshim(Relation rel, Snapshot snapshot, ItemPointer mintid, ItemPointer maxtid) { return table_beginscan_tidrange(rel, snapshot, mintid, maxtid); }
void table_rescan_tidrange__pgrx_cshim(TableScanDesc sscan, ItemPointer mintid, ItemPointer maxtid) { table_rescan_tidrange(sscan, mintid, maxtid); }
bool table_scan_getnextslot_tidrange__pgrx_cshim(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot) { return table_scan_getnextslot_tidrange(sscan, direction, slot); }
void table_parallelscan_reinitialize__pgrx_cshim(Relation rel, ParallelTableScanDesc pscan) { table_parallelscan_reinitialize(rel, pscan); }
IndexFetchTableData * table_index_fetch_begin__pgrx_cshim(Relation rel) { return table_index_fetch_begin(rel); }
void table_index_fetch_reset__pgrx_cshim(struct IndexFetchTableData *scan) { table_index_fetch_reset(scan); }
void table_index_fetch_end__pgrx_cshim(struct IndexFetchTableData *scan) { table_index_fetch_end(scan); }
bool table_index_fetch_tuple__pgrx_cshim(struct IndexFetchTableData *scan, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot, bool *call_again, bool *all_dead) { return table_index_fetch_tuple(scan, tid, snapshot, slot, call_again, all_dead); }
bool table_tuple_fetch_row_version__pgrx_cshim(Relation rel, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot) { return table_tuple_fetch_row_version(rel, tid, snapshot, slot); }
bool table_tuple_tid_valid__pgrx_cshim(TableScanDesc scan, ItemPointer tid) { return table_tuple_tid_valid(scan, tid); }
bool table_tuple_satisfies_snapshot__pgrx_cshim(Relation rel, TupleTableSlot *slot, Snapshot snapshot) { return table_tuple_satisfies_snapshot(rel, slot, snapshot); }
TransactionId table_index_delete_tuples__pgrx_cshim(Relation rel, TM_IndexDeleteOp *delstate) { return table_index_delete_tuples(rel, delstate); }
void table_tuple_insert__pgrx_cshim(Relation rel, TupleTableSlot *slot, CommandId cid, int options, struct BulkInsertStateData *bistate) { table_tuple_insert(rel, slot, cid, options, bistate); }
void table_tuple_insert_speculative__pgrx_cshim(Relation rel, TupleTableSlot *slot, CommandId cid, int options, struct BulkInsertStateData *bistate, uint32 specToken) { table_tuple_insert_speculative(rel, slot, cid, options, bistate, specToken); }
void table_tuple_complete_speculative__pgrx_cshim(Relation rel, TupleTableSlot *slot, uint32 specToken, bool succeeded) { table_tuple_complete_speculative(rel, slot, specToken, succeeded); }
void table_multi_insert__pgrx_cshim(Relation rel, TupleTableSlot **slots, int nslots, CommandId cid, int options, struct BulkInsertStateData *bistate) { table_multi_insert(rel, slots, nslots, cid, options, bistate); }
TM_Result table_tuple_delete__pgrx_cshim(Relation rel, ItemPointer tid, CommandId cid, Snapshot snapshot, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, bool changingPart) { return table_tuple_delete(rel, tid, cid, snapshot, crosscheck, wait, tmfd, changingPart); }
TM_Result table_tuple_update__pgrx_cshim(Relation rel, ItemPointer otid, TupleTableSlot *slot, CommandId cid, Snapshot snapshot, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, LockTupleMode *lockmode, TU_UpdateIndexes *update_indexes) { return table_tuple_update(rel, otid, slot, cid, snapshot, crosscheck, wait, tmfd, lockmode, update_indexes); }
TM_Result table_tuple_lock__pgrx_cshim(Relation rel, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot, CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy, uint8 flags, TM_FailureData *tmfd) { return table_tuple_lock(rel, tid, snapshot, slot, cid, mode, wait_policy, flags, tmfd); }
void table_finish_bulk_insert__pgrx_cshim(Relation rel, int options) { table_finish_bulk_insert(rel, options); }
void table_relation_set_new_filelocator__pgrx_cshim(Relation rel, const RelFileLocator *newrlocator, char persistence, TransactionId *freezeXid, MultiXactId *minmulti) { table_relation_set_new_filelocator(rel, newrlocator, persistence, freezeXid, minmulti); }
void table_relation_nontransactional_truncate__pgrx_cshim(Relation rel) { table_relation_nontransactional_truncate(rel); }
void table_relation_copy_data__pgrx_cshim(Relation rel, const RelFileLocator *newrlocator) { table_relation_copy_data(rel, newrlocator); }
void table_relation_copy_for_cluster__pgrx_cshim(Relation OldTable, Relation NewTable, Relation OldIndex, bool use_sort, TransactionId OldestXmin, TransactionId *xid_cutoff, MultiXactId *multi_cutoff, double *num_tuples, double *tups_vacuumed, double *tups_recently_dead) { table_relation_copy_for_cluster(OldTable, NewTable, OldIndex, use_sort, OldestXmin, xid_cutoff, multi_cutoff, num_tuples, tups_vacuumed, tups_recently_dead); }
void table_relation_vacuum__pgrx_cshim(Relation rel, struct VacuumParams *params, BufferAccessStrategy bstrategy) { table_relation_vacuum(rel, params, bstrategy); }
bool table_scan_analyze_next_block__pgrx_cshim(TableScanDesc scan, ReadStream *stream) { return table_scan_analyze_next_block(scan, stream); }
bool table_scan_analyze_next_tuple__pgrx_cshim(TableScanDesc scan, TransactionId OldestXmin, double *liverows, double *deadrows, TupleTableSlot *slot) { return table_scan_analyze_next_tuple(scan, OldestXmin, liverows, deadrows, slot); }
double table_index_build_scan__pgrx_cshim(Relation table_rel, Relation index_rel, struct IndexInfo *index_info, bool allow_sync, bool progress, IndexBuildCallback callback, void *callback_state, TableScanDesc scan) { return table_index_build_scan(table_rel, index_rel, index_info, allow_sync, progress, callback, callback_state, scan); }
double table_index_build_range_scan__pgrx_cshim(Relation table_rel, Relation index_rel, struct IndexInfo *index_info, bool allow_sync, bool anyvisible, bool progress, BlockNumber start_blockno, BlockNumber numblocks, IndexBuildCallback callback, void *callback_state, TableScanDesc scan) { return table_index_build_range_scan(table_rel, index_rel, index_info, allow_sync, anyvisible, progress, start_blockno, numblocks, callback, callback_state, scan); }
void table_index_validate_scan__pgrx_cshim(Relation table_rel, Relation index_rel, struct IndexInfo *index_info, Snapshot snapshot, struct ValidateIndexState *state) { table_index_validate_scan(table_rel, index_rel, index_info, snapshot, state); }
uint64 table_relation_size__pgrx_cshim(Relation rel, ForkNumber forkNumber) { return table_relation_size(rel, forkNumber); }
bool table_relation_needs_toast_table__pgrx_cshim(Relation rel) { return table_relation_needs_toast_table(rel); }
Oid table_relation_toast_am__pgrx_cshim(Relation rel) { return table_relation_toast_am(rel); }
void table_relation_fetch_toast_slice__pgrx_cshim(Relation toastrel, Oid valueid, int32 attrsize, int32 sliceoffset, int32 slicelength, struct varlena *result) { table_relation_fetch_toast_slice(toastrel, valueid, attrsize, sliceoffset, slicelength, result); }
void table_relation_estimate_size__pgrx_cshim(Relation rel, int32 *attr_widths, BlockNumber *pages, double *tuples, double *allvisfrac) { table_relation_estimate_size(rel, attr_widths, pages, tuples, allvisfrac); }
bool table_scan_bitmap_next_tuple__pgrx_cshim(TableScanDesc scan, TupleTableSlot *slot, bool *recheck, uint64 *lossy_pages, uint64 *exact_pages) { return table_scan_bitmap_next_tuple(scan, slot, recheck, lossy_pages, exact_pages); }
bool table_scan_sample_next_block__pgrx_cshim(TableScanDesc scan, struct SampleScanState *scanstate) { return table_scan_sample_next_block(scan, scanstate); }
bool table_scan_sample_next_tuple__pgrx_cshim(TableScanDesc scan, struct SampleScanState *scanstate, TupleTableSlot *slot) { return table_scan_sample_next_tuple(scan, scanstate, slot); }
void heap_execute_freeze_tuple__pgrx_cshim(HeapTupleHeader tuple, HeapTupleFreeze *frz) { heap_execute_freeze_tuple(tuple, frz); }
void XLogFileName__pgrx_cshim(char *fname, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes) { XLogFileName(fname, tli, logSegNo, wal_segsz_bytes); }
void XLogFileNameById__pgrx_cshim(char *fname, TimeLineID tli, uint32 log, uint32 seg) { XLogFileNameById(fname, tli, log, seg); }
bool IsXLogFileName__pgrx_cshim(const char *fname) { return IsXLogFileName(fname); }
bool IsPartialXLogFileName__pgrx_cshim(const char *fname) { return IsPartialXLogFileName(fname); }
void XLogFromFileName__pgrx_cshim(const char *fname, TimeLineID *tli, XLogSegNo *logSegNo, int wal_segsz_bytes) { XLogFromFileName(fname, tli, logSegNo, wal_segsz_bytes); }
void XLogFilePath__pgrx_cshim(char *path, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes) { XLogFilePath(path, tli, logSegNo, wal_segsz_bytes); }
void TLHistoryFileName__pgrx_cshim(char *fname, TimeLineID tli) { TLHistoryFileName(fname, tli); }
bool IsTLHistoryFileName__pgrx_cshim(const char *fname) { return IsTLHistoryFileName(fname); }
void TLHistoryFilePath__pgrx_cshim(char *path, TimeLineID tli) { TLHistoryFilePath(path, tli); }
void StatusFilePath__pgrx_cshim(char *path, const char *xlog, const char *suffix) { StatusFilePath(path, xlog, suffix); }
void BackupHistoryFileName__pgrx_cshim(char *fname, TimeLineID tli, XLogSegNo logSegNo, XLogRecPtr startpoint, int wal_segsz_bytes) { BackupHistoryFileName(fname, tli, logSegNo, startpoint, wal_segsz_bytes); }
bool IsBackupHistoryFileName__pgrx_cshim(const char *fname) { return IsBackupHistoryFileName(fname); }
void BackupHistoryFilePath__pgrx_cshim(char *path, TimeLineID tli, XLogSegNo logSegNo, XLogRecPtr startpoint, int wal_segsz_bytes) { BackupHistoryFilePath(path, tli, logSegNo, startpoint, wal_segsz_bytes); }
bool RmgrIdExists__pgrx_cshim(RmgrId rmid) { return RmgrIdExists(rmid); }
RmgrData GetRmgr__pgrx_cshim(RmgrId rmid) { return GetRmgr(rmid); }
int64 itemptr_encode__pgrx_cshim(ItemPointer itemptr) { return itemptr_encode(itemptr); }
void itemptr_decode__pgrx_cshim(ItemPointer itemptr, int64 encoded) { itemptr_decode(itemptr, encoded); }
const char * collprovider_name__pgrx_cshim(char c) { return collprovider_name(c); }
Datum EOHPGetRWDatum__pgrx_cshim(const struct ExpandedObjectHeader *eohptr) { return EOHPGetRWDatum(eohptr); }
Datum EOHPGetRODatum__pgrx_cshim(const struct ExpandedObjectHeader *eohptr) { return EOHPGetRODatum(eohptr); }
bool is_valid_unicode_codepoint__pgrx_cshim(pg_wchar c) { return is_valid_unicode_codepoint(c); }
bool is_utf16_surrogate_first__pgrx_cshim(pg_wchar c) { return is_utf16_surrogate_first(c); }
bool is_utf16_surrogate_second__pgrx_cshim(pg_wchar c) { return is_utf16_surrogate_second(c); }
pg_wchar surrogate_pair_to_codepoint__pgrx_cshim(pg_wchar first, pg_wchar second) { return surrogate_pair_to_codepoint(first, second); }
pg_wchar utf8_to_unicode__pgrx_cshim(const unsigned char *c) { return utf8_to_unicode(c); }
unsigned char * unicode_to_utf8__pgrx_cshim(pg_wchar c, unsigned char *utf8string) { return unicode_to_utf8(c, utf8string); }
int unicode_utf8len__pgrx_cshim(pg_wchar c) { return unicode_utf8len(c); }
void pq_writeint8__pgrx_cshim(StringInfoData *buf, uint8 i) { pq_writeint8(buf, i); }
void pq_writeint16__pgrx_cshim(StringInfoData *buf, uint16 i) { pq_writeint16(buf, i); }
void pq_writeint32__pgrx_cshim(StringInfoData *buf, uint32 i) { pq_writeint32(buf, i); }
void pq_writeint64__pgrx_cshim(StringInfoData *buf, uint64 i) { pq_writeint64(buf, i); }
void pq_writestring__pgrx_cshim(StringInfoData *buf, const char *str) { pq_writestring(buf, str); }
void pq_sendint8__pgrx_cshim(StringInfo buf, uint8 i) { pq_sendint8(buf, i); }
void pq_sendint16__pgrx_cshim(StringInfo buf, uint16 i) { pq_sendint16(buf, i); }
void pq_sendint32__pgrx_cshim(StringInfo buf, uint32 i) { pq_sendint32(buf, i); }
void pq_sendint64__pgrx_cshim(StringInfo buf, uint64 i) { pq_sendint64(buf, i); }
void pq_sendbyte__pgrx_cshim(StringInfo buf, uint8 byt) { pq_sendbyte(buf, byt); }
void pq_sendint__pgrx_cshim(StringInfo buf, uint32 i, int b) { pq_sendint(buf, i, b); }
bool is_funcclause__pgrx_cshim(const void *clause) { return is_funcclause(clause); }
bool is_opclause__pgrx_cshim(const void *clause) { return is_opclause(clause); }
Node * get_leftop__pgrx_cshim(const void *clause) { return get_leftop(clause); }
Node * get_rightop__pgrx_cshim(const void *clause) { return get_rightop(clause); }
bool is_andclause__pgrx_cshim(const void *clause) { return is_andclause(clause); }
bool is_orclause__pgrx_cshim(const void *clause) { return is_orclause(clause); }
bool is_notclause__pgrx_cshim(const void *clause) { return is_notclause(clause); }
Expr * get_notclausearg__pgrx_cshim(const void *notclause) { return get_notclausearg(notclause); }
bool clause_sides_match_join__pgrx_cshim(RestrictInfo *rinfo, Relids outerrelids, Relids innerrelids) { return clause_sides_match_join(rinfo, outerrelids, innerrelids); }
const char * GetScanKeyword__pgrx_cshim(int n, const ScanKeywordList *keywords) { return GetScanKeyword(n, keywords); }
Datum ExpandedRecordGetDatum__pgrx_cshim(const ExpandedRecordHeader *erh) { return ExpandedRecordGetDatum(erh); }
Datum ExpandedRecordGetRODatum__pgrx_cshim(const ExpandedRecordHeader *erh) { return ExpandedRecordGetRODatum(erh); }
TupleDesc expanded_record_get_tupdesc__pgrx_cshim(ExpandedRecordHeader *erh) { return expanded_record_get_tupdesc(erh); }
Datum expanded_record_get_field__pgrx_cshim(ExpandedRecordHeader *erh, int fnumber, bool *isnull) { return expanded_record_get_field(erh, fnumber, isnull); }
void WalSndWakeupProcessRequests__pgrx_cshim(bool physical, bool logical) { WalSndWakeupProcessRequests(physical, logical); }
void walrcv_clear_result__pgrx_cshim(WalRcvExecResult *walres) { walrcv_clear_result(walres); }
void ReplicationSlotSetInactiveSince__pgrx_cshim(ReplicationSlot *s, TimestampTz ts, bool acquire_lock) { ReplicationSlotSetInactiveSince(s, ts, acquire_lock); }
RelFileNumber BufTagGetRelNumber__pgrx_cshim(const BufferTag *tag) { return BufTagGetRelNumber(tag); }
ForkNumber BufTagGetForkNum__pgrx_cshim(const BufferTag *tag) { return BufTagGetForkNum(tag); }
void BufTagSetRelForkDetails__pgrx_cshim(BufferTag *tag, RelFileNumber relnumber, ForkNumber forknum) { BufTagSetRelForkDetails(tag, relnumber, forknum); }
RelFileLocator BufTagGetRelFileLocator__pgrx_cshim(const BufferTag *tag) { return BufTagGetRelFileLocator(tag); }
void ClearBufferTag__pgrx_cshim(BufferTag *tag) { ClearBufferTag(tag); }
void InitBufferTag__pgrx_cshim(BufferTag *tag, const RelFileLocator *rlocator, ForkNumber forkNum, BlockNumber blockNum) { InitBufferTag(tag, rlocator, forkNum, blockNum); }
bool BufferTagsEqual__pgrx_cshim(const BufferTag *tag1, const BufferTag *tag2) { return BufferTagsEqual(tag1, tag2); }
bool BufTagMatchesRelFileLocator__pgrx_cshim(const BufferTag *tag, const RelFileLocator *rlocator) { return BufTagMatchesRelFileLocator(tag, rlocator); }
uint32 BufTableHashPartition__pgrx_cshim(uint32 hashcode) { return BufTableHashPartition(hashcode); }
LWLock * BufMappingPartitionLock__pgrx_cshim(uint32 hashcode) { return BufMappingPartitionLock(hashcode); }
LWLock * BufMappingPartitionLockByIndex__pgrx_cshim(uint32 index) { return BufMappingPartitionLockByIndex(index); }
BufferDesc * GetBufferDescriptor__pgrx_cshim(uint32 id) { return GetBufferDescriptor(id); }
BufferDesc * GetLocalBufferDescriptor__pgrx_cshim(uint32 id) { return GetLocalBufferDescriptor(id); }
Buffer BufferDescriptorGetBuffer__pgrx_cshim(const BufferDesc *bdesc) { return BufferDescriptorGetBuffer(bdesc); }
ConditionVariable * BufferDescriptorGetIOCV__pgrx_cshim(const BufferDesc *bdesc) { return BufferDescriptorGetIOCV(bdesc); }
LWLock * BufferDescriptorGetContentLock__pgrx_cshim(const BufferDesc *bdesc) { return BufferDescriptorGetContentLock(bdesc); }
void UnlockBufHdr__pgrx_cshim(BufferDesc *desc, uint32 buf_state) { UnlockBufHdr(desc, buf_state); }
void ResourceOwnerRememberBuffer__pgrx_cshim(ResourceOwner owner, Buffer buffer) { ResourceOwnerRememberBuffer(owner, buffer); }
void ResourceOwnerForgetBuffer__pgrx_cshim(ResourceOwner owner, Buffer buffer) { ResourceOwnerForgetBuffer(owner, buffer); }
void ResourceOwnerRememberBufferIO__pgrx_cshim(ResourceOwner owner, Buffer buffer) { ResourceOwnerRememberBufferIO(owner, buffer); }
void ResourceOwnerForgetBufferIO__pgrx_cshim(ResourceOwner owner, Buffer buffer) { ResourceOwnerForgetBufferIO(owner, buffer); }
const char * CreateCommandName__pgrx_cshim(Node *parsetree) { return CreateCommandName(parsetree); }
TSVector DatumGetTSVector__pgrx_cshim(Datum X) { return DatumGetTSVector(X); }
TSVector DatumGetTSVectorCopy__pgrx_cshim(Datum X) { return DatumGetTSVectorCopy(X); }
Datum TSVectorGetDatum__pgrx_cshim(const TSVectorData *X) { return TSVectorGetDatum(X); }
TSQuery DatumGetTSQuery__pgrx_cshim(Datum X) { return DatumGetTSQuery(X); }
TSQuery DatumGetTSQueryCopy__pgrx_cshim(Datum X) { return DatumGetTSQueryCopy(X); }
Datum TSQueryGetDatum__pgrx_cshim(const TSQueryData *X) { return TSQueryGetDatum(X); }
Datum TSQuerySignGetDatum__pgrx_cshim(TSQuerySign X) { return TSQuerySignGetDatum(X); }
TSQuerySign DatumGetTSQuerySign__pgrx_cshim(Datum X) { return DatumGetTSQuerySign(X); }
DateADT DatumGetDateADT__pgrx_cshim(Datum X) { return DatumGetDateADT(X); }
TimeADT DatumGetTimeADT__pgrx_cshim(Datum X) { return DatumGetTimeADT(X); }
TimeTzADT * DatumGetTimeTzADTP__pgrx_cshim(Datum X) { return DatumGetTimeTzADTP(X); }
Datum DateADTGetDatum__pgrx_cshim(DateADT X) { return DateADTGetDatum(X); }
Datum TimeADTGetDatum__pgrx_cshim(TimeADT X) { return TimeADTGetDatum(X); }
Datum TimeTzADTPGetDatum__pgrx_cshim(const TimeTzADT *X) { return TimeTzADTPGetDatum(X); }
float4 get_float4_infinity__pgrx_cshim(void) { return get_float4_infinity(); }
float8 get_float8_infinity__pgrx_cshim(void) { return get_float8_infinity(); }
float4 get_float4_nan__pgrx_cshim(void) { return get_float4_nan(); }
float8 get_float8_nan__pgrx_cshim(void) { return get_float8_nan(); }
float4 float4_pl__pgrx_cshim(const float4 val1, const float4 val2) { return float4_pl(val1, val2); }
float8 float8_pl__pgrx_cshim(const float8 val1, const float8 val2) { return float8_pl(val1, val2); }
float4 float4_mi__pgrx_cshim(const float4 val1, const float4 val2) { return float4_mi(val1, val2); }
float8 float8_mi__pgrx_cshim(const float8 val1, const float8 val2) { return float8_mi(val1, val2); }
float4 float4_mul__pgrx_cshim(const float4 val1, const float4 val2) { return float4_mul(val1, val2); }
float8 float8_mul__pgrx_cshim(const float8 val1, const float8 val2) { return float8_mul(val1, val2); }
float4 float4_div__pgrx_cshim(const float4 val1, const float4 val2) { return float4_div(val1, val2); }
float8 float8_div__pgrx_cshim(const float8 val1, const float8 val2) { return float8_div(val1, val2); }
bool float4_eq__pgrx_cshim(const float4 val1, const float4 val2) { return float4_eq(val1, val2); }
bool float8_eq__pgrx_cshim(const float8 val1, const float8 val2) { return float8_eq(val1, val2); }
bool float4_ne__pgrx_cshim(const float4 val1, const float4 val2) { return float4_ne(val1, val2); }
bool float8_ne__pgrx_cshim(const float8 val1, const float8 val2) { return float8_ne(val1, val2); }
bool float4_lt__pgrx_cshim(const float4 val1, const float4 val2) { return float4_lt(val1, val2); }
bool float8_lt__pgrx_cshim(const float8 val1, const float8 val2) { return float8_lt(val1, val2); }
bool float4_le__pgrx_cshim(const float4 val1, const float4 val2) { return float4_le(val1, val2); }
bool float8_le__pgrx_cshim(const float8 val1, const float8 val2) { return float8_le(val1, val2); }
bool float4_gt__pgrx_cshim(const float4 val1, const float4 val2) { return float4_gt(val1, val2); }
bool float8_gt__pgrx_cshim(const float8 val1, const float8 val2) { return float8_gt(val1, val2); }
bool float4_ge__pgrx_cshim(const float4 val1, const float4 val2) { return float4_ge(val1, val2); }
bool float8_ge__pgrx_cshim(const float8 val1, const float8 val2) { return float8_ge(val1, val2); }
float4 float4_min__pgrx_cshim(const float4 val1, const float4 val2) { return float4_min(val1, val2); }
float8 float8_min__pgrx_cshim(const float8 val1, const float8 val2) { return float8_min(val1, val2); }
float4 float4_max__pgrx_cshim(const float4 val1, const float4 val2) { return float4_max(val1, val2); }
float8 float8_max__pgrx_cshim(const float8 val1, const float8 val2) { return float8_max(val1, val2); }
bool FPeq__pgrx_cshim(double A, double B) { return FPeq(A, B); }
bool FPne__pgrx_cshim(double A, double B) { return FPne(A, B); }
bool FPlt__pgrx_cshim(double A, double B) { return FPlt(A, B); }
bool FPle__pgrx_cshim(double A, double B) { return FPle(A, B); }
bool FPgt__pgrx_cshim(double A, double B) { return FPgt(A, B); }
bool FPge__pgrx_cshim(double A, double B) { return FPge(A, B); }
Point * DatumGetPointP__pgrx_cshim(Datum X) { return DatumGetPointP(X); }
Datum PointPGetDatum__pgrx_cshim(const Point *X) { return PointPGetDatum(X); }
LSEG * DatumGetLsegP__pgrx_cshim(Datum X) { return DatumGetLsegP(X); }
Datum LsegPGetDatum__pgrx_cshim(const LSEG *X) { return LsegPGetDatum(X); }
PATH * DatumGetPathP__pgrx_cshim(Datum X) { return DatumGetPathP(X); }
PATH * DatumGetPathPCopy__pgrx_cshim(Datum X) { return DatumGetPathPCopy(X); }
Datum PathPGetDatum__pgrx_cshim(const PATH *X) { return PathPGetDatum(X); }
LINE * DatumGetLineP__pgrx_cshim(Datum X) { return DatumGetLineP(X); }
Datum LinePGetDatum__pgrx_cshim(const LINE *X) { return LinePGetDatum(X); }
BOX * DatumGetBoxP__pgrx_cshim(Datum X) { return DatumGetBoxP(X); }
Datum BoxPGetDatum__pgrx_cshim(const BOX *X) { return BoxPGetDatum(X); }
POLYGON * DatumGetPolygonP__pgrx_cshim(Datum X) { return DatumGetPolygonP(X); }
POLYGON * DatumGetPolygonPCopy__pgrx_cshim(Datum X) { return DatumGetPolygonPCopy(X); }
Datum PolygonPGetDatum__pgrx_cshim(const POLYGON *X) { return PolygonPGetDatum(X); }
CIRCLE * DatumGetCircleP__pgrx_cshim(Datum X) { return DatumGetCircleP(X); }
Datum CirclePGetDatum__pgrx_cshim(const CIRCLE *X) { return CirclePGetDatum(X); }
Numeric DatumGetNumeric__pgrx_cshim(Datum X) { return DatumGetNumeric(X); }
Numeric DatumGetNumericCopy__pgrx_cshim(Datum X) { return DatumGetNumericCopy(X); }
Datum NumericGetDatum__pgrx_cshim(Numeric X) { return NumericGetDatum(X); }
Jsonb * DatumGetJsonbP__pgrx_cshim(Datum d) { return DatumGetJsonbP(d); }
Jsonb * DatumGetJsonbPCopy__pgrx_cshim(Datum d) { return DatumGetJsonbPCopy(d); }
Datum JsonbPGetDatum__pgrx_cshim(const Jsonb *p) { return JsonbPGetDatum(p); }
void set_ps_display__pgrx_cshim(const char *activity) { set_ps_display(activity); }
RangeType * DatumGetRangeTypeP__pgrx_cshim(Datum X) { return DatumGetRangeTypeP(X); }
RangeType * DatumGetRangeTypePCopy__pgrx_cshim(Datum X) { return DatumGetRangeTypePCopy(X); }
Datum RangeTypePGetDatum__pgrx_cshim(const RangeType *X) { return RangeTypePGetDatum(X); }
