v32-0011-tidstore-vacuum-Use-camel-case-for-TidStore-APIs.patch
application/octet-stream
Filename: v32-0011-tidstore-vacuum-Use-camel-case-for-TidStore-APIs.patch
Type: application/octet-stream
Part: 6
Patch
Format: format-patch
Series: patch v32-0011
Subject: tidstore, vacuum: Use camel case for TidStore APIs
| File | + | − |
|---|---|---|
| src/backend/access/common/tidstore.c | 33 | 31 |
| src/backend/access/heap/vacuumlazy.c | 22 | 22 |
| src/backend/commands/vacuum.c | 2 | 2 |
| src/backend/commands/vacuumparallel.c | 6 | 6 |
| src/include/access/tidstore.h | 17 | 17 |
| src/test/modules/test_tidstore/test_tidstore.c | 34 | 33 |
From 6f4ff3584cbbf4db3ed7268ebc360df0ad328696 Mon Sep 17 00:00:00 2001
From: Masahiko Sawada <sawada.mshk@gmail.com>
Date: Mon, 17 Apr 2023 17:47:10 +0900
Subject: [PATCH v32 11/18] tidstore, vacuum: Use camel case for TidStore APIs
---
src/backend/access/common/tidstore.c | 64 +++++++++---------
src/backend/access/heap/vacuumlazy.c | 44 ++++++------
src/backend/commands/vacuum.c | 4 +-
src/backend/commands/vacuumparallel.c | 12 ++--
src/include/access/tidstore.h | 34 +++++-----
.../modules/test_tidstore/test_tidstore.c | 67 ++++++++++---------
6 files changed, 114 insertions(+), 111 deletions(-)
diff --git a/src/backend/access/common/tidstore.c b/src/backend/access/common/tidstore.c
index 8c05e60d92..283a326d13 100644
--- a/src/backend/access/common/tidstore.c
+++ b/src/backend/access/common/tidstore.c
@@ -7,9 +7,9 @@
* Internally, a tid is encoded as a pair of 64-bit key and 64-bit value, and
* stored in the radix tree.
*
- * A TidStore can be shared among parallel worker processes by passing DSA area
- * to tidstore_create(). Other backends can attach to the shared TidStore by
- * tidstore_attach().
+ * TidStore can be shared among parallel worker processes by passing DSA area
+ * to TidStoreCreate(). Other backends can attach to the shared TidStore by
+ * TidStoreAttach().
*
* Regarding the concurrency, it basically relies on the concurrency support in
* the radix tree, but we acquires the lock on a TidStore in some cases, for
@@ -106,7 +106,7 @@ typedef struct TidStoreControl
LWLock lock;
/* handles for TidStore and radix tree */
- tidstore_handle handle;
+ TidStoreHandle handle;
shared_rt_handle tree_handle;
} TidStoreControl;
@@ -164,7 +164,7 @@ static inline uint64 tid_to_key_off(TidStore *ts, ItemPointer tid, uint64 *off_b
* The radix tree for storage is allocated in DSA area is 'area' is non-NULL.
*/
TidStore *
-tidstore_create(size_t max_bytes, int max_offset, dsa_area *area)
+TidStoreCreate(size_t max_bytes, int max_off, dsa_area *area)
{
TidStore *ts;
@@ -176,12 +176,12 @@ tidstore_create(size_t max_bytes, int max_offset, dsa_area *area)
* Memory consumption depends on the number of stored tids, but also on the
* distribution of them, how the radix tree stores, and the memory management
* that backed the radix tree. The maximum bytes that a TidStore can
- * use is specified by the max_bytes in tidstore_create(). We want the total
+ * use is specified by the max_bytes in TidStoreCreate(). We want the total
* amount of memory consumption by a TidStore not to exceed the max_bytes.
*
* In local TidStore cases, the radix tree uses slab allocators for each kind
* of node class. The most memory consuming case while adding Tids associated
- * with one page (i.e. during tidstore_add_tids()) is that we allocate a new
+ * with one page (i.e. during TidStoreSetBlockOffsets()) is that we allocate a new
* slab block for a new radix tree node, which is approximately 70kB. Therefore,
* we deduct 70kB from the max_bytes.
*
@@ -235,7 +235,7 @@ tidstore_create(size_t max_bytes, int max_offset, dsa_area *area)
* allocated in backend-local memory using the CurrentMemoryContext.
*/
TidStore *
-tidstore_attach(dsa_area *area, tidstore_handle handle)
+TidStoreAttach(dsa_area *area, TidStoreHandle handle)
{
TidStore *ts;
dsa_pointer control;
@@ -266,7 +266,7 @@ tidstore_attach(dsa_area *area, tidstore_handle handle)
* to the operating system.
*/
void
-tidstore_detach(TidStore *ts)
+TidStoreDetach(TidStore *ts)
{
Assert(TidStoreIsShared(ts) && ts->control->magic == TIDSTORE_MAGIC);
@@ -279,12 +279,12 @@ tidstore_detach(TidStore *ts)
*
* TODO: The caller must be certain that no other backend will attempt to
* access the TidStore before calling this function. Other backend must
- * explicitly call tidstore_detach to free up backend-local memory associated
- * with the TidStore. The backend that calls tidstore_destroy must not call
- * tidstore_detach.
+ * explicitly call TidStoreDetach() to free up backend-local memory associated
+ * with the TidStore. The backend that calls TidStoreDestroy() must not call
+ * TidStoreDetach().
*/
void
-tidstore_destroy(TidStore *ts)
+TidStoreDestroy(TidStore *ts)
{
if (TidStoreIsShared(ts))
{
@@ -309,11 +309,11 @@ tidstore_destroy(TidStore *ts)
}
/*
- * Forget all collected Tids. It's similar to tidstore_destroy but we don't free
+ * Forget all collected Tids. It's similar to TidStoreDestroy() but we don't free
* entire TidStore but recreate only the radix tree storage.
*/
void
-tidstore_reset(TidStore *ts)
+TidStoreReset(TidStore *ts)
{
if (TidStoreIsShared(ts))
{
@@ -352,8 +352,8 @@ tidstore_reset(TidStore *ts)
/* Add Tids on a block to TidStore */
void
-tidstore_add_tids(TidStore *ts, BlockNumber blkno, OffsetNumber *offsets,
- int num_offsets)
+TidStoreSetBlockOffsets(TidStore *ts, BlockNumber blkno, OffsetNumber *offsets,
+ int num_offsets)
{
uint64 *values;
uint64 key;
@@ -431,7 +431,7 @@ tidstore_add_tids(TidStore *ts, BlockNumber blkno, OffsetNumber *offsets,
/* Return true if the given tid is present in the TidStore */
bool
-tidstore_lookup_tid(TidStore *ts, ItemPointer tid)
+TidStoreIsMember(TidStore *ts, ItemPointer tid)
{
uint64 key;
uint64 val = 0;
@@ -452,14 +452,16 @@ tidstore_lookup_tid(TidStore *ts, ItemPointer tid)
}
/*
- * Prepare to iterate through a TidStore. Since the radix tree is locked during the
- * iteration, so tidstore_end_iterate() needs to called when finished.
+ * Prepare to iterate through a TidStore. Since the radix tree is locked during
+ * the iteration, so TidStoreEndIterate() needs to be called when finished.
+ *
+ * The TidStoreIter struct is created in the caller's memory context.
*
* Concurrent updates during the iteration will be blocked when inserting a
* key-value to the radix tree.
*/
TidStoreIter *
-tidstore_begin_iterate(TidStore *ts)
+TidStoreBeginIterate(TidStore *ts)
{
TidStoreIter *iter;
@@ -477,7 +479,7 @@ tidstore_begin_iterate(TidStore *ts)
iter->tree_iter.local = local_rt_begin_iterate(ts->tree.local);
/* If the TidStore is empty, there is no business */
- if (tidstore_num_tids(ts) == 0)
+ if (TidStoreNumTids(ts) == 0)
iter->finished = true;
return iter;
@@ -498,7 +500,7 @@ tidstore_iter_kv(TidStoreIter *iter, uint64 *key, uint64 *val)
* numbers in each result is also sorted in ascending order.
*/
TidStoreIterResult *
-tidstore_iterate_next(TidStoreIter *iter)
+TidStoreIterateNext(TidStoreIter *iter)
{
uint64 key;
uint64 val;
@@ -544,7 +546,7 @@ tidstore_iterate_next(TidStoreIter *iter)
* or when existing an iteration.
*/
void
-tidstore_end_iterate(TidStoreIter *iter)
+TidStoreEndIterate(TidStoreIter *iter)
{
if (TidStoreIsShared(iter->ts))
shared_rt_end_iterate(iter->tree_iter.shared);
@@ -557,7 +559,7 @@ tidstore_end_iterate(TidStoreIter *iter)
/* Return the number of tids we collected so far */
int64
-tidstore_num_tids(TidStore *ts)
+TidStoreNumTids(TidStore *ts)
{
uint64 num_tids;
@@ -575,16 +577,16 @@ tidstore_num_tids(TidStore *ts)
/* Return true if the current memory usage of TidStore exceeds the limit */
bool
-tidstore_is_full(TidStore *ts)
+TidStoreIsFull(TidStore *ts)
{
Assert(!TidStoreIsShared(ts) || ts->control->magic == TIDSTORE_MAGIC);
- return (tidstore_memory_usage(ts) > ts->control->max_bytes);
+ return (TidStoreMemoryUsage(ts) > ts->control->max_bytes);
}
/* Return the maximum memory TidStore can use */
size_t
-tidstore_max_memory(TidStore *ts)
+TidStoreMaxMemory(TidStore *ts)
{
Assert(!TidStoreIsShared(ts) || ts->control->magic == TIDSTORE_MAGIC);
@@ -593,7 +595,7 @@ tidstore_max_memory(TidStore *ts)
/* Return the memory usage of TidStore */
size_t
-tidstore_memory_usage(TidStore *ts)
+TidStoreMemoryUsage(TidStore *ts)
{
Assert(!TidStoreIsShared(ts) || ts->control->magic == TIDSTORE_MAGIC);
@@ -611,8 +613,8 @@ tidstore_memory_usage(TidStore *ts)
/*
* Get a handle that can be used by other processes to attach to this TidStore
*/
-tidstore_handle
-tidstore_get_handle(TidStore *ts)
+TidStoreHandle
+TidStoreGetHandle(TidStore *ts)
{
Assert(TidStoreIsShared(ts) && ts->control->magic == TIDSTORE_MAGIC);
diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
index 2c72088e69..be487aced6 100644
--- a/src/backend/access/heap/vacuumlazy.c
+++ b/src/backend/access/heap/vacuumlazy.c
@@ -842,7 +842,7 @@ lazy_scan_heap(LVRelState *vacrel)
/* Report that we're scanning the heap, advertising total # of blocks */
initprog_val[0] = PROGRESS_VACUUM_PHASE_SCAN_HEAP;
initprog_val[1] = rel_pages;
- initprog_val[2] = tidstore_max_memory(vacrel->dead_items);
+ initprog_val[2] = TidStoreMaxMemory(vacrel->dead_items);
pgstat_progress_update_multi_param(3, initprog_index, initprog_val);
/* Set up an initial range of skippable blocks using the visibility map */
@@ -909,7 +909,7 @@ lazy_scan_heap(LVRelState *vacrel)
* dead_items TIDs, pause and do a cycle of vacuuming before we tackle
* this page.
*/
- if (tidstore_is_full(vacrel->dead_items))
+ if (TidStoreIsFull(vacrel->dead_items))
{
/*
* Before beginning index vacuuming, we release any pin we may
@@ -1078,16 +1078,16 @@ lazy_scan_heap(LVRelState *vacrel)
* with prunestate-driven visibility map and FSM steps (just like
* the two-pass strategy).
*/
- Assert(tidstore_num_tids(dead_items) == 0);
+ Assert(TidStoreNumTids(dead_items) == 0);
}
else if (prunestate.num_offsets > 0)
{
/* Save details of the LP_DEAD items from the page in dead_items */
- tidstore_add_tids(dead_items, blkno, prunestate.deadoffsets,
- prunestate.num_offsets);
+ TidStoreSetBlockOffsets(dead_items, blkno, prunestate.deadoffsets,
+ prunestate.num_offsets);
pgstat_progress_update_param(PROGRESS_VACUUM_DEAD_TUPLE_BYTES,
- tidstore_memory_usage(dead_items));
+ TidStoreMemoryUsage(dead_items));
}
/*
@@ -1258,7 +1258,7 @@ lazy_scan_heap(LVRelState *vacrel)
* Do index vacuuming (call each index's ambulkdelete routine), then do
* related heap vacuuming
*/
- if (tidstore_num_tids(dead_items) > 0)
+ if (TidStoreNumTids(dead_items) > 0)
lazy_vacuum(vacrel);
/*
@@ -2125,10 +2125,10 @@ lazy_scan_noprune(LVRelState *vacrel,
*/
vacrel->lpdead_item_pages++;
- tidstore_add_tids(dead_items, blkno, deadoffsets, lpdead_items);
+ TidStoreSetBlockOffsets(dead_items, blkno, deadoffsets, lpdead_items);
pgstat_progress_update_param(PROGRESS_VACUUM_DEAD_TUPLE_BYTES,
- tidstore_memory_usage(dead_items));
+ TidStoreMemoryUsage(dead_items));
vacrel->lpdead_items += lpdead_items;
@@ -2177,7 +2177,7 @@ lazy_vacuum(LVRelState *vacrel)
if (!vacrel->do_index_vacuuming)
{
Assert(!vacrel->do_index_cleanup);
- tidstore_reset(vacrel->dead_items);
+ TidStoreReset(vacrel->dead_items);
return;
}
@@ -2206,7 +2206,7 @@ lazy_vacuum(LVRelState *vacrel)
BlockNumber threshold;
Assert(vacrel->num_index_scans == 0);
- Assert(vacrel->lpdead_items == tidstore_num_tids(vacrel->dead_items));
+ Assert(vacrel->lpdead_items == TidStoreNumTids(vacrel->dead_items));
Assert(vacrel->do_index_vacuuming);
Assert(vacrel->do_index_cleanup);
@@ -2234,7 +2234,7 @@ lazy_vacuum(LVRelState *vacrel)
*/
threshold = (double) vacrel->rel_pages * BYPASS_THRESHOLD_PAGES;
bypass = (vacrel->lpdead_item_pages < threshold) &&
- tidstore_memory_usage(vacrel->dead_items) < (32L * 1024L * 1024L);
+ TidStoreMemoryUsage(vacrel->dead_items) < (32L * 1024L * 1024L);
}
if (bypass)
@@ -2279,7 +2279,7 @@ lazy_vacuum(LVRelState *vacrel)
* Forget the LP_DEAD items that we just vacuumed (or just decided to not
* vacuum)
*/
- tidstore_reset(vacrel->dead_items);
+ TidStoreReset(vacrel->dead_items);
}
/*
@@ -2352,7 +2352,7 @@ lazy_vacuum_all_indexes(LVRelState *vacrel)
* place).
*/
Assert(vacrel->num_index_scans > 0 ||
- tidstore_num_tids(vacrel->dead_items) == vacrel->lpdead_items);
+ TidStoreNumTids(vacrel->dead_items) == vacrel->lpdead_items);
Assert(allindexes || VacuumFailsafeActive);
/*
@@ -2407,8 +2407,8 @@ lazy_vacuum_heap_rel(LVRelState *vacrel)
VACUUM_ERRCB_PHASE_VACUUM_HEAP,
InvalidBlockNumber, InvalidOffsetNumber);
- iter = tidstore_begin_iterate(vacrel->dead_items);
- while ((result = tidstore_iterate_next(iter)) != NULL)
+ iter = TidStoreBeginIterate(vacrel->dead_items);
+ while ((iter_result = TidStoreIterateNext(iter)) != NULL)
{
BlockNumber blkno;
Buffer buf;
@@ -2442,7 +2442,7 @@ lazy_vacuum_heap_rel(LVRelState *vacrel)
RecordPageWithFreeSpace(vacrel->rel, blkno, freespace);
vacuumed_pages++;
}
- tidstore_end_iterate(iter);
+ TidStoreEndIterate(iter);
vacrel->blkno = InvalidBlockNumber;
if (BufferIsValid(vmbuffer))
@@ -2453,12 +2453,12 @@ lazy_vacuum_heap_rel(LVRelState *vacrel)
* the second heap pass. No more, no less.
*/
Assert(vacrel->num_index_scans > 1 ||
- (tidstore_num_tids(vacrel->dead_items) == vacrel->lpdead_items &&
+ (TidStoreNumTids(vacrel->dead_items) == vacrel->lpdead_items &&
vacuumed_pages == vacrel->lpdead_item_pages));
ereport(DEBUG2,
- (errmsg("table \"%s\": removed " UINT64_FORMAT "dead item identifiers in %u pages",
- vacrel->relname, tidstore_num_tids(vacrel->dead_items),
+ (errmsg("table \"%s\": removed " INT64_FORMAT "dead item identifiers in %u pages",
+ vacrel->relname, TidStoreNumTids(vacrel->dead_items),
vacuumed_pages)));
/* Revert to the previous phase information for error traceback */
@@ -3125,8 +3125,8 @@ dead_items_alloc(LVRelState *vacrel, int nworkers)
}
/* Serial VACUUM case */
- vacrel->dead_items = tidstore_create(vac_work_mem, MaxHeapTuplesPerPage,
- NULL);
+ vacrel->dead_items = TidStoreCreate(vac_work_mem, MaxHeapTuplesPerPage,
+ NULL);
}
/*
diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
index f3922b72dc..84f71fb14a 100644
--- a/src/backend/commands/vacuum.c
+++ b/src/backend/commands/vacuum.c
@@ -2486,7 +2486,7 @@ vac_bulkdel_one_index(IndexVacuumInfo *ivinfo, IndexBulkDeleteResult *istat,
ereport(ivinfo->message_level,
(errmsg("scanned index \"%s\" to remove " UINT64_FORMAT " row versions",
RelationGetRelationName(ivinfo->index),
- tidstore_num_tids(dead_items))));
+ TidStoreNumTids(dead_items))));
return istat;
}
@@ -2527,5 +2527,5 @@ vac_tid_reaped(ItemPointer itemptr, void *state)
{
TidStore *dead_items = (TidStore *) state;
- return tidstore_lookup_tid(dead_items, itemptr);
+ return TidStoreIsMember(dead_items, itemptr);
}
diff --git a/src/backend/commands/vacuumparallel.c b/src/backend/commands/vacuumparallel.c
index c363f45e32..be83ceb871 100644
--- a/src/backend/commands/vacuumparallel.c
+++ b/src/backend/commands/vacuumparallel.c
@@ -110,7 +110,7 @@ typedef struct PVShared
pg_atomic_uint32 idx;
/* Handle of the shared TidStore */
- tidstore_handle dead_items_handle;
+ TidStoreHandle dead_items_handle;
} PVShared;
/* Status used during parallel index vacuum or cleanup */
@@ -372,7 +372,7 @@ parallel_vacuum_init(Relation rel, Relation *indrels, int nindexes,
dead_items_dsa = dsa_create_in_place(area_space, dsa_minsize,
LWTRANCHE_PARALLEL_VACUUM_DSA,
pcxt->seg);
- dead_items = tidstore_create(vac_work_mem, max_offset, dead_items_dsa);
+ dead_items = TidStoreCreate(vac_work_mem, max_offset, dead_items_dsa);
pvs->dead_items = dead_items;
pvs->dead_items_area = dead_items_dsa;
@@ -385,7 +385,7 @@ parallel_vacuum_init(Relation rel, Relation *indrels, int nindexes,
(nindexes_mwm > 0) ?
maintenance_work_mem / Min(parallel_workers, nindexes_mwm) :
maintenance_work_mem;
- shared->dead_items_handle = tidstore_get_handle(dead_items);
+ shared->dead_items_handle = TidStoreGetHandle(dead_items);
/* Use the same buffer size for all workers */
shared->ring_nbuffers = GetAccessStrategyBufferCount(bstrategy);
@@ -454,7 +454,7 @@ parallel_vacuum_end(ParallelVacuumState *pvs, IndexBulkDeleteResult **istats)
istats[i] = NULL;
}
- tidstore_destroy(pvs->dead_items);
+ TidStoreDestroy(pvs->dead_items);
dsa_detach(pvs->dead_items_area);
DestroyParallelContext(pvs->pcxt);
@@ -1013,7 +1013,7 @@ parallel_vacuum_main(dsm_segment *seg, shm_toc *toc)
/* Set dead items */
area_space = shm_toc_lookup(toc, PARALLEL_VACUUM_KEY_DEAD_ITEMS, false);
dead_items_area = dsa_attach_in_place(area_space, seg);
- dead_items = tidstore_attach(dead_items_area, shared->dead_items_handle);
+ dead_items = TidStoreAttach(dead_items_area, shared->dead_items_handle);
/* Set cost-based vacuum delay */
VacuumUpdateCosts();
@@ -1061,7 +1061,7 @@ parallel_vacuum_main(dsm_segment *seg, shm_toc *toc)
InstrEndParallelQuery(&buffer_usage[ParallelWorkerNumber],
&wal_usage[ParallelWorkerNumber]);
- tidstore_detach(pvs.dead_items);
+ TidStoreDetach(dead_items);
dsa_detach(dead_items_area);
/* Pop the error context stack */
diff --git a/src/include/access/tidstore.h b/src/include/access/tidstore.h
index a35a52124a..f0a432d0da 100644
--- a/src/include/access/tidstore.h
+++ b/src/include/access/tidstore.h
@@ -17,7 +17,7 @@
#include "storage/itemptr.h"
#include "utils/dsa.h"
-typedef dsa_pointer tidstore_handle;
+typedef dsa_pointer TidStoreHandle;
typedef struct TidStore TidStore;
typedef struct TidStoreIter TidStoreIter;
@@ -29,21 +29,21 @@ typedef struct TidStoreIterResult
int num_offsets;
} TidStoreIterResult;
-extern TidStore *tidstore_create(size_t max_bytes, int max_offset, dsa_area *dsa);
-extern TidStore *tidstore_attach(dsa_area *dsa, dsa_pointer handle);
-extern void tidstore_detach(TidStore *ts);
-extern void tidstore_destroy(TidStore *ts);
-extern void tidstore_reset(TidStore *ts);
-extern void tidstore_add_tids(TidStore *ts, BlockNumber blkno, OffsetNumber *offsets,
- int num_offsets);
-extern bool tidstore_lookup_tid(TidStore *ts, ItemPointer tid);
-extern TidStoreIter * tidstore_begin_iterate(TidStore *ts);
-extern TidStoreIterResult *tidstore_iterate_next(TidStoreIter *iter);
-extern void tidstore_end_iterate(TidStoreIter *iter);
-extern int64 tidstore_num_tids(TidStore *ts);
-extern bool tidstore_is_full(TidStore *ts);
-extern size_t tidstore_max_memory(TidStore *ts);
-extern size_t tidstore_memory_usage(TidStore *ts);
-extern tidstore_handle tidstore_get_handle(TidStore *ts);
+extern TidStore *TidStoreCreate(size_t max_bytes, int max_off, dsa_area *dsa);
+extern TidStore *TidStoreAttach(dsa_area *dsa, dsa_pointer handle);
+extern void TidStoreDetach(TidStore *ts);
+extern void TidStoreDestroy(TidStore *ts);
+extern void TidStoreReset(TidStore *ts);
+extern void TidStoreSetBlockOffsets(TidStore *ts, BlockNumber blkno, OffsetNumber *offsets,
+ int num_offsets);
+extern bool TidStoreIsMember(TidStore *ts, ItemPointer tid);
+extern TidStoreIter * TidStoreBeginIterate(TidStore *ts);
+extern TidStoreIterResult *TidStoreIterateNext(TidStoreIter *iter);
+extern void TidStoreEndIterate(TidStoreIter *iter);
+extern int64 TidStoreNumTids(TidStore *ts);
+extern bool TidStoreIsFull(TidStore *ts);
+extern size_t TidStoreMaxMemory(TidStore *ts);
+extern size_t TidStoreMemoryUsage(TidStore *ts);
+extern TidStoreHandle TidStoreGetHandle(TidStore *ts);
#endif /* TIDSTORE_H */
diff --git a/src/test/modules/test_tidstore/test_tidstore.c b/src/test/modules/test_tidstore/test_tidstore.c
index 9a1217f833..12d3027624 100644
--- a/src/test/modules/test_tidstore/test_tidstore.c
+++ b/src/test/modules/test_tidstore/test_tidstore.c
@@ -37,10 +37,10 @@ check_tid(TidStore *ts, BlockNumber blkno, OffsetNumber off, bool expect)
ItemPointerSet(&tid, blkno, off);
- found = tidstore_lookup_tid(ts, &tid);
+ found = TidStoreIsMember(ts, &tid);
if (found != expect)
- elog(ERROR, "lookup TID (%u, %u) returned %d, expected %d",
+ elog(ERROR, "TidStoreIsMember for TID (%u, %u) returned %d, expected %d",
blkno, off, found, expect);
}
@@ -69,9 +69,9 @@ test_basic(int max_offset)
LWLockRegisterTranche(tranche_id, "test_tidstore");
dsa = dsa_create(tranche_id);
- ts = tidstore_create(TEST_TIDSTORE_MAX_BYTES, max_offset, dsa);
+ ts = TidStoreCreate(TEST_TIDSTORE_MAX_BYTES, max_offset, dsa);
#else
- ts = tidstore_create(TEST_TIDSTORE_MAX_BYTES, max_offset, NULL);
+ ts = TidStoreCreate(TEST_TIDSTORE_MAX_BYTES, max_offset, NULL);
#endif
/* prepare the offset array */
@@ -83,7 +83,7 @@ test_basic(int max_offset)
/* add tids */
for (int i = 0; i < TEST_TIDSTORE_NUM_BLOCKS; i++)
- tidstore_add_tids(ts, blks[i], offs, TEST_TIDSTORE_NUM_OFFSETS);
+ TidStoreSetBlockOffsets(ts, blks[i], offs, TEST_TIDSTORE_NUM_OFFSETS);
/* lookup test */
for (OffsetNumber off = FirstOffsetNumber ; off < max_offset; off++)
@@ -105,30 +105,30 @@ test_basic(int max_offset)
}
/* test the number of tids */
- if (tidstore_num_tids(ts) != (TEST_TIDSTORE_NUM_BLOCKS * TEST_TIDSTORE_NUM_OFFSETS))
- elog(ERROR, "tidstore_num_tids returned " UINT64_FORMAT ", expected %d",
- tidstore_num_tids(ts),
+ if (TidStoreNumTids(ts) != (TEST_TIDSTORE_NUM_BLOCKS * TEST_TIDSTORE_NUM_OFFSETS))
+ elog(ERROR, "TidStoreNumTids returned " UINT64_FORMAT ", expected %d",
+ TidStoreNumTids(ts),
TEST_TIDSTORE_NUM_BLOCKS * TEST_TIDSTORE_NUM_OFFSETS);
/* iteration test */
- iter = tidstore_begin_iterate(ts);
+ iter = TidStoreBeginIterate(ts);
blk_idx = 0;
- while ((iter_result = tidstore_iterate_next(iter)) != NULL)
+ while ((iter_result = TidStoreIterateNext(iter)) != NULL)
{
/* check the returned block number */
if (blks_sorted[blk_idx] != iter_result->blkno)
- elog(ERROR, "tidstore_iterate_next returned block number %u, expected %u",
+ elog(ERROR, "TidStoreIterateNext returned block number %u, expected %u",
iter_result->blkno, blks_sorted[blk_idx]);
/* check the returned offset numbers */
if (TEST_TIDSTORE_NUM_OFFSETS != iter_result->num_offsets)
- elog(ERROR, "tidstore_iterate_next returned %u offsets, expected %u",
+ elog(ERROR, "TidStoreIterateNext %u offsets, expected %u",
iter_result->num_offsets, TEST_TIDSTORE_NUM_OFFSETS);
for (int i = 0; i < iter_result->num_offsets; i++)
{
if (offs[i] != iter_result->offsets[i])
- elog(ERROR, "tidstore_iterate_next returned offset number %u on block %u, expected %u",
+ elog(ERROR, "TidStoreIterateNext offset number %u on block %u, expected %u",
iter_result->offsets[i], iter_result->blkno, offs[i]);
}
@@ -136,15 +136,15 @@ test_basic(int max_offset)
}
if (blk_idx != TEST_TIDSTORE_NUM_BLOCKS)
- elog(ERROR, "tidstore_iterate_next returned %d blocks, expected %d",
+ elog(ERROR, "TidStoreIterateNext returned %d blocks, expected %d",
blk_idx, TEST_TIDSTORE_NUM_BLOCKS);
/* remove all tids */
- tidstore_reset(ts);
+ TidStoreReset(ts);
/* test the number of tids */
- if (tidstore_num_tids(ts) != 0)
- elog(ERROR, "tidstore_num_tids on empty store returned non-zero");
+ if (TidStoreNumTids(ts) != 0)
+ elog(ERROR, "TidStoreNumTids on empty store returned non-zero");
/* lookup test for empty store */
for (OffsetNumber off = FirstOffsetNumber ; off < MaxHeapTuplesPerPage;
@@ -156,7 +156,7 @@ test_basic(int max_offset)
check_tid(ts, MaxBlockNumber, off, false);
}
- tidstore_destroy(ts);
+ TidStoreDestroy(ts);
#ifdef TEST_SHARED_TIDSTORE
dsa_detach(dsa);
@@ -177,36 +177,37 @@ test_empty(void)
LWLockRegisterTranche(tranche_id, "test_tidstore");
dsa = dsa_create(tranche_id);
- ts = tidstore_create(TEST_TIDSTORE_MAX_BYTES, MaxHeapTuplesPerPage, dsa);
+ ts = TidStoreCreate(TEST_TIDSTORE_MAX_BYTES, MaxHeapTuplesPerPage, dsa);
#else
- ts = tidstore_create(TEST_TIDSTORE_MAX_BYTES, MaxHeapTuplesPerPage, NULL);
+ ts = TidStoreCreate(TEST_TIDSTORE_MAX_BYTES, MaxHeapTuplesPerPage, NULL);
#endif
elog(NOTICE, "testing empty tidstore");
ItemPointerSet(&tid, 0, FirstOffsetNumber);
- if (tidstore_lookup_tid(ts, &tid))
- elog(ERROR, "tidstore_lookup_tid for (0,1) on empty store returned true");
+ if (TidStoreIsMember(ts, &tid))
+ elog(ERROR, "TidStoreIsMember for TID (%u,%u) on empty store returned true",
+ 0, FirstOffsetNumber);
ItemPointerSet(&tid, MaxBlockNumber, MaxOffsetNumber);
- if (tidstore_lookup_tid(ts, &tid))
- elog(ERROR, "tidstore_lookup_tid for (%u,%u) on empty store returned true",
+ if (TidStoreIsMember(ts, &tid))
+ elog(ERROR, "TidStoreIsMember for TID (%u,%u) on empty store returned true",
MaxBlockNumber, MaxOffsetNumber);
- if (tidstore_num_tids(ts) != 0)
- elog(ERROR, "tidstore_num_entries on empty store returned non-zero");
+ if (TidStoreNumTids(ts) != 0)
+ elog(ERROR, "TidStoreNumTids on empty store returned non-zero");
- if (tidstore_is_full(ts))
- elog(ERROR, "tidstore_is_full on empty store returned true");
+ if (TidStoreIsFull(ts))
+ elog(ERROR, "TidStoreIsFull on empty store returned true");
- iter = tidstore_begin_iterate(ts);
+ iter = TidStoreBeginIterate(ts);
- if (tidstore_iterate_next(iter) != NULL)
- elog(ERROR, "tidstore_iterate_next on empty store returned TIDs");
+ if (TidStoreIterateNext(iter) != NULL)
+ elog(ERROR, "TidStoreIterateNext on empty store returned TIDs");
- tidstore_end_iterate(iter);
+ TidStoreEndIterate(iter);
- tidstore_destroy(ts);
+ TidStoreDestroy(ts);
#ifdef TEST_SHARED_TIDSTORE
dsa_detach(dsa);
--
2.31.1