static void PersistentStore_DoInsertTuple(
PersistentStoreData *storeData,
PersistentStoreSharedData *storeSharedData,
Relation persistentRel,
/* The persistent table relation. */
Datum *values,
bool flushToXLog,
/* When true, the XLOG record for this change will be flushed to disk. */
ItemPointer persistentTid)
/* TID of the stored tuple. */
{
bool *nulls;
HeapTuple persistentTuple = NULL;
XLogRecPtr xlogInsertEndLoc;
/*
* In order to keep the tuples the exact same size to enable direct reuse of
* free tuples, we do not use NULLs.
*/
nulls = (bool*)palloc0(storeData->numAttributes * sizeof(bool));
/*
* Form the tuple.
*/
persistentTuple = heap_form_tuple(persistentRel->rd_att, values, nulls);
if (!HeapTupleIsValid(persistentTuple))
elog(ERROR, "Failed to build persistent tuple ('%s')",
storeData->tableName);
frozen_heap_insert(
persistentRel,
persistentTuple);
if (Debug_persistent_store_print)
elog(PersistentStore_DebugPrintLevel(),
"PersistentStore_DoInsertTuple: new insert TID %s ('%s')",
ItemPointerToString2(&persistentTuple->t_self),
storeData->tableName);
/*
* Return the TID of the INSERT tuple.
* Return the XLOG location of the INSERT tuple's XLOG record.
*/
*persistentTid = persistentTuple->t_self;
xlogInsertEndLoc = XLogLastInsertEndLoc();
heap_freetuple(persistentTuple);
if (flushToXLog)
{
XLogFlush(xlogInsertEndLoc);
XLogRecPtr_Zero(&nowaitXLogEndLoc);
}
else
nowaitXLogEndLoc = xlogInsertEndLoc;
pfree(nulls);
}
void PersistentStore_FreeTuple(
PersistentStoreData *storeData,
PersistentStoreSharedData *storeSharedData,
ItemPointer persistentTid,
/* TID of the stored tuple. */
Datum *freeValues,
bool flushToXLog)
/* When true, the XLOG record for this change will be flushed to disk. */
{
Relation persistentRel;
XLogRecPtr xlogEndLoc;
/* The end location of the UPDATE XLOG record. */
Assert( LWLockHeldByMe(PersistentObjLock) );
#ifdef USE_ASSERT_CHECKING
if (storeSharedData == NULL ||
!PersistentStoreSharedData_EyecatcherIsValid(storeSharedData))
elog(ERROR, "Persistent store shared-memory not valid");
#endif
if (Debug_persistent_store_print)
elog(PersistentStore_DebugPrintLevel(),
"PersistentStore_FreeTuple: Going to free tuple at TID %s ('%s', shared data %p)",
ItemPointerToString(persistentTid),
storeData->tableName,
storeSharedData);
Assert(ItemPointerIsValid(persistentTid));
persistentRel = (*storeData->openRel)();
simple_heap_delete_xid(persistentRel, persistentTid, FrozenTransactionId);
/*
* XLOG location of the UPDATE tuple's XLOG record.
*/
xlogEndLoc = XLogLastInsertEndLoc();
(*storeData->closeRel)(persistentRel);
storeSharedData->inUseCount--;
if (flushToXLog)
{
XLogFlush(xlogEndLoc);
XLogRecPtr_Zero(&nowaitXLogEndLoc);
}
else
nowaitXLogEndLoc = xlogEndLoc;
}
void PersistentStore_ReplaceTuple(
PersistentStoreData *storeData,
PersistentStoreSharedData *storeSharedData,
ItemPointer persistentTid,
/* TID of the stored tuple. */
HeapTuple tuple,
Datum *newValues,
bool *replaces,
bool flushToXLog)
/* When true, the XLOG record for this change will be flushed to disk. */
{
Relation persistentRel;
bool *nulls;
HeapTuple replacementTuple = NULL;
XLogRecPtr xlogUpdateEndLoc;
#ifdef USE_ASSERT_CHECKING
if (storeSharedData == NULL ||
!PersistentStoreSharedData_EyecatcherIsValid(storeSharedData))
elog(ERROR, "Persistent store shared-memory not valid");
#endif
if (Debug_persistent_store_print)
elog(PersistentStore_DebugPrintLevel(),
"PersistentStore_ReplaceTuple: Going to replace set of columns in tuple at TID %s ('%s', shared data %p)",
ItemPointerToString(persistentTid),
storeData->tableName,
storeSharedData);
persistentRel = (*storeData->openRel)();
/*
* In order to keep the tuples the exact same size to enable direct reuse of
* free tuples, we do not use NULLs.
*/
nulls = (bool*)palloc0(storeData->numAttributes * sizeof(bool));
/*
* Modify the tuple.
*/
replacementTuple = heap_modify_tuple(tuple, persistentRel->rd_att,
newValues, nulls, replaces);
replacementTuple->t_self = *persistentTid;
frozen_heap_inplace_update(persistentRel, replacementTuple);
/*
* Return the XLOG location of the UPDATE tuple's XLOG record.
*/
xlogUpdateEndLoc = XLogLastInsertEndLoc();
heap_freetuple(replacementTuple);
pfree(nulls);
if (Debug_persistent_store_print)
{
Datum *readValues;
bool *readNulls;
HeapTupleData readTuple;
Buffer buffer;
HeapTuple readTupleCopy;
elog(PersistentStore_DebugPrintLevel(),
"PersistentStore_ReplaceTuple: Replaced set of columns in tuple at TID %s ('%s')",
ItemPointerToString(persistentTid),
storeData->tableName);
readValues = (Datum*)palloc(storeData->numAttributes * sizeof(Datum));
readNulls = (bool*)palloc(storeData->numAttributes * sizeof(bool));
readTuple.t_self = *persistentTid;
if (!heap_fetch(persistentRel, SnapshotAny,
&readTuple, &buffer, false, NULL))
{
elog(ERROR, "Failed to fetch persistent tuple at %s ('%s')",
ItemPointerToString(&readTuple.t_self),
storeData->tableName);
}
readTupleCopy = heaptuple_copy_to(&readTuple, NULL, NULL);
ReleaseBuffer(buffer);
heap_deform_tuple(readTupleCopy, persistentRel->rd_att, readValues, readNulls);
(*storeData->printTupleCallback)(
PersistentStore_DebugPrintLevel(),
"STORE REPLACED TUPLE",
persistentTid,
readValues);
heap_freetuple(readTupleCopy);
pfree(readValues);
pfree(readNulls);
}
(*storeData->closeRel)(persistentRel);
if (flushToXLog)
{
XLogFlush(xlogUpdateEndLoc);
XLogRecPtr_Zero(&nowaitXLogEndLoc);
}
else
nowaitXLogEndLoc = xlogUpdateEndLoc;
}
void PersistentStore_UpdateTuple(
PersistentStoreData *storeData,
PersistentStoreSharedData *storeSharedData,
ItemPointer persistentTid,
/* TID of the stored tuple. */
Datum *values,
bool flushToXLog)
/* When true, the XLOG record for this change will be flushed to disk. */
{
Relation persistentRel;
bool *nulls;
HeapTuple persistentTuple = NULL;
XLogRecPtr xlogUpdateEndLoc;
#ifdef USE_ASSERT_CHECKING
if (storeSharedData == NULL ||
!PersistentStoreSharedData_EyecatcherIsValid(storeSharedData))
elog(ERROR, "Persistent store shared-memory not valid");
#endif
if (Debug_persistent_store_print)
elog(PersistentStore_DebugPrintLevel(),
"PersistentStore_ReplaceTuple: Going to update whole tuple at TID %s ('%s', shared data %p)",
ItemPointerToString(persistentTid),
storeData->tableName,
storeSharedData);
persistentRel = (*storeData->openRel)();
/*
* In order to keep the tuples the exact same size to enable direct reuse of
* free tuples, we do not use NULLs.
*/
nulls = (bool*)palloc0(storeData->numAttributes * sizeof(bool));
/*
* Form the tuple.
*/
persistentTuple = heap_form_tuple(persistentRel->rd_att, values, nulls);
if (!HeapTupleIsValid(persistentTuple))
elog(ERROR, "Failed to build persistent tuple ('%s')",
storeData->tableName);
persistentTuple->t_self = *persistentTid;
frozen_heap_inplace_update(persistentRel, persistentTuple);
/*
* Return the XLOG location of the UPDATE tuple's XLOG record.
*/
xlogUpdateEndLoc = XLogLastInsertEndLoc();
heap_freetuple(persistentTuple);
#ifdef FAULT_INJECTOR
if (FaultInjector_InjectFaultIfSet(SyncPersistentTable,
DDLNotSpecified,
"" /* databaseName */,
"" /* tableName */)== FaultInjectorTypeSkip)
{
FlushRelationBuffers(persistentRel);
smgrimmedsync(persistentRel->rd_smgr);
}
#endif
(*storeData->closeRel)(persistentRel);
if (Debug_persistent_store_print)
{
elog(PersistentStore_DebugPrintLevel(),
"PersistentStore_UpdateTuple: Updated whole tuple at TID %s ('%s')",
ItemPointerToString(persistentTid),
storeData->tableName);
(*storeData->printTupleCallback)(
PersistentStore_DebugPrintLevel(),
"STORE UPDATED TUPLE",
persistentTid,
values);
}
if (flushToXLog)
{
XLogFlush(xlogUpdateEndLoc);
XLogRecPtr_Zero(&nowaitXLogEndLoc);
}
else
nowaitXLogEndLoc = xlogUpdateEndLoc;
}
static void PersistentStore_DoInsertTuple(
PersistentStoreData *storeData,
PersistentStoreSharedData *storeSharedData,
Relation persistentRel,
/* The persistent table relation. */
Datum *values,
bool flushToXLog,
/* When true, the XLOG record for this change will be flushed to disk. */
ItemPointer persistentTid)
/* TID of the stored tuple. */
{
bool *nulls;
HeapTuple persistentTuple = NULL;
XLogRecPtr xlogInsertEndLoc;
/*
* In order to keep the tuples the exact same size to enable direct reuse of
* free tuples, we do not use NULLs.
*/
nulls = (bool*)palloc0(storeData->numAttributes * sizeof(bool));
/*
* Form the tuple.
*/
persistentTuple = heap_form_tuple(persistentRel->rd_att, values, nulls);
if (!HeapTupleIsValid(persistentTuple))
elog(ERROR, "Failed to build persistent tuple ('%s')",
storeData->tableName);
/*
* (We have an exclusive lock (higher up) here so we can direct the insert to the last page.)
*/
{
// Do not assert valid ItemPointer -- it is ok if it is (0,0)...
BlockNumber blockNumber =
BlockIdGetBlockNumber(
&storeSharedData->maxTid.ip_blkid);
frozen_heap_insert_directed(
persistentRel,
persistentTuple,
blockNumber);
}
if (Debug_persistent_store_print)
elog(PersistentStore_DebugPrintLevel(),
"PersistentStore_DoInsertTuple: old maximum known TID %s, new insert TID %s ('%s')",
ItemPointerToString(&storeSharedData->maxTid),
ItemPointerToString2(&persistentTuple->t_self),
storeData->tableName);
if (ItemPointerCompare(
&storeSharedData->maxTid,
&persistentTuple->t_self) == -1)
{
// Current max is Less-Than.
storeSharedData->maxTid = persistentTuple->t_self;
}
/*
* Return the TID of the INSERT tuple.
* Return the XLOG location of the INSERT tuple's XLOG record.
*/
*persistentTid = persistentTuple->t_self;
xlogInsertEndLoc = XLogLastInsertEndLoc();
heap_freetuple(persistentTuple);
if (flushToXLog)
{
XLogFlush(xlogInsertEndLoc);
XLogRecPtr_Zero(&nowaitXLogEndLoc);
}
else
nowaitXLogEndLoc = xlogInsertEndLoc;
pfree(nulls);
}
void PersistentStore_FreeTuple(
PersistentStoreData *storeData,
PersistentStoreSharedData *storeSharedData,
ItemPointer persistentTid,
/* TID of the stored tuple. */
Datum *freeValues,
bool flushToXLog)
/* When true, the XLOG record for this change will be flushed to disk. */
{
Relation persistentRel;
HeapTuple persistentTuple = NULL;
ItemPointerData prevFreeTid;
XLogRecPtr xlogEndLoc;
/* The end location of the UPDATE XLOG record. */
#ifdef USE_ASSERT_CHECKING
if (storeSharedData == NULL ||
!PersistentStoreSharedData_EyecatcherIsValid(storeSharedData))
elog(ERROR, "Persistent store shared-memory not valid");
#endif
if (Debug_persistent_store_print)
elog(PersistentStore_DebugPrintLevel(),
"PersistentStore_FreeTuple: Going to free tuple at TID %s ('%s', shared data %p)",
ItemPointerToString(persistentTid),
storeData->tableName,
storeSharedData);
Assert(persistentTid->ip_posid != 0);
persistentRel = (*storeData->openRel)();
storeSharedData->maxFreeOrderNum++;
if (storeSharedData->maxFreeOrderNum == 1)
prevFreeTid = *persistentTid; // So non-zero PreviousFreeTid indicates free.
else
prevFreeTid = storeSharedData->freeTid;
storeSharedData->freeTid = *persistentTid;
PersistentStore_FormTupleSetOurs(
storeData,
persistentRel->rd_att,
freeValues,
storeSharedData->maxFreeOrderNum,
&prevFreeTid,
&persistentTuple);
persistentTuple->t_self = *persistentTid;
frozen_heap_inplace_update(persistentRel, persistentTuple);
/*
* XLOG location of the UPDATE tuple's XLOG record.
*/
xlogEndLoc = XLogLastInsertEndLoc();
heap_freetuple(persistentTuple);
(*storeData->closeRel)(persistentRel);
storeSharedData->inUseCount--;
if (Debug_persistent_store_print)
elog(PersistentStore_DebugPrintLevel(),
"PersistentStore_FreeTuple: Freed tuple at TID %s. Maximum free order number " INT64_FORMAT ", in use count " INT64_FORMAT " ('%s')",
ItemPointerToString(&storeSharedData->freeTid),
storeSharedData->maxFreeOrderNum,
storeSharedData->inUseCount,
storeData->tableName);
if (flushToXLog)
{
XLogFlush(xlogEndLoc);
XLogRecPtr_Zero(&nowaitXLogEndLoc);
}
else
nowaitXLogEndLoc = xlogEndLoc;
}
