MemoryContext oldcxt;
oldcxt = MemoryContextSwitchTo(indexInfo->ii_Context);
- bistate = palloc0(sizeof(BrinInsertState));
+ bistate = palloc0_object(BrinInsertState);
bistate->bis_desc = brin_build_desc(idxRel);
bistate->bis_rmAccess = brinRevmapInitialize(idxRel,
&bistate->bis_pages_per_range);
{
SortCoordinate coordinate;
- coordinate = (SortCoordinate) palloc0(sizeof(SortCoordinateData));
+ coordinate = palloc0_object(SortCoordinateData);
coordinate->isWorker = false;
coordinate->nParticipants =
state->bs_leader->nparticipanttuplesorts;
Size estsort;
BrinShared *brinshared;
Sharedsort *sharedsort;
- BrinLeader *brinleader = (BrinLeader *) palloc0(sizeof(BrinLeader));
+ BrinLeader *brinleader = palloc0_object(BrinLeader);
WalUsage *walusage;
BufferUsage *bufferusage;
bool leaderparticipates = true;
IndexInfo *indexInfo;
/* Initialize local tuplesort coordination state */
- coordinate = palloc0(sizeof(SortCoordinateData));
+ coordinate = palloc0_object(SortCoordinateData);
coordinate->isWorker = true;
coordinate->nParticipants = -1;
coordinate->sharedsort = sharedsort;
return NULL;
ndistances = (neranges - 1);
- distances = (DistanceValue *) palloc0(sizeof(DistanceValue) * ndistances);
+ distances = palloc0_array(DistanceValue, ndistances);
/*
* Walk through the ranges once and compute the distance between the
/* allocate space for the boundary values */
nvalues = 0;
- values = (Datum *) palloc(sizeof(Datum) * max_values);
+ values = palloc_array(Datum, max_values);
/* add the global min/max values, from the first/last range */
values[nvalues++] = eranges[0].minval;
page = BufferGetPage(meta);
metadata = (BrinMetaPageData *) PageGetContents(page);
- revmap = palloc(sizeof(BrinRevmap));
+ revmap = palloc_object(BrinRevmap);
revmap->rm_irel = idxrel;
revmap->rm_pagesPerRange = metadata->pagesPerRange;
revmap->rm_lastRevmapPage = metadata->lastRevmapPage;
Assert(brdesc->bd_totalstored > 0);
- values = (Datum *) palloc(sizeof(Datum) * brdesc->bd_totalstored);
- nulls = (bool *) palloc0(sizeof(bool) * brdesc->bd_totalstored);
- phony_nullbitmap = (bits8 *)
- palloc(sizeof(bits8) * BITMAPLEN(brdesc->bd_totalstored));
+ values = palloc_array(Datum, brdesc->bd_totalstored);
+ nulls = palloc0_array(bool, brdesc->bd_totalstored);
+ phony_nullbitmap = palloc_array(bits8, BITMAPLEN(brdesc->bd_totalstored));
#ifdef TOAST_INDEX_HACK
- untoasted_values = (Datum *) palloc(sizeof(Datum) * brdesc->bd_totalstored);
+ untoasted_values = palloc_array(Datum, brdesc->bd_totalstored);
#endif
/*
sizeof(BrinValues) * brdesc->bd_tupdesc->natts);
dtup = palloc0(basesize + sizeof(Datum) * brdesc->bd_totalstored);
- dtup->bt_values = palloc(sizeof(Datum) * brdesc->bd_totalstored);
- dtup->bt_allnulls = palloc(sizeof(bool) * brdesc->bd_tupdesc->natts);
- dtup->bt_hasnulls = palloc(sizeof(bool) * brdesc->bd_tupdesc->natts);
+ dtup->bt_values = palloc_array(Datum, brdesc->bd_totalstored);
+ dtup->bt_allnulls = palloc_array(bool, brdesc->bd_tupdesc->natts);
+ dtup->bt_hasnulls = palloc_array(bool, brdesc->bd_tupdesc->natts);
dtup->bt_empty_range = true;
{
AttrMap *res;
- res = (AttrMap *) palloc0(sizeof(AttrMap));
+ res = palloc0_object(AttrMap);
res->maplen = maplen;
- res->attnums = (AttrNumber *) palloc0(sizeof(AttrNumber) * maplen);
+ res->attnums = palloc0_array(AttrNumber, maplen);
return res;
}
* O(N^2) if there are many non-replaced columns, so it seems better to
* err on the side of linear cost.
*/
- values = (Datum *) palloc(numberOfAttributes * sizeof(Datum));
- isnull = (bool *) palloc(numberOfAttributes * sizeof(bool));
+ values = palloc_array(Datum, numberOfAttributes);
+ isnull = palloc_array(bool, numberOfAttributes);
heap_deform_tuple(tuple, tupleDesc, values, isnull);
* allocate and fill values and isnull arrays from the tuple, then replace
* selected columns from the input arrays.
*/
- values = (Datum *) palloc(numberOfAttributes * sizeof(Datum));
- isnull = (bool *) palloc(numberOfAttributes * sizeof(bool));
+ values = palloc_array(Datum, numberOfAttributes);
+ isnull = palloc_array(bool, numberOfAttributes);
heap_deform_tuple(tuple, tupleDesc, values, isnull);
DestReceiver *
printtup_create_DR(CommandDest dest)
{
- DR_printtup *self = (DR_printtup *) palloc0(sizeof(DR_printtup));
+ DR_printtup *self = palloc0_object(DR_printtup);
self->pub.receiveSlot = printtup; /* might get changed later */
self->pub.rStartup = printtup_startup;
static void
add_local_reloption(local_relopts *relopts, relopt_gen *newoption, int offset)
{
- local_relopt *opt = palloc(sizeof(*opt));
+ local_relopt *opt = palloc_object(local_relopt);
Assert(offset < relopts->relopt_struct_size);
parseLocalRelOptions(local_relopts *relopts, Datum options, bool validate)
{
int nopts = list_length(relopts->options);
- relopt_value *values = palloc(sizeof(*values) * nopts);
+ relopt_value *values = palloc_array(relopt_value, nopts);
ListCell *lc;
int i = 0;
build_local_reloptions(local_relopts *relopts, Datum options, bool validate)
{
int noptions = list_length(relopts->options);
- relopt_parse_elt *elems = palloc(sizeof(*elems) * noptions);
+ relopt_parse_elt *elems = palloc_array(relopt_parse_elt, noptions);
relopt_value *vals;
void *opts;
int i = 0;
size_t minContextSize = ALLOCSET_DEFAULT_MINSIZE;
size_t maxBlockSize = ALLOCSET_DEFAULT_MAXSIZE;
- ts = palloc0(sizeof(TidStore));
+ ts = palloc0_object(TidStore);
/* choose the maxBlockSize to be no larger than 1/16 of max_bytes */
while (16 * maxBlockSize > max_bytes)
size_t dsa_init_size = DSA_DEFAULT_INIT_SEGMENT_SIZE;
size_t dsa_max_size = DSA_MAX_SEGMENT_SIZE;
- ts = palloc0(sizeof(TidStore));
+ ts = palloc0_object(TidStore);
/*
* Choose the initial and maximum DSA segment sizes to be no longer than
Assert(DsaPointerIsValid(handle));
/* create per-backend state */
- ts = palloc0(sizeof(TidStore));
+ ts = palloc0_object(TidStore);
area = dsa_attach(area_handle);
{
TidStoreIter *iter;
- iter = palloc0(sizeof(TidStoreIter));
+ iter = palloc0_object(TidStoreIter);
iter->ts = ts;
if (TidStoreIsShared(ts))
*num_indexes = list_length(indexlist);
/* Open all the index relations */
- *toastidxs = (Relation *) palloc(*num_indexes * sizeof(Relation));
+ *toastidxs = palloc_array(Relation, *num_indexes);
foreach(lc, indexlist)
(*toastidxs)[i++] = index_open(lfirst_oid(lc), lock);
}
/* Prepare the map structure */
- map = (TupleConversionMap *) palloc(sizeof(TupleConversionMap));
+ map = palloc_object(TupleConversionMap);
map->indesc = indesc;
map->outdesc = outdesc;
map->attrMap = attrMap;
/* preallocate workspace for Datum arrays */
n = outdesc->natts + 1; /* +1 for NULL */
- map->outvalues = (Datum *) palloc(n * sizeof(Datum));
- map->outisnull = (bool *) palloc(n * sizeof(bool));
+ map->outvalues = palloc_array(Datum, n);
+ map->outisnull = palloc_array(bool, n);
n = indesc->natts + 1; /* +1 for NULL */
- map->invalues = (Datum *) palloc(n * sizeof(Datum));
- map->inisnull = (bool *) palloc(n * sizeof(bool));
+ map->invalues = palloc_array(Datum, n);
+ map->inisnull = palloc_array(bool, n);
map->invalues[0] = (Datum) 0; /* set up the NULL entry */
map->inisnull[0] = true;
Assert(attrMap != NULL);
/* Prepare the map structure */
- map = (TupleConversionMap *) palloc(sizeof(TupleConversionMap));
+ map = palloc_object(TupleConversionMap);
map->indesc = indesc;
map->outdesc = outdesc;
map->attrMap = attrMap;
/* preallocate workspace for Datum arrays */
- map->outvalues = (Datum *) palloc(n * sizeof(Datum));
- map->outisnull = (bool *) palloc(n * sizeof(bool));
+ map->outvalues = palloc_array(Datum, n);
+ map->outisnull = palloc_array(bool, n);
n = indesc->natts + 1; /* +1 for NULL */
- map->invalues = (Datum *) palloc(n * sizeof(Datum));
- map->inisnull = (bool *) palloc(n * sizeof(bool));
+ map->invalues = palloc_array(Datum, n);
+ map->inisnull = palloc_array(bool, n);
map->invalues[0] = (Datum) 0; /* set up the NULL entry */
map->inisnull[0] = true;
/* Copy the TupleConstr data structure, if any */
if (constr)
{
- TupleConstr *cpy = (TupleConstr *) palloc0(sizeof(TupleConstr));
+ TupleConstr *cpy = palloc0_object(TupleConstr);
cpy->has_not_null = constr->has_not_null;
cpy->has_generated_stored = constr->has_generated_stored;
{
GinBtreeStack *stack;
- stack = (GinBtreeStack *) palloc(sizeof(GinBtreeStack));
+ stack = palloc_object(GinBtreeStack);
stack->blkno = btree->rootBlkno;
stack->buffer = ReadBuffer(btree->index, btree->rootBlkno);
stack->parent = NULL;
}
else
{
- GinBtreeStack *ptr = (GinBtreeStack *) palloc(sizeof(GinBtreeStack));
+ GinBtreeStack *ptr = palloc_object(GinBtreeStack);
ptr->parent = stack;
stack = ptr;
blkno = root->blkno;
buffer = root->buffer;
- ptr = (GinBtreeStack *) palloc(sizeof(GinBtreeStack));
+ ptr = palloc_object(GinBtreeStack);
for (;;)
{
*/
if (accum->entryallocator == NULL || accum->eas_used >= DEF_NENTRY)
{
- accum->entryallocator = palloc(sizeof(GinEntryAccumulator) * DEF_NENTRY);
+ accum->entryallocator = palloc_array(GinEntryAccumulator, DEF_NENTRY);
accum->allocatedMemory += GetMemoryChunkSpace(accum->entryallocator);
accum->eas_used = 0;
}
ea->maxcount = DEF_NPTR;
ea->count = 1;
ea->shouldSort = false;
- ea->list =
- (ItemPointerData *) palloc(sizeof(ItemPointerData) * DEF_NPTR);
+ ea->list = palloc_array(ItemPointerData, DEF_NPTR);
ea->list[0] = *heapptr;
accum->allocatedMemory += GetMemoryChunkSpace(ea->list);
}
static void *
dataPrepareDownlink(GinBtree btree, Buffer lbuf)
{
- PostingItem *pitem = palloc(sizeof(PostingItem));
+ PostingItem *pitem = palloc_object(PostingItem);
Page lpage = BufferGetPage(lbuf);
PostingItemSetBlockNumber(pitem, BufferGetBlockNumber(lbuf));
char *segbegin;
char *segend;
- leaf = palloc0(sizeof(disassembledLeaf));
+ leaf = palloc0_object(disassembledLeaf);
dlist_init(&leaf->segments);
if (GinPageIsCompressed(page))
segend = segbegin + GinDataLeafPageGetPostingListSize(page);
while ((char *) seg < segend)
{
- leafSegmentInfo *seginfo = palloc(sizeof(leafSegmentInfo));
+ leafSegmentInfo *seginfo = palloc_object(leafSegmentInfo);
seginfo->action = GIN_SEGMENT_UNMODIFIED;
seginfo->seg = seg;
if (nuncompressed > 0)
{
- seginfo = palloc(sizeof(leafSegmentInfo));
+ seginfo = palloc_object(leafSegmentInfo);
seginfo->action = GIN_SEGMENT_REPLACE;
seginfo->seg = NULL;
*/
if (dlist_is_empty(&leaf->segments))
{
- newseg = palloc(sizeof(leafSegmentInfo));
+ newseg = palloc_object(leafSegmentInfo);
newseg->seg = NULL;
newseg->items = newItems;
newseg->nitems = nNewItems;
cur->seg != NULL &&
SizeOfGinPostingList(cur->seg) >= GinPostingListSegmentTargetSize)
{
- newseg = palloc(sizeof(leafSegmentInfo));
+ newseg = palloc_object(leafSegmentInfo);
newseg->seg = NULL;
newseg->items = nextnew;
newseg->nitems = nthis;
if (seginfo->action != GIN_SEGMENT_INSERT)
seginfo->action = GIN_SEGMENT_REPLACE;
- nextseg = palloc(sizeof(leafSegmentInfo));
+ nextseg = palloc_object(leafSegmentInfo);
nextseg->action = GIN_SEGMENT_INSERT;
nextseg->seg = NULL;
nextseg->items = &seginfo->items[npacked];
}
else
{
- ipd = (ItemPointer) palloc(sizeof(ItemPointerData) * nipd);
+ ipd = palloc_array(ItemPointerData, nipd);
memcpy(ipd, ptr, sizeof(ItemPointerData) * nipd);
}
*nitems = nipd;
itup = getRightMostTuple(lpage);
- insertData = palloc(sizeof(GinBtreeEntryInsertData));
+ insertData = palloc_object(GinBtreeEntryInsertData);
insertData->entry = GinFormInteriorTuple(itup, lpage, lblkno);
insertData->isDelete = false;
{
MemoryContextSwitchTo(so->tempCtx);
- entryIndexes = (int *) palloc(sizeof(int) * key->nentries);
+ entryIndexes = palloc_array(int, key->nentries);
for (i = 0; i < key->nentries; i++)
entryIndexes[i] = i;
qsort_arg(entryIndexes, key->nentries, sizeof(int),
LockBuffer(pos.pendingBuffer, GIN_SHARE);
pos.firstOffset = FirstOffsetNumber;
UnlockReleaseBuffer(metabuffer);
- pos.hasMatchKey = palloc(sizeof(bool) * so->nkeys);
+ pos.hasMatchKey = palloc_array(bool, so->nkeys);
/*
* loop for each heap row. scanGetCandidate returns full row or row's
{
SortCoordinate coordinate;
- coordinate = (SortCoordinate) palloc0(sizeof(SortCoordinateData));
+ coordinate = palloc0_object(SortCoordinateData);
coordinate->isWorker = false;
coordinate->nParticipants =
state->bs_leader->nparticipanttuplesorts;
/*
* Return statistics
*/
- result = (IndexBuildResult *) palloc(sizeof(IndexBuildResult));
+ result = palloc_object(IndexBuildResult);
result->heap_tuples = reltuples;
result->index_tuples = buildstate.indtuples;
if (ginstate == NULL)
{
oldCtx = MemoryContextSwitchTo(indexInfo->ii_Context);
- ginstate = (GinState *) palloc(sizeof(GinState));
+ ginstate = palloc_object(GinState);
initGinState(ginstate, index);
indexInfo->ii_AmCache = ginstate;
MemoryContextSwitchTo(oldCtx);
Size estsort;
GinBuildShared *ginshared;
Sharedsort *sharedsort;
- GinLeader *ginleader = (GinLeader *) palloc0(sizeof(GinLeader));
+ GinLeader *ginleader = palloc0_object(GinLeader);
WalUsage *walusage;
BufferUsage *bufferusage;
bool leaderparticipates = true;
static GinBuffer *
GinBufferInit(Relation index)
{
- GinBuffer *buffer = palloc0(sizeof(GinBuffer));
+ GinBuffer *buffer = palloc0_object(GinBuffer);
int i,
nKeys;
TupleDesc desc = RelationGetDescr(index);
nKeys = IndexRelationGetNumberOfKeyAttributes(index);
- buffer->ssup = palloc0(sizeof(SortSupportData) * nKeys);
+ buffer->ssup = palloc0_array(SortSupportData, nKeys);
/*
* Lookup ordering operator for the index key data type, and initialize
IndexInfo *indexInfo;
/* Initialize local tuplesort coordination state */
- coordinate = palloc0(sizeof(SortCoordinateData));
+ coordinate = palloc0_object(SortCoordinateData);
coordinate->isWorker = true;
coordinate->nParticipants = -1;
coordinate->sharedsort = sharedsort;
while (ncompressed < nitems)
{
int cnt;
- GinSegmentInfo *seginfo = palloc(sizeof(GinSegmentInfo));
+ GinSegmentInfo *seginfo = palloc_object(GinSegmentInfo);
seginfo->seg = ginCompressPostingList(&items[ncompressed],
(nitems - ncompressed),
scan = RelationGetIndexScan(rel, nkeys, norderbys);
/* allocate private workspace */
- so = (GinScanOpaque) palloc(sizeof(GinScanOpaqueData));
+ so = (GinScanOpaque) palloc_object(GinScanOpaqueData);
so->keys = NULL;
so->nkeys = 0;
so->tempCtx = AllocSetContextCreate(CurrentMemoryContext,
}
/* Nope, create a new entry */
- scanEntry = (GinScanEntry) palloc(sizeof(GinScanEntryData));
+ scanEntry = palloc_object(GinScanEntryData);
scanEntry->queryKey = queryKey;
scanEntry->queryCategory = queryCategory;
scanEntry->isPartialMatch = isPartialMatch;
if (so->totalentries >= so->allocentries)
{
so->allocentries *= 2;
- so->entries = (GinScanEntry *)
- repalloc(so->entries, so->allocentries * sizeof(GinScanEntry));
+ so->entries = repalloc_array(so->entries, GinScanEntry, so->allocentries);
}
so->entries[so->totalentries++] = scanEntry;
key->nuserentries = nQueryValues;
/* Allocate one extra array slot for possible "hidden" entry */
- key->scanEntry = (GinScanEntry *) palloc(sizeof(GinScanEntry) *
- (nQueryValues + 1));
- key->entryRes = (GinTernaryValue *) palloc0(sizeof(GinTernaryValue) *
- (nQueryValues + 1));
+ key->scanEntry = palloc_array(GinScanEntry, nQueryValues + 1);
+ key->entryRes = palloc0_array(GinTernaryValue, nQueryValues + 1);
key->query = query;
key->queryValues = queryValues;
if (isNull)
{
*nentries = 1;
- entries = (Datum *) palloc(sizeof(Datum));
+ entries = palloc_object(Datum);
entries[0] = (Datum) 0;
- *categories = (GinNullCategory *) palloc(sizeof(GinNullCategory));
+ *categories = palloc_object(GinNullCategory);
(*categories)[0] = GIN_CAT_NULL_ITEM;
return entries;
}
if (entries == NULL || *nentries <= 0)
{
*nentries = 1;
- entries = (Datum *) palloc(sizeof(Datum));
+ entries = palloc_object(Datum);
entries[0] = (Datum) 0;
- *categories = (GinNullCategory *) palloc(sizeof(GinNullCategory));
+ *categories = palloc_object(GinNullCategory);
(*categories)[0] = GIN_CAT_EMPTY_ITEM;
return entries;
}
keyEntryData *keydata;
cmpEntriesArg arg;
- keydata = (keyEntryData *) palloc(*nentries * sizeof(keyEntryData));
+ keydata = palloc_array(keyEntryData, *nentries);
for (i = 0; i < *nentries; i++)
{
keydata[i].datum = entries[i];
* First TID to be deleted: allocate memory to hold the
* remaining items.
*/
- tmpitems = palloc(sizeof(ItemPointerData) * nitem);
+ tmpitems = palloc_array(ItemPointerData, nitem);
memcpy(tmpitems, items, sizeof(ItemPointerData) * i);
}
}
{
if (!parent->child)
{
- me = (DataPageDeleteStack *) palloc0(sizeof(DataPageDeleteStack));
+ me = palloc0_object(DataPageDeleteStack);
me->parent = parent;
parent->child = me;
me->leftBuffer = InvalidBuffer;
if (stats == NULL)
{
/* Yes, so initialize stats to zeroes */
- stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+ stats = palloc0_object(IndexBulkDeleteResult);
/*
* and cleanup any pending inserts
*/
if (stats == NULL)
{
- stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+ stats = palloc0_object(IndexBulkDeleteResult);
initGinState(&ginstate, index);
ginInsertCleanup(&ginstate, !AmAutoVacuumWorkerProcess(),
false, true, stats);
#define ROTATEDIST(d) do { \
- SplitPageLayout *tmp = (SplitPageLayout *) palloc0(sizeof(SplitPageLayout)); \
+ SplitPageLayout *tmp = palloc0_object(SplitPageLayout); \
tmp->block.blkno = InvalidBlockNumber; \
tmp->buffer = InvalidBuffer; \
tmp->next = (d); \
/* Prepare a vector of all the downlinks */
for (ptr = dist; ptr; ptr = ptr->next)
ndownlinks++;
- downlinks = palloc(sizeof(IndexTuple) * ndownlinks);
+ downlinks = palloc_array(IndexTuple, ndownlinks);
for (i = 0, ptr = dist; ptr; ptr = ptr->next)
downlinks[i++] = ptr->itup;
/* Prepare split-info to be returned to caller */
for (ptr = dist; ptr; ptr = ptr->next)
{
- GISTPageSplitInfo *si = palloc(sizeof(GISTPageSplitInfo));
+ GISTPageSplitInfo *si = palloc_object(GISTPageSplitInfo);
si->buf = ptr->buffer;
si->downlink = ptr->itup;
xlocked = false;
/* descend to the chosen child */
- item = (GISTInsertStack *) palloc0(sizeof(GISTInsertStack));
+ item = palloc0_object(GISTInsertStack);
item->blkno = childblkno;
item->parent = stack;
item->downlinkoffnum = downlinkoffnum;
*ptr;
BlockNumber blkno;
- top = (GISTInsertStack *) palloc0(sizeof(GISTInsertStack));
+ top = palloc0_object(GISTInsertStack);
top->blkno = GIST_ROOT_BLKNO;
top->downlinkoffnum = InvalidOffsetNumber;
* leaf pages, and we assume that there can't be any non-leaf
* pages behind leaf pages.
*/
- ptr = (GISTInsertStack *) palloc0(sizeof(GISTInsertStack));
+ ptr = palloc0_object(GISTInsertStack);
ptr->blkno = GistPageGetOpaque(page)->rightlink;
ptr->downlinkoffnum = InvalidOffsetNumber;
ptr->parent = top->parent;
else
{
/* Append this child to the list of pages to visit later */
- ptr = (GISTInsertStack *) palloc0(sizeof(GISTInsertStack));
+ ptr = palloc0_object(GISTInsertStack);
ptr->blkno = blkno;
ptr->downlinkoffnum = i;
ptr->parent = top;
*/
for (;;)
{
- GISTPageSplitInfo *si = palloc(sizeof(GISTPageSplitInfo));
+ GISTPageSplitInfo *si = palloc_object(GISTPageSplitInfo);
IndexTuple downlink;
page = BufferGetPage(buf);
gistSplitByKey(r, page, itup, len, giststate, &v, 0);
/* form left and right vector */
- lvectup = (IndexTuple *) palloc(sizeof(IndexTuple) * (len + 1));
- rvectup = (IndexTuple *) palloc(sizeof(IndexTuple) * (len + 1));
+ lvectup = palloc_array(IndexTuple, len + 1);
+ rvectup = palloc_array(IndexTuple, len + 1);
for (i = 0; i < v.splitVector.spl_nleft; i++)
lvectup[i] = itup[v.splitVector.spl_left[i] - 1];
oldCxt = MemoryContextSwitchTo(scanCxt);
/* Create and fill in the GISTSTATE */
- giststate = (GISTSTATE *) palloc(sizeof(GISTSTATE));
+ giststate = palloc_object(GISTSTATE);
giststate->scanCxt = scanCxt;
giststate->tempCxt = scanCxt; /* caller must change this if needed */
/*
* Return statistics
*/
- result = (IndexBuildResult *) palloc(sizeof(IndexBuildResult));
+ result = palloc_object(IndexBuildResult);
result->heap_tuples = reltuples;
result->index_tuples = (double) buildstate.indtuples;
state->bulkstate = smgr_bulk_start_rel(state->indexrel, MAIN_FORKNUM);
/* Allocate a temporary buffer for the first leaf page batch. */
- levelstate = palloc0(sizeof(GistSortedBuildLevelState));
+ levelstate = palloc0_object(GistSortedBuildLevelState);
levelstate->pages[0] = palloc(BLCKSZ);
levelstate->parent = NULL;
gistinitpage(levelstate->pages[0], F_LEAF);
else
{
/* Create split layout from single page */
- dist = (SplitPageLayout *) palloc0(sizeof(SplitPageLayout));
+ dist = palloc0_object(SplitPageLayout);
union_tuple = gistunion(state->indexrel, itvec, vect_len,
state->giststate);
dist->itup = union_tuple;
parent = levelstate->parent;
if (parent == NULL)
{
- parent = palloc0(sizeof(GistSortedBuildLevelState));
+ parent = palloc0_object(GistSortedBuildLevelState);
parent->pages[0] = palloc(BLCKSZ);
parent->parent = NULL;
gistinitpage(parent->pages[0], 0);
/* Create an array of all the downlink tuples */
ndownlinks = list_length(splitinfo);
- downlinks = (IndexTuple *) palloc(sizeof(IndexTuple) * ndownlinks);
+ downlinks = palloc_array(IndexTuple, ndownlinks);
i = 0;
foreach(lc, splitinfo)
{
GISTBuildBuffers *gfbb;
HASHCTL hashCtl;
- gfbb = palloc(sizeof(GISTBuildBuffers));
+ gfbb = palloc_object(GISTBuildBuffers);
gfbb->pagesPerBuffer = pagesPerBuffer;
gfbb->levelStep = levelStep;
/* Initialize free page management. */
gfbb->nFreeBlocks = 0;
gfbb->freeBlocksLen = 32;
- gfbb->freeBlocks = (long *) palloc(gfbb->freeBlocksLen * sizeof(long));
+ gfbb->freeBlocks = palloc_array(long, gfbb->freeBlocksLen);
/*
* Current memory context will be used for all in-memory data structures
* buffers are inserted here when they are created.
*/
gfbb->buffersOnLevelsLen = 1;
- gfbb->buffersOnLevels = (List **) palloc(sizeof(List *) *
- gfbb->buffersOnLevelsLen);
+ gfbb->buffersOnLevels = palloc_array(List *, gfbb->buffersOnLevelsLen);
gfbb->buffersOnLevels[0] = NIL;
/*
* into main memory.
*/
gfbb->loadedBuffersLen = 32;
- gfbb->loadedBuffers = (GISTNodeBuffer **) palloc(gfbb->loadedBuffersLen *
- sizeof(GISTNodeBuffer *));
+ gfbb->loadedBuffers = palloc_array(GISTNodeBuffer *, gfbb->loadedBuffersLen);
gfbb->loadedBuffersCount = 0;
gfbb->rootlevel = maxLevel;
* Allocate memory for information about relocation buffers.
*/
splitPagesCount = list_length(splitinfo);
- relocationBuffersInfos =
- (RelocationBufferInfo *) palloc(sizeof(RelocationBufferInfo) *
- splitPagesCount);
+ relocationBuffersInfos = palloc_array(RelocationBufferInfo, splitPagesCount);
/*
* Fill relocation buffers information for node buffers of pages produced
*pageunion;
numranges = entryvec->n;
- pageunion = (BOX *) palloc(sizeof(BOX));
+ pageunion = palloc_object(BOX);
cur = DatumGetBoxP(entryvec->vector[0].key);
memcpy(pageunion, cur, sizeof(BOX));
v->spl_left[v->spl_nleft] = i;
if (unionL == NULL)
{
- unionL = (BOX *) palloc(sizeof(BOX));
+ unionL = palloc_object(BOX);
*unionL = *cur;
}
else
v->spl_right[v->spl_nright] = i;
if (unionR == NULL)
{
- unionR = (BOX *) palloc(sizeof(BOX));
+ unionR = palloc_object(BOX);
*unionR = *cur;
}
else
v->spl_nright = 0;
/* Allocate bounding boxes of left and right groups */
- leftBox = palloc0(sizeof(BOX));
- rightBox = palloc0(sizeof(BOX));
+ leftBox = palloc0_object(BOX);
+ rightBox = palloc0_object(BOX);
/*
* Allocate an array for "common entries" - entries which can be placed to
POLYGON *in = DatumGetPolygonP(entry->key);
BOX *r;
- r = (BOX *) palloc(sizeof(BOX));
+ r = palloc_object(BOX);
memcpy(r, &(in->boundbox), sizeof(BOX));
- retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page,
entry->offset, false);
CIRCLE *in = DatumGetCircleP(entry->key);
BOX *r;
- r = (BOX *) palloc(sizeof(BOX));
+ r = palloc_object(BOX);
r->high.x = float8_pl(in->center.x, in->radius);
r->low.x = float8_mi(in->center.x, in->radius);
r->high.y = float8_pl(in->center.y, in->radius);
r->low.y = float8_mi(in->center.y, in->radius);
- retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page,
entry->offset, false);
if (entry->leafkey) /* Point, actually */
{
- BOX *box = palloc(sizeof(BOX));
+ BOX *box = palloc_object(BOX);
Point *point = DatumGetPointP(entry->key);
- GISTENTRY *retval = palloc(sizeof(GISTENTRY));
+ GISTENTRY *retval = palloc_object(GISTENTRY);
box->high = box->low = *point;
Point *r;
GISTENTRY *retval;
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
- r = (Point *) palloc(sizeof(Point));
+ r = palloc_object(Point);
r->x = in->high.x;
r->y = in->high.y;
gistentryinit(*retval, PointerGetDatum(r),
oldCxt = MemoryContextSwitchTo(giststate->scanCxt);
/* initialize opaque data */
- so = (GISTScanOpaque) palloc0(sizeof(GISTScanOpaqueData));
+ so = palloc0_object(GISTScanOpaqueData);
so->giststate = giststate;
giststate->tempCxt = createTempGistContext();
so->queue = NULL;
so->qual_ok = true; /* in case there are zero keys */
if (scan->numberOfOrderBys > 0)
{
- scan->xs_orderbyvals = palloc0(sizeof(Datum) * scan->numberOfOrderBys);
- scan->xs_orderbynulls = palloc(sizeof(bool) * scan->numberOfOrderBys);
+ scan->xs_orderbyvals = palloc0_array(Datum, scan->numberOfOrderBys);
+ scan->xs_orderbynulls = palloc_array(bool, scan->numberOfOrderBys);
memset(scan->xs_orderbynulls, true, sizeof(bool) * scan->numberOfOrderBys);
}
int i,
cleanedLen = 0;
- cleanedItVec = (IndexTuple *) palloc(sizeof(IndexTuple) * gsvp->len);
+ cleanedItVec = palloc_array(IndexTuple, gsvp->len);
for (i = 0; i < gsvp->len; i++)
{
* Locate don't-care tuples, if any. If there are none, the split is
* optimal, so just fall out and return false.
*/
- v->spl_dontcare = (bool *) palloc0(sizeof(bool) * (entryvec->n + 1));
+ v->spl_dontcare = palloc0_array(bool, entryvec->n + 1);
NumDontCare = findDontCares(r, giststate, entryvec->vector, v, attno);
* call will overwrite that with its own result.
*/
backupSplit = v->splitVector;
- backupSplit.spl_left = (OffsetNumber *) palloc(sizeof(OffsetNumber) * len);
+ backupSplit.spl_left = palloc_array(OffsetNumber, len);
memcpy(backupSplit.spl_left, v->splitVector.spl_left, sizeof(OffsetNumber) * v->splitVector.spl_nleft);
- backupSplit.spl_right = (OffsetNumber *) palloc(sizeof(OffsetNumber) * len);
+ backupSplit.spl_right = palloc_array(OffsetNumber, len);
memcpy(backupSplit.spl_right, v->splitVector.spl_right, sizeof(OffsetNumber) * v->splitVector.spl_nright);
/* Recursively decide how to split the don't-care tuples */
maxoff = PageGetMaxOffsetNumber(page);
*len = maxoff;
- itvec = palloc(sizeof(IndexTuple) * maxoff);
+ itvec = palloc_array(IndexTuple, maxoff);
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
itvec[i - FirstOffsetNumber] = (IndexTuple) PageGetItem(page, PageGetItemId(page, i));
IndexTuple *
gistjoinvector(IndexTuple *itvec, int *len, IndexTuple *additvec, int addlen)
{
- itvec = (IndexTuple *) repalloc(itvec, sizeof(IndexTuple) * ((*len) + addlen));
+ itvec = repalloc_array(itvec, IndexTuple, (*len) + addlen);
memmove(&itvec[*len], additvec, sizeof(IndexTuple) * addlen);
*len += addlen;
return itvec;
{
/* allocate stats if first time through, else re-use existing struct */
if (stats == NULL)
- stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+ stats = palloc0_object(IndexBulkDeleteResult);
gistvacuumscan(info, stats, callback, callback_state);
*/
if (stats == NULL)
{
- stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+ stats = palloc0_object(IndexBulkDeleteResult);
gistvacuumscan(info, stats, NULL, NULL);
}
/*
* Return statistics
*/
- result = (IndexBuildResult *) palloc(sizeof(IndexBuildResult));
+ result = palloc_object(IndexBuildResult);
result->heap_tuples = reltuples;
result->index_tuples = buildstate.indtuples;
* entries.
*/
if (so->killedItems == NULL)
- so->killedItems = (int *)
- palloc(MaxIndexTuplesPerPage * sizeof(int));
+ so->killedItems = palloc_array(int, MaxIndexTuplesPerPage);
if (so->numKilled < MaxIndexTuplesPerPage)
so->killedItems[so->numKilled++] = so->currPos.itemIndex;
scan = RelationGetIndexScan(rel, nkeys, norderbys);
- so = (HashScanOpaque) palloc(sizeof(HashScanOpaqueData));
+ so = (HashScanOpaque) palloc_object(HashScanOpaqueData);
HashScanPosInvalidate(so->currPos);
so->hashso_bucket_buf = InvalidBuffer;
so->hashso_split_bucket_buf = InvalidBuffer;
/* return statistics */
if (stats == NULL)
- stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+ stats = palloc0_object(IndexBulkDeleteResult);
stats->estimated_count = false;
stats->num_index_tuples = num_index_tuples;
stats->tuples_removed += tuples_removed;
HSpool *
_h_spoolinit(Relation heap, Relation index, uint32 num_buckets)
{
- HSpool *hspool = (HSpool *) palloc0(sizeof(HSpool));
+ HSpool *hspool = palloc0_object(HSpool);
hspool->index = index;
*/
if (flags & SO_TYPE_BITMAPSCAN)
{
- BitmapHeapScanDesc bscan = palloc(sizeof(BitmapHeapScanDescData));
+ BitmapHeapScanDesc bscan = palloc_object(BitmapHeapScanDescData);
/*
* Bitmap Heap scans do not have any fields that a normal Heap Scan
scan = (HeapScanDesc) bscan;
}
else
- scan = (HeapScanDesc) palloc(sizeof(HeapScanDescData));
+ scan = (HeapScanDesc) palloc_object(HeapScanDescData);
scan->rs_base.rs_rd = relation;
scan->rs_base.rs_snapshot = snapshot;
* when doing a parallel scan.
*/
if (parallel_scan != NULL)
- scan->rs_parallelworkerdata = palloc(sizeof(ParallelBlockTableScanWorkerData));
+ scan->rs_parallelworkerdata = palloc_object(ParallelBlockTableScanWorkerData);
else
scan->rs_parallelworkerdata = NULL;
* initscan() and we don't want to allocate memory again
*/
if (nkeys > 0)
- scan->rs_base.rs_key = (ScanKey) palloc(sizeof(ScanKeyData) * nkeys);
+ scan->rs_base.rs_key = palloc_array(ScanKeyData, nkeys);
else
scan->rs_base.rs_key = NULL;
{
BulkInsertState bistate;
- bistate = (BulkInsertState) palloc(sizeof(BulkInsertStateData));
+ bistate = (BulkInsertState) palloc_object(BulkInsertStateData);
bistate->strategy = GetAccessStrategy(BAS_BULKWRITE);
bistate->current_buf = InvalidBuffer;
bistate->next_free = InvalidBlockNumber;
* even member XIDs >= OldestXmin often won't be kept by second pass.
*/
nnewmembers = 0;
- newmembers = palloc(sizeof(MultiXactMember) * nmembers);
+ newmembers = palloc_array(MultiXactMember, nmembers);
has_lockers = false;
update_xid = InvalidTransactionId;
update_committed = false;
Assert(delstate->ndeltids > 0);
/* Calculate per-heap-block count of TIDs */
- blockgroups = palloc(sizeof(IndexDeleteCounts) * delstate->ndeltids);
+ blockgroups = palloc_array(IndexDeleteCounts, delstate->ndeltids);
for (int i = 0; i < delstate->ndeltids; i++)
{
TM_IndexDelete *ideltid = &delstate->deltids[i];
static IndexFetchTableData *
heapam_index_fetch_begin(Relation rel)
{
- IndexFetchHeapData *hscan = palloc0(sizeof(IndexFetchHeapData));
+ IndexFetchHeapData *hscan = palloc0_object(IndexFetchHeapData);
hscan->xs_base.rel = rel;
hscan->xs_cbuf = InvalidBuffer;
/* Preallocate values/isnull arrays */
natts = newTupDesc->natts;
- values = (Datum *) palloc(natts * sizeof(Datum));
- isnull = (bool *) palloc(natts * sizeof(bool));
+ values = palloc_array(Datum, natts);
+ isnull = palloc_array(bool, natts);
/* Initialize the rewrite operation */
rwstate = begin_heap_rewrite(OldHeap, NewHeap, OldestXmin, *xid_cutoff,
old_cxt = MemoryContextSwitchTo(rw_cxt);
/* Create and fill in the state struct */
- state = palloc0(sizeof(RewriteStateData));
+ state = palloc0_object(RewriteStateData);
state->rs_old_rel = old_heap;
state->rs_new_rel = new_heap;
* of each rel. It's convenient for code in lazy_scan_heap to always use
* these temp copies.
*/
- vacrel = (LVRelState *) palloc0(sizeof(LVRelState));
+ vacrel = palloc0_object(LVRelState);
vacrel->dbname = get_database_name(MyDatabaseId);
vacrel->relnamespace = get_namespace_name(RelationGetNamespace(rel));
vacrel->relname = pstrdup(RelationGetRelationName(rel));
if (instrument && vacrel->nindexes > 0)
{
/* Copy index names used by instrumentation (not error reporting) */
- indnames = palloc(sizeof(char *) * vacrel->nindexes);
+ indnames = palloc_array(char *, vacrel->nindexes);
for (int i = 0; i < vacrel->nindexes; i++)
indnames[i] = pstrdup(RelationGetRelationName(vacrel->indrels[i]));
}
* locally.
*/
- dead_items_info = (VacDeadItemsInfo *) palloc(sizeof(VacDeadItemsInfo));
+ dead_items_info = palloc_object(VacDeadItemsInfo);
dead_items_info->max_bytes = vac_work_mem * (Size) 1024;
dead_items_info->num_items = 0;
vacrel->dead_items_info = dead_items_info;
}
/* Time for a new group */
- thisgroup = (OpFamilyOpFuncGroup *) palloc(sizeof(OpFamilyOpFuncGroup));
+ thisgroup = palloc_object(OpFamilyOpFuncGroup);
if (oprform &&
(!procform ||
(oprform->amoplefttype < procform->amproclefttype ||
{
IndexScanDesc scan;
- scan = (IndexScanDesc) palloc(sizeof(IndexScanDescData));
+ scan = palloc_object(IndexScanDescData);
scan->heapRelation = NULL; /* may be set later */
scan->xs_heapfetch = NULL;
* We allocate key workspace here, but it won't get filled until amrescan.
*/
if (nkeys > 0)
- scan->keyData = (ScanKey) palloc(sizeof(ScanKeyData) * nkeys);
+ scan->keyData = palloc_array(ScanKeyData, nkeys);
else
scan->keyData = NULL;
if (norderbys > 0)
- scan->orderByData = (ScanKey) palloc(sizeof(ScanKeyData) * norderbys);
+ scan->orderByData = palloc_array(ScanKeyData, norderbys);
else
scan->orderByData = NULL;
delstate.bottomup = false;
delstate.bottomupfreespace = 0;
delstate.ndeltids = 0;
- delstate.deltids = palloc(nitems * sizeof(TM_IndexDelete));
- delstate.status = palloc(nitems * sizeof(TM_IndexStatus));
+ delstate.deltids = palloc_array(TM_IndexDelete, nitems);
+ delstate.status = palloc_array(TM_IndexStatus, nitems);
/* identify what the index tuples about to be deleted point to */
for (int i = 0; i < nitems; i++)
else
irel = NULL;
- sysscan = (SysScanDesc) palloc(sizeof(SysScanDescData));
+ sysscan = palloc_object(SysScanDescData);
sysscan->heap_rel = heapRelation;
sysscan->irel = irel;
elog(WARNING, "using index \"%s\" despite IgnoreSystemIndexes",
RelationGetRelationName(indexRelation));
- sysscan = (SysScanDesc) palloc(sizeof(SysScanDescData));
+ sysscan = palloc_object(SysScanDescData);
sysscan->heap_rel = heapRelation;
sysscan->irel = indexRelation;
* That ought to leave us with a good split point when pages full of
* duplicates can be split several times.
*/
- state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+ state = palloc_object(BTDedupStateData);
state->deduplicate = true;
state->nmaxitems = 0;
state->maxpostingsize = Min(BTMaxItemSize / 2, INDEX_SIZE_MASK);
newitemsz += sizeof(ItemIdData);
/* Initialize deduplication state */
- state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+ state = palloc_object(BTDedupStateData);
state->deduplicate = true;
state->nmaxitems = 0;
state->maxpostingsize = BLCKSZ; /* We're not really deduplicating */
delstate.bottomup = true;
delstate.bottomupfreespace = Max(BLCKSZ / 16, newitemsz);
delstate.ndeltids = 0;
- delstate.deltids = palloc(MaxTIDsPerBTreePage * sizeof(TM_IndexDelete));
- delstate.status = palloc(MaxTIDsPerBTreePage * sizeof(TM_IndexStatus));
+ delstate.deltids = palloc_array(TM_IndexDelete, MaxTIDsPerBTreePage);
+ delstate.status = palloc_array(TM_IndexStatus, MaxTIDsPerBTreePage);
minoff = P_FIRSTDATAKEY(opaque);
maxoff = PageGetMaxOffsetNumber(page);
*/
spacentids = ndeletable + 1;
ntids = 0;
- tidblocks = (BlockNumber *) palloc(sizeof(BlockNumber) * spacentids);
+ tidblocks = palloc_array(BlockNumber, spacentids);
/*
* First add the table block for the incoming newitem. This is the one
vstate->maxbufsize = (int) maxbufsize;
/* Allocate buffer, indicate that there are currently 0 pending pages */
- vstate->pendingpages = palloc(sizeof(BTPendingFSM) * vstate->bufsize);
+ vstate->pendingpages = palloc_array(BTPendingFSM, vstate->bufsize);
vstate->npendingpages = 0;
}
* just forget any excess entries.
*/
if (so->killedItems == NULL)
- so->killedItems = (int *)
- palloc(MaxTIDsPerBTreePage * sizeof(int));
+ so->killedItems = palloc_array(int, MaxTIDsPerBTreePage);
if (so->numKilled < MaxTIDsPerBTreePage)
so->killedItems[so->numKilled++] = so->currPos.itemIndex;
}
scan = RelationGetIndexScan(rel, nkeys, norderbys);
/* allocate private workspace */
- so = (BTScanOpaque) palloc(sizeof(BTScanOpaqueData));
+ so = palloc_object(BTScanOpaqueData);
BTScanPosInvalidate(so->currPos);
BTScanPosInvalidate(so->markPos);
if (scan->numberOfKeys > 0)
/* allocate stats if first time through, else re-use existing struct */
if (stats == NULL)
- stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+ stats = palloc0_object(IndexBulkDeleteResult);
/* Establish the vacuum cycle ID to use for this scan */
/* The ENSURE stuff ensures we clean up shared memory on failure */
* We handle the problem by making num_index_tuples an estimate in
* cleanup-only case.
*/
- stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+ stats = palloc0_object(IndexBulkDeleteResult);
btvacuumscan(info, stats, NULL, NULL, 0);
stats->estimated_count = true;
}
* page one level down, it usually ends up inserting a new pivot
* tuple/downlink immediately after the location recorded here.
*/
- new_stack = (BTStack) palloc(sizeof(BTStackData));
+ new_stack = (BTStack) palloc_object(BTStackData);
new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
new_stack->bts_offset = offnum;
new_stack->bts_parent = stack_in;
if (buildstate.btleader)
_bt_end_parallel(buildstate.btleader);
- result = (IndexBuildResult *) palloc(sizeof(IndexBuildResult));
+ result = palloc_object(IndexBuildResult);
result->heap_tuples = reltuples;
result->index_tuples = buildstate.indtuples;
_bt_spools_heapscan(Relation heap, Relation index, BTBuildState *buildstate,
IndexInfo *indexInfo)
{
- BTSpool *btspool = (BTSpool *) palloc0(sizeof(BTSpool));
+ BTSpool *btspool = palloc0_object(BTSpool);
SortCoordinate coordinate = NULL;
double reltuples = 0;
*/
if (buildstate->btleader)
{
- coordinate = (SortCoordinate) palloc0(sizeof(SortCoordinateData));
+ coordinate = palloc0_object(SortCoordinateData);
coordinate->isWorker = false;
coordinate->nParticipants =
buildstate->btleader->nparticipanttuplesorts;
*/
if (indexInfo->ii_Unique)
{
- BTSpool *btspool2 = (BTSpool *) palloc0(sizeof(BTSpool));
+ BTSpool *btspool2 = palloc0_object(BTSpool);
SortCoordinate coordinate2 = NULL;
/* Initialize secondary spool */
* tuplesort_begin_index_btree() about the basic high level
* coordination of a parallel sort.
*/
- coordinate2 = (SortCoordinate) palloc0(sizeof(SortCoordinateData));
+ coordinate2 = palloc0_object(SortCoordinateData);
coordinate2->isWorker = false;
coordinate2->nParticipants =
buildstate->btleader->nparticipanttuplesorts;
static BTPageState *
_bt_pagestate(BTWriteState *wstate, uint32 level)
{
- BTPageState *state = (BTPageState *) palloc0(sizeof(BTPageState));
+ BTPageState *state = palloc0_object(BTPageState);
/* create initial page for level */
state->btps_buf = _bt_blnewpage(wstate, level);
if (last_off == P_HIKEY)
{
Assert(state->btps_lowkey == NULL);
- state->btps_lowkey = palloc0(sizeof(IndexTupleData));
+ state->btps_lowkey = palloc0_object(IndexTupleData);
state->btps_lowkey->t_info = sizeof(IndexTupleData);
BTreeTupleSetNAtts(state->btps_lowkey, 0, false);
}
itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
/* Prepare SortSupport data for each column */
- sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+ sortKeys = palloc0_array(SortSupportData, keysz);
for (i = 0; i < keysz; i++)
{
/* merge is unnecessary, deduplicate into posting lists */
BTDedupState dstate;
- dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+ dstate = palloc_object(BTDedupStateData);
dstate->deduplicate = true; /* unused */
dstate->nmaxitems = 0; /* unused */
dstate->maxpostingsize = 0; /* set later */
Sharedsort *sharedsort;
Sharedsort *sharedsort2;
BTSpool *btspool = buildstate->spool;
- BTLeader *btleader = (BTLeader *) palloc0(sizeof(BTLeader));
+ BTLeader *btleader = palloc0_object(BTLeader);
WalUsage *walusage;
BufferUsage *bufferusage;
bool leaderparticipates = true;
int sortmem;
/* Allocate memory and initialize private spool */
- leaderworker = (BTSpool *) palloc0(sizeof(BTSpool));
+ leaderworker = palloc0_object(BTSpool);
leaderworker->heap = buildstate->spool->heap;
leaderworker->index = buildstate->spool->index;
leaderworker->isunique = buildstate->spool->isunique;
else
{
/* Allocate memory for worker's own private secondary spool */
- leaderworker2 = (BTSpool *) palloc0(sizeof(BTSpool));
+ leaderworker2 = palloc0_object(BTSpool);
/* Initialize worker's own secondary spool */
leaderworker2->heap = leaderworker->heap;
indexRel = index_open(btshared->indexrelid, indexLockmode);
/* Initialize worker's own spool */
- btspool = (BTSpool *) palloc0(sizeof(BTSpool));
+ btspool = palloc0_object(BTSpool);
btspool->heap = heapRel;
btspool->index = indexRel;
btspool->isunique = btshared->isunique;
else
{
/* Allocate memory for worker's own private secondary spool */
- btspool2 = (BTSpool *) palloc0(sizeof(BTSpool));
+ btspool2 = palloc0_object(BTSpool);
/* Initialize worker's own secondary spool */
btspool2->heap = btspool->heap;
IndexInfo *indexInfo;
/* Initialize local tuplesort coordination state */
- coordinate = palloc0(sizeof(SortCoordinateData));
+ coordinate = palloc0_object(SortCoordinateData);
coordinate->isWorker = true;
coordinate->nParticipants = -1;
coordinate->sharedsort = sharedsort;
* worker). Worker processes are generally permitted to allocate
* work_mem independently.
*/
- coordinate2 = palloc0(sizeof(SortCoordinateData));
+ coordinate2 = palloc0_object(SortCoordinateData);
coordinate2->isWorker = true;
coordinate2->nParticipants = -1;
coordinate2->sharedsort = sharedsort2;
* between tuples will be legal).
*/
state.maxsplits = maxoff;
- state.splits = palloc(sizeof(SplitPoint) * state.maxsplits);
+ state.splits = palloc_array(SplitPoint, state.maxsplits);
state.nsplits = 0;
/*
BTDedupInterval *intervals;
Page newpage;
- state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+ state = palloc_object(BTDedupStateData);
state->deduplicate = true; /* unused */
state->nmaxitems = 0; /* unused */
/* Conservatively use larger maxpostingsize than primary */
else if (offset > tuple->nNodes)
elog(ERROR, "invalid offset for adding node to SPGiST inner tuple");
- nodes = palloc(sizeof(SpGistNodeTuple) * (tuple->nNodes + 1));
+ nodes = palloc_array(SpGistNodeTuple, tuple->nNodes + 1);
SGITITERATE(tuple, i, node)
{
if (i < offset)
/* Locate the tuples to be moved, and count up the space needed */
i = PageGetMaxOffsetNumber(current->page);
- toDelete = (OffsetNumber *) palloc(sizeof(OffsetNumber) * i);
- toInsert = (OffsetNumber *) palloc(sizeof(OffsetNumber) * (i + 1));
+ toDelete = palloc_array(OffsetNumber, i);
+ toInsert = palloc_array(OffsetNumber, i + 1);
size = newLeafTuple->size + sizeof(ItemIdData);
{
Datum theLabel = out->nodeLabels[theNode];
- out->nodeLabels = (Datum *) palloc(sizeof(Datum) * out->nNodes);
+ out->nodeLabels = palloc_array(Datum, out->nNodes);
for (i = 0; i < out->nNodes; i++)
out->nodeLabels[i] = theLabel;
}
*/
max = PageGetMaxOffsetNumber(current->page);
n = max + 1;
- in.datums = (Datum *) palloc(sizeof(Datum) * n);
- toDelete = (OffsetNumber *) palloc(sizeof(OffsetNumber) * n);
- toInsert = (OffsetNumber *) palloc(sizeof(OffsetNumber) * n);
- oldLeafs = (SpGistLeafTuple *) palloc(sizeof(SpGistLeafTuple) * n);
- newLeafs = (SpGistLeafTuple *) palloc(sizeof(SpGistLeafTuple) * n);
- leafPageSelect = (uint8 *) palloc(sizeof(uint8) * n);
+ in.datums = palloc_array(Datum, n);
+ toDelete = palloc_array(OffsetNumber, n);
+ toInsert = palloc_array(OffsetNumber, n);
+ oldLeafs = palloc_array(SpGistLeafTuple, n);
+ newLeafs = palloc_array(SpGistLeafTuple, n);
+ leafPageSelect = palloc_array(uint8, n);
STORE_STATE(state, xlrec.stateSrc);
out.hasPrefix = false;
out.nNodes = 1;
out.nodeLabels = NULL;
- out.mapTuplesToNodes = palloc0(sizeof(int) * in.nTuples);
+ out.mapTuplesToNodes = palloc0_array(int, in.nTuples);
/*
* Form new leaf tuples and count up the total space needed.
* out.nNodes with a value larger than the number of tuples on the input
* page, we can't allocate these arrays before here.
*/
- nodes = (SpGistNodeTuple *) palloc(sizeof(SpGistNodeTuple) * out.nNodes);
- leafSizes = (int *) palloc0(sizeof(int) * out.nNodes);
+ nodes = palloc_array(SpGistNodeTuple, out.nNodes);
+ leafSizes = palloc0_array(int, out.nNodes);
/*
* Form nodes of inner tuple and inner tuple itself
* do so, even if totalLeafSizes is less than the available space,
* because we can't split a group across pages.
*/
- nodePageSelect = (uint8 *) palloc(sizeof(uint8) * out.nNodes);
+ nodePageSelect = palloc_array(uint8, out.nNodes);
curspace = currentFreeSpace;
newspace = PageGetExactFreeSpace(BufferGetPage(newLeafBuffer));
* Construct new prefix tuple with requested number of nodes. We'll fill
* in the childNodeN'th node's downlink below.
*/
- nodes = (SpGistNodeTuple *) palloc(sizeof(SpGistNodeTuple) *
- out->result.splitTuple.prefixNNodes);
+ nodes = palloc_array(SpGistNodeTuple, out->result.splitTuple.prefixNNodes);
for (i = 0; i < out->result.splitTuple.prefixNNodes; i++)
{
* same node datums, but with the prefix specified by the picksplit
* function.
*/
- nodes = palloc(sizeof(SpGistNodeTuple) * innerTuple->nNodes);
+ nodes = palloc_array(SpGistNodeTuple, innerTuple->nNodes);
SGITITERATE(innerTuple, i, node)
{
nodes[i] = node;
true);
}
- result = (IndexBuildResult *) palloc0(sizeof(IndexBuildResult));
+ result = palloc0_object(IndexBuildResult);
result->heap_tuples = reltuples;
result->index_tuples = buildstate.indtuples;
SortedPoint *sorted;
double coord;
- sorted = palloc(sizeof(*sorted) * in->nTuples);
+ sorted = palloc_array(SortedPoint, in->nTuples);
for (i = 0; i < in->nTuples; i++)
{
sorted[i].p = DatumGetPointP(in->datums[i]);
out->nNodes = 2;
out->nodeLabels = NULL; /* we don't need node labels */
- out->mapTuplesToNodes = palloc(sizeof(int) * in->nTuples);
- out->leafTupleDatums = palloc(sizeof(Datum) * in->nTuples);
+ out->mapTuplesToNodes = palloc_array(int, in->nTuples);
+ out->leafTupleDatums = palloc_array(Datum, in->nTuples);
/*
* Note: points that have coordinates exactly equal to coord may get
if (!which)
PG_RETURN_VOID();
- out->nodeNumbers = (int *) palloc(sizeof(int) * 2);
+ out->nodeNumbers = palloc_array(int, 2);
/*
* When ordering scan keys are specified, we've to calculate distance for
BOX infArea;
BOX *area;
- out->distances = (double **) palloc(sizeof(double *) * in->nNodes);
- out->traversalValues = (void **) palloc(sizeof(void *) * in->nNodes);
+ out->distances = palloc_array(double *, in->nNodes);
+ out->traversalValues = palloc_array(void *, in->nNodes);
if (in->level == 0)
{
}
/* Set up level increments, too */
- out->levelAdds = (int *) palloc(sizeof(int) * 2);
+ out->levelAdds = palloc_array(int, 2);
out->levelAdds[0] = 1;
out->levelAdds[1] = 1;
ScanKey orderbys, int norderbys)
{
int sk_num;
- double *distances = (double *) palloc(norderbys * sizeof(double)),
+ double *distances = palloc_array(double, norderbys),
*distance = distances;
for (sk_num = 0; sk_num < norderbys; ++sk_num, ++orderbys, ++distance)
BOX *
box_copy(BOX *orig)
{
- BOX *result = palloc(sizeof(BOX));
+ BOX *result = palloc_object(BOX);
*result = *orig;
return result;
static BOX *
getQuadrantArea(BOX *bbox, Point *centroid, int quadrant)
{
- BOX *result = (BOX *) palloc(sizeof(BOX));
+ BOX *result = palloc_object(BOX);
switch (quadrant)
{
/* Use the median values of x and y as the centroid point */
Point **sorted;
- sorted = palloc(sizeof(*sorted) * in->nTuples);
+ sorted = palloc_array(Point *, in->nTuples);
for (i = 0; i < in->nTuples; i++)
sorted[i] = DatumGetPointP(in->datums[i]);
- centroid = palloc(sizeof(*centroid));
+ centroid = palloc_object(Point);
qsort(sorted, in->nTuples, sizeof(*sorted), x_cmp);
centroid->x = sorted[in->nTuples >> 1]->x;
centroid->y = sorted[in->nTuples >> 1]->y;
#else
/* Use the average values of x and y as the centroid point */
- centroid = palloc0(sizeof(*centroid));
+ centroid = palloc0_object(Point);
for (i = 0; i < in->nTuples; i++)
{
out->nNodes = 4;
out->nodeLabels = NULL; /* we don't need node labels */
- out->mapTuplesToNodes = palloc(sizeof(int) * in->nTuples);
- out->leafTupleDatums = palloc(sizeof(Datum) * in->nTuples);
+ out->mapTuplesToNodes = palloc_array(int, in->nTuples);
+ out->leafTupleDatums = palloc_array(Datum, in->nTuples);
for (i = 0; i < in->nTuples; i++)
{
*/
if (in->norderbys > 0)
{
- out->distances = (double **) palloc(sizeof(double *) * in->nNodes);
- out->traversalValues = (void **) palloc(sizeof(void *) * in->nNodes);
+ out->distances = palloc_array(double *, in->nNodes);
+ out->traversalValues = palloc_array(void *, in->nNodes);
if (in->level == 0)
{
{
/* Report that all nodes should be visited */
out->nNodes = in->nNodes;
- out->nodeNumbers = (int *) palloc(sizeof(int) * in->nNodes);
+ out->nodeNumbers = palloc_array(int, in->nNodes);
for (i = 0; i < in->nNodes; i++)
{
out->nodeNumbers[i] = i;
break; /* no need to consider remaining conditions */
}
- out->levelAdds = palloc(sizeof(int) * 4);
+ out->levelAdds = palloc_array(int, 4);
for (i = 0; i < 4; ++i)
out->levelAdds[i] = 1;
/* We must descend into the quadrant(s) identified by which */
- out->nodeNumbers = (int *) palloc(sizeof(int) * 4);
+ out->nodeNumbers = palloc_array(int, 4);
out->nNodes = 0;
for (i = 1; i <= 4; i++)
scan = RelationGetIndexScan(rel, keysz, orderbysz);
- so = (SpGistScanOpaque) palloc0(sizeof(SpGistScanOpaqueData));
+ so = palloc0_object(SpGistScanOpaqueData);
if (keysz > 0)
- so->keyData = (ScanKey) palloc(sizeof(ScanKeyData) * keysz);
+ so->keyData = palloc_array(ScanKeyData, keysz);
else
so->keyData = NULL;
initSpGistState(&so->state, scan->indexRelation);
if (scan->numberOfOrderBys > 0)
{
/* This will be filled in spgrescan, but allocate the space here */
- so->orderByTypes = (Oid *)
- palloc(sizeof(Oid) * scan->numberOfOrderBys);
- so->nonNullOrderByOffsets = (int *)
- palloc(sizeof(int) * scan->numberOfOrderBys);
+ so->orderByTypes = palloc_array(Oid, scan->numberOfOrderBys);
+ so->nonNullOrderByOffsets = palloc_array(int, scan->numberOfOrderBys);
/* These arrays have constant contents, so we can fill them now */
- so->zeroDistances = (double *)
- palloc(sizeof(double) * scan->numberOfOrderBys);
- so->infDistances = (double *)
- palloc(sizeof(double) * scan->numberOfOrderBys);
+ so->zeroDistances = palloc_array(double, scan->numberOfOrderBys);
+ so->infDistances = palloc_array(double, scan->numberOfOrderBys);
for (i = 0; i < scan->numberOfOrderBys; i++)
{
so->infDistances[i] = get_float8_infinity();
}
- scan->xs_orderbyvals = (Datum *)
- palloc0(sizeof(Datum) * scan->numberOfOrderBys);
- scan->xs_orderbynulls = (bool *)
- palloc(sizeof(bool) * scan->numberOfOrderBys);
+ scan->xs_orderbyvals = palloc0_array(Datum, scan->numberOfOrderBys);
+ scan->xs_orderbynulls = palloc_array(bool, scan->numberOfOrderBys);
memset(scan->xs_orderbynulls, true,
sizeof(bool) * scan->numberOfOrderBys);
}
{
/* force all children to be visited */
out.nNodes = nNodes;
- out.nodeNumbers = (int *) palloc(sizeof(int) * nNodes);
+ out.nodeNumbers = palloc_array(int, nNodes);
for (i = 0; i < nNodes; i++)
out.nodeNumbers[i] = i;
}
{
/* collect node pointers */
SpGistNodeTuple node;
- SpGistNodeTuple *nodes = (SpGistNodeTuple *) palloc(sizeof(SpGistNodeTuple) * nNodes);
+ SpGistNodeTuple *nodes = palloc_array(SpGistNodeTuple, nNodes);
SGITITERATE(innerTuple, i, node)
{
so->distances[so->nPtrs] = NULL;
else
{
- IndexOrderByDistance *distances =
- palloc(sizeof(distances[0]) * so->numberOfOrderBys);
+ IndexOrderByDistance *distances = palloc_array(IndexOrderByDistance,
+ so->numberOfOrderBys);
int i;
for (i = 0; i < so->numberOfOrderBys; i++)
formTextDatum(prefixStr, commonLen);
}
out->result.splitTuple.prefixNNodes = 1;
- out->result.splitTuple.prefixNodeLabels =
- (Datum *) palloc(sizeof(Datum));
+ out->result.splitTuple.prefixNodeLabels = palloc_object(Datum);
out->result.splitTuple.prefixNodeLabels[0] =
Int16GetDatum(*(unsigned char *) (prefixStr + commonLen));
out->result.splitTuple.prefixHasPrefix = in->hasPrefix;
out->result.splitTuple.prefixPrefixDatum = in->prefixDatum;
out->result.splitTuple.prefixNNodes = 1;
- out->result.splitTuple.prefixNodeLabels = (Datum *) palloc(sizeof(Datum));
+ out->result.splitTuple.prefixNodeLabels = palloc_object(Datum);
out->result.splitTuple.prefixNodeLabels[0] = Int16GetDatum(-2);
out->result.splitTuple.childNodeN = 0;
out->result.splitTuple.postfixHasPrefix = false;
}
/* Extract the node label (first non-common byte) from each value */
- nodes = (spgNodePtr *) palloc(sizeof(spgNodePtr) * in->nTuples);
+ nodes = palloc_array(spgNodePtr, in->nTuples);
for (i = 0; i < in->nTuples; i++)
{
/* And emit results */
out->nNodes = 0;
- out->nodeLabels = (Datum *) palloc(sizeof(Datum) * in->nTuples);
- out->mapTuplesToNodes = (int *) palloc(sizeof(int) * in->nTuples);
- out->leafTupleDatums = (Datum *) palloc(sizeof(Datum) * in->nTuples);
+ out->nodeLabels = palloc_array(Datum, in->nTuples);
+ out->mapTuplesToNodes = palloc_array(int, in->nTuples);
+ out->leafTupleDatums = palloc_array(Datum, in->nTuples);
for (i = 0; i < in->nTuples; i++)
{
* and see if it's consistent with the query. If so, emit an entry into
* the output arrays.
*/
- out->nodeNumbers = (int *) palloc(sizeof(int) * in->nNodes);
- out->levelAdds = (int *) palloc(sizeof(int) * in->nNodes);
- out->reconstructedValues = (Datum *) palloc(sizeof(Datum) * in->nNodes);
+ out->nodeNumbers = palloc_array(int, in->nNodes);
+ out->levelAdds = palloc_array(int, in->nNodes);
+ out->reconstructedValues = palloc_array(Datum, in->nNodes);
out->nNodes = 0;
for (i = 0; i < in->nNodes; i++)
}
else
{
- nodeLabels = (Datum *) palloc(sizeof(Datum) * innerTuple->nNodes);
+ nodeLabels = palloc_array(Datum, innerTuple->nNodes);
SGITITERATE(innerTuple, i, node)
{
if (IndexTupleHasNulls(node))
listLink = &pitem->next;
}
/* not there, so append new entry */
- pitem = (spgVacPendingItem *) palloc(sizeof(spgVacPendingItem));
+ pitem = palloc_object(spgVacPendingItem);
pitem->tid = *tid;
pitem->done = false;
pitem->next = NULL;
/* allocate stats if first time through, else re-use existing struct */
if (stats == NULL)
- stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+ stats = palloc0_object(IndexBulkDeleteResult);
bds.info = info;
bds.stats = stats;
bds.callback = callback;
*/
if (stats == NULL)
{
- stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+ stats = palloc0_object(IndexBulkDeleteResult);
bds.info = info;
bds.stats = stats;
bds.callback = dummy_callback;
int max = PageGetMaxOffsetNumber(page);
OffsetNumber *toDelete;
- toDelete = palloc(sizeof(OffsetNumber) * max);
+ toDelete = palloc_array(OffsetNumber, max);
for (i = xldata->firstPlaceholder; i <= max; i++)
toDelete[i - xldata->firstPlaceholder] = i;
static void
system_initsamplescan(SampleScanState *node, int eflags)
{
- node->tsm_state = palloc0(sizeof(SystemSamplerData));
+ node->tsm_state = palloc0_object(SystemSamplerData);
}
/*
* Note we have the same race condition here as above: j could be 0 at the
* end of the loop.
*/
- newMembers = (MultiXactMember *)
- palloc(sizeof(MultiXactMember) * (nmembers + 1));
+ newMembers = palloc_array(MultiXactMember, nmembers + 1);
for (i = 0, j = 0; i < nmembers; i++)
{
oldcontext = MemoryContextSwitchTo(TopTransactionContext);
/* Initialize a new ParallelContext. */
- pcxt = palloc0(sizeof(ParallelContext));
+ pcxt = palloc0_object(ParallelContext);
pcxt->subid = GetCurrentSubTransactionId();
pcxt->nworkers = nworkers;
pcxt->nworkers_to_launch = nworkers;
clientconninfospace);
/* Allocate space for worker information. */
- pcxt->worker = palloc0(sizeof(ParallelWorkerInfo) * pcxt->nworkers);
+ pcxt->worker = palloc0_array(ParallelWorkerInfo, pcxt->nworkers);
/*
* Establish error queues in dynamic shared memory.
*/
if (pcxt->nworkers_launched > 0)
{
- pcxt->known_attached_workers =
- palloc0(sizeof(bool) * pcxt->nworkers_launched);
+ pcxt->known_attached_workers = palloc0_array(bool, pcxt->nworkers_launched);
pcxt->nknown_attached_workers = 0;
}
/* Timeline 1 does not have a history file, so no need to check */
if (targetTLI == 1)
{
- entry = (TimeLineHistoryEntry *) palloc(sizeof(TimeLineHistoryEntry));
+ entry = palloc_object(TimeLineHistoryEntry);
entry->tli = targetTLI;
entry->begin = entry->end = InvalidXLogRecPtr;
return list_make1(entry);
(errcode_for_file_access(),
errmsg("could not open file \"%s\": %m", path)));
/* Not there, so assume no parents */
- entry = (TimeLineHistoryEntry *) palloc(sizeof(TimeLineHistoryEntry));
+ entry = palloc_object(TimeLineHistoryEntry);
entry->tli = targetTLI;
entry->begin = entry->end = InvalidXLogRecPtr;
return list_make1(entry);
lasttli = tli;
- entry = (TimeLineHistoryEntry *) palloc(sizeof(TimeLineHistoryEntry));
+ entry = palloc_object(TimeLineHistoryEntry);
entry->tli = tli;
entry->begin = prevend;
entry->end = ((uint64) (switchpoint_hi)) << 32 | (uint64) switchpoint_lo;
* Create one more entry for the "tip" of the timeline, which has no entry
* in the history file.
*/
- entry = (TimeLineHistoryEntry *) palloc(sizeof(TimeLineHistoryEntry));
+ entry = palloc_object(TimeLineHistoryEntry);
entry->tli = targetTLI;
entry->begin = prevend;
entry->end = InvalidXLogRecPtr;
}
num = TwoPhaseState->numPrepXacts;
- array = (GlobalTransaction) palloc(sizeof(GlobalTransactionData) * num);
+ array = palloc_array(GlobalTransactionData, num);
*gxacts = array;
for (i = 0; i < num; i++)
memcpy(array + i, TwoPhaseState->prepXacts[i],
* Collect all the 2PC status information that we will format and send
* out as a result set.
*/
- status = (Working_State *) palloc(sizeof(Working_State));
+ status = palloc_object(Working_State);
funcctx->user_fctx = status;
status->ngxacts = GetPreparedTransactionList(&status->array);
if (padlen > records.bytes_free)
{
- records.tail->next = palloc0(sizeof(StateFileChunk));
+ records.tail->next = palloc0_object(StateFileChunk);
records.tail = records.tail->next;
records.tail->len = 0;
records.tail->next = NULL;
SharedInvalidationMessage *invalmsgs;
/* Initialize linked list */
- records.head = palloc0(sizeof(StateFileChunk));
+ records.head = palloc0_object(StateFileChunk);
records.head->len = 0;
records.head->next = NULL;
if (len != NULL)
*len = XLogRecGetDataLen(xlogreader);
- *buf = palloc(sizeof(char) * XLogRecGetDataLen(xlogreader));
+ *buf = palloc_array(char, XLogRecGetDataLen(xlogreader));
memcpy(*buf, XLogRecGetData(xlogreader), sizeof(char) * XLogRecGetDataLen(xlogreader));
XLogReaderFree(xlogreader);
TransactionState *parents;
size_t parentOffset = 0;
- parents = palloc(sizeof(TransactionState) * s->nestingLevel);
+ parents = palloc_array(TransactionState, s->nestingLevel);
while (p != NULL && !FullTransactionIdIsValid(p->fullTransactionId))
{
parents[parentOffset++] = p;
LocalProcessControlFile(bool reset)
{
Assert(reset || ControlFile == NULL);
- ControlFile = palloc(sizeof(ControlFileData));
+ ControlFile = palloc_object(ControlFileData);
ReadControlFile();
}
continue;
}
- ti = palloc(sizeof(tablespaceinfo));
+ ti = palloc_object(tablespaceinfo);
ti->oid = tsoid;
ti->path = pstrdup(linkpath);
ti->rpath = relpath;
}
oldcontext = MemoryContextSwitchTo(backupcontext);
- backup_state = (BackupState *) palloc0(sizeof(BackupState));
+ backup_state = palloc0_object(BackupState);
tablespace_map = makeStringInfo();
MemoryContextSwitchTo(oldcontext);
XLogPrefetcher *prefetcher;
HASHCTL ctl;
- prefetcher = palloc0(sizeof(XLogPrefetcher));
+ prefetcher = palloc0_object(XLogPrefetcher);
prefetcher->reader = reader;
ctl.keysize = sizeof(RelFileLocator);
* Set the WAL reading processor now, as it will be needed when reading
* the checkpoint record required (backup_label or not).
*/
- private = palloc0(sizeof(XLogPageReadPrivate));
+ private = palloc0_object(XLogPageReadPrivate);
xlogreader =
XLogReaderAllocate(wal_segment_size, NULL,
XL_ROUTINE(.page_read = &XLogPageRead,
errmsg("invalid data in file \"%s\"", TABLESPACE_MAP)));
str[n++] = '\0';
- ti = palloc0(sizeof(tablespaceinfo));
+ ti = palloc0_object(tablespaceinfo);
errno = 0;
ti->oid = strtoul(str, &endp, 10);
if (*endp != '\0' || errno == EINVAL || errno == ERANGE)
EndOfWalRecoveryInfo *
FinishWalRecovery(void)
{
- EndOfWalRecoveryInfo *result = palloc(sizeof(EndOfWalRecoveryInfo));
+ EndOfWalRecoveryInfo *result = palloc_object(EndOfWalRecoveryInfo);
XLogRecPtr lastRec;
TimeLineID lastRecTLI;
XLogRecPtr endOfLog;
Relation rel;
/* Allocate the Relation struct and all related space in one block. */
- fakeentry = palloc0(sizeof(FakeRelCacheEntryData));
+ fakeentry = palloc0_object(FakeRelCacheEntryData);
rel = (Relation) fakeentry;
rel->rd_rel = &fakeentry->pgc;
total_checksum_failures = 0;
/* Allocate backup related variables. */
- backup_state = (BackupState *) palloc0(sizeof(BackupState));
+ backup_state = palloc0_object(BackupState);
initStringInfo(&tablespace_map);
basebackup_progress_wait_checkpoint();
PrepareForIncrementalBackup(ib, backup_state);
/* Add a node for the base directory at the end */
- newti = palloc0(sizeof(tablespaceinfo));
+ newti = palloc0_object(tablespaceinfo);
newti->size = -1;
state.tablespaces = lappend(state.tablespaces, newti);
* But we don't need it at all if this is not an incremental backup.
*/
if (ib != NULL)
- relative_block_numbers = palloc(sizeof(BlockNumber) * RELSEG_SIZE);
+ relative_block_numbers = palloc_array(BlockNumber, RELSEG_SIZE);
/*
* Determine if the current path is a database directory that can contain
bbsink *
bbsink_copystream_new(bool send_to_client)
{
- bbsink_copystream *sink = palloc0(sizeof(bbsink_copystream));
+ bbsink_copystream *sink = palloc0_object(bbsink_copystream);
*((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_copystream_ops;
sink->send_to_client = send_to_client;
Assert((compresslevel >= 1 && compresslevel <= 9) ||
compresslevel == Z_DEFAULT_COMPRESSION);
- sink = palloc0(sizeof(bbsink_gzip));
+ sink = palloc0_object(bbsink_gzip);
*((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_gzip_ops;
sink->base.bbs_next = next;
sink->compresslevel = compresslevel;
oldcontext = MemoryContextSwitchTo(mcxt);
- ib = palloc0(sizeof(IncrementalBackupInfo));
+ ib = palloc0_object(IncrementalBackupInfo);
ib->mcxt = mcxt;
initStringInfo(&ib->buf);
*/
ib->manifest_files = backup_file_create(mcxt, 10000, NULL);
- context = palloc0(sizeof(JsonManifestParseContext));
+ context = palloc0_object(JsonManifestParseContext);
/* Parse the manifest. */
context->private_data = ib;
context->version_cb = manifest_process_version;
XLogRecPtr end_lsn)
{
IncrementalBackupInfo *ib = context->private_data;
- backup_wal_range *range = palloc(sizeof(backup_wal_range));
+ backup_wal_range *range = palloc_object(backup_wal_range);
range->tli = tli;
range->start_lsn = start_lsn;
compresslevel = compress->level;
Assert(compresslevel >= 0 && compresslevel <= 12);
- sink = palloc0(sizeof(bbsink_lz4));
+ sink = palloc0_object(bbsink_lz4);
*((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_lz4_ops;
sink->base.bbs_next = next;
sink->compresslevel = compresslevel;
Assert(next != NULL);
- sink = palloc0(sizeof(bbsink));
+ sink = palloc0_object(bbsink);
*((const bbsink_ops **) &sink->bbs_ops) = &bbsink_progress_ops;
sink->bbs_next = next;
bbsink *
bbsink_server_new(bbsink *next, char *pathname)
{
- bbsink_server *sink = palloc0(sizeof(bbsink_server));
+ bbsink_server *sink = palloc0_object(bbsink_server);
*((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_server_ops;
sink->pathname = pathname;
* name into a newly-allocated chunk of memory.
*/
oldcontext = MemoryContextSwitchTo(TopMemoryContext);
- newtype = palloc(sizeof(BaseBackupTargetType));
+ newtype = palloc_object(BaseBackupTargetType);
newtype->name = pstrdup(name);
newtype->check_detail = check_detail;
newtype->get_sink = get_sink;
BaseBackupTargetHandle *handle;
/* Found the target. */
- handle = palloc(sizeof(BaseBackupTargetHandle));
+ handle = palloc_object(BaseBackupTargetHandle);
handle->type = ttype;
handle->detail_arg = ttype->check_detail(target, target_detail);
Assert(next != NULL);
Assert(maxrate > 0);
- sink = palloc0(sizeof(bbsink_throttle));
+ sink = palloc0_object(bbsink_throttle);
*((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_throttle_ops;
sink->base.bbs_next = next;
Assert(next != NULL);
- sink = palloc0(sizeof(bbsink_zstd));
+ sink = palloc0_object(bbsink_zstd);
*((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_zstd_ops;
sink->base.bbs_next = next;
sink->compress = compress;
continue;
/* Add it to the list. */
- ws = palloc(sizeof(WalSummaryFile));
+ ws = palloc_object(WalSummaryFile);
ws->tli = file_tli;
ws->start_lsn = file_start_lsn;
ws->end_lsn = file_end_lsn;
Form_pg_type typForm = (Form_pg_type) GETSTRUCT(tup);
struct typmap *newtyp;
- newtyp = (struct typmap *) palloc(sizeof(struct typmap));
+ newtyp = palloc_object(struct typmap);
Typ = lappend(Typ, newtyp);
newtyp->am_oid = typForm->oid;
oldcxt = MemoryContextSwitchTo(nogc);
- newind = (IndexList *) palloc(sizeof(IndexList));
+ newind = palloc_object(IndexList);
newind->il_heap = heap;
newind->il_ind = ind;
- newind->il_info = (IndexInfo *) palloc(sizeof(IndexInfo));
+ newind->il_info = palloc_object(IndexInfo);
memcpy(newind->il_info, indexInfo, sizeof(IndexInfo));
/* expressions will likely be null, but may as well copy it */
* regression testing.)
*/
maxDependentObjects = 128; /* arbitrary initial allocation */
- dependentObjects = (ObjectAddressAndFlags *)
- palloc(maxDependentObjects * sizeof(ObjectAddressAndFlags));
+ dependentObjects = palloc_array(ObjectAddressAndFlags, maxDependentObjects);
numDependentObjects = 0;
ScanKeyInit(&key[0],
{
ObjectAddresses *addrs;
- addrs = palloc(sizeof(ObjectAddresses));
+ addrs = palloc_object(ObjectAddresses);
addrs->numrefs = 0;
addrs->maxrefs = 32;
- addrs->refs = (ObjectAddress *)
- palloc(addrs->maxrefs * sizeof(ObjectAddress));
+ addrs->refs = palloc_array(ObjectAddress, addrs->maxrefs);
addrs->extras = NULL; /* until/unless needed */
return addrs;
/* Initialize the number of slots to use */
nslots = Min(tupdesc->natts,
(MAX_CATALOG_MULTI_INSERT_BYTES / sizeof(FormData_pg_attribute)));
- slot = palloc(sizeof(TupleTableSlot *) * nslots);
+ slot = palloc_array(TupleTableSlot *, nslots);
for (int i = 0; i < nslots; i++)
slot[i] = MakeSingleTupleTableSlot(td, &TTSOpsHeapTuple);
defOid = StoreAttrDefault(rel, colDef->attnum, expr, is_internal);
- cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
+ cooked = palloc_object(CookedConstraint);
cooked->contype = CONSTR_DEFAULT;
cooked->conoid = defOid;
cooked->name = NULL;
numchecks++;
- cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
+ cooked = palloc_object(CookedConstraint);
cooked->contype = CONSTR_CHECK;
cooked->conoid = constrOid;
cooked->name = ccname;
inhcount,
cdef->is_no_inherit);
- nncooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
+ nncooked = palloc_object(CookedConstraint);
nncooked->contype = CONSTR_NOTNULL;
nncooked->conoid = constrOid;
nncooked->name = nnname;
}
/* Extract opclass options for each attribute */
- opclassOptions = palloc0(sizeof(Datum) * newInfo->ii_NumIndexAttrs);
+ opclassOptions = palloc0_array(Datum, newInfo->ii_NumIndexAttrs);
for (int i = 0; i < newInfo->ii_NumIndexAttrs; i++)
opclassOptions[i] = get_attoptions(oldIndexId, i + 1);
*/
Assert(ii->ii_Unique);
- ii->ii_UniqueOps = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
- ii->ii_UniqueProcs = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
- ii->ii_UniqueStrats = (uint16 *) palloc(sizeof(uint16) * indnkeyatts);
+ ii->ii_UniqueOps = palloc_array(Oid, indnkeyatts);
+ ii->ii_UniqueProcs = palloc_array(Oid, indnkeyatts);
+ ii->ii_UniqueStrats = palloc_array(uint16, indnkeyatts);
/*
* We have to look up the operator's strategy number. This provides a
oldcxt = MemoryContextSwitchTo(context);
- result = (SearchPathMatcher *) palloc0(sizeof(SearchPathMatcher));
+ result = palloc0_object(SearchPathMatcher);
schemas = list_copy(activeSearchPath);
while (schemas && linitial_oid(schemas) != activeCreationNamespace)
{
{
SearchPathMatcher *result;
- result = (SearchPathMatcher *) palloc(sizeof(SearchPathMatcher));
+ result = palloc_object(SearchPathMatcher);
result->schemas = list_copy(path->schemas);
result->addCatalog = path->addCatalog;
result->addTemp = path->addTemp;
ALLOCSET_DEFAULT_SIZES);
oldcxt = MemoryContextSwitchTo(memcxt);
- datums = (Datum *) palloc(sizeof(Datum) * list_length(list));
- nulls = palloc(sizeof(bool) * list_length(list));
+ datums = palloc_array(Datum, list_length(list));
+ nulls = palloc_array(bool, list_length(list));
foreach(cell, list)
{
{
CookedConstraint *cooked;
- cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
+ cooked = palloc_object(CookedConstraint);
cooked->contype = CONSTR_NOTNULL;
cooked->conoid = conForm->oid;
*/
max_slots = Min(nreferenced,
MAX_CATALOG_MULTI_INSERT_BYTES / sizeof(FormData_pg_depend));
- slot = palloc(sizeof(TupleTableSlot *) * max_slots);
+ slot = palloc_array(TupleTableSlot *, max_slots);
/* Don't open indexes unless we need to make an update */
indstate = NULL;
* allocating the next), trouble could only occur if the OID counter wraps
* all the way around before we finish. Which seems unlikely.
*/
- oids = (Oid *) palloc(num_elems * sizeof(Oid));
+ oids = palloc_array(Oid, num_elems);
for (elemno = 0; elemno < num_elems; elemno++)
{
/* allocate the slots to use and initialize them */
nslots = Min(num_elems,
MAX_CATALOG_MULTI_INSERT_BYTES / sizeof(FormData_pg_enum));
- slot = palloc(sizeof(TupleTableSlot *) * nslots);
+ slot = palloc_array(TupleTableSlot *, nslots);
for (int i = 0; i < nslots; i++)
slot[i] = MakeSingleTupleTableSlot(RelationGetDescr(pg_enum),
&TTSOpsHeapTuple);
nelems = list->n_members;
/* Sort the existing members by enumsortorder */
- existing = (HeapTuple *) palloc(nelems * sizeof(HeapTuple));
+ existing = palloc_array(HeapTuple, nelems);
for (i = 0; i < nelems; i++)
existing[i] = &(list->members[i]->tuple);
pubform = (Form_pg_publication) GETSTRUCT(tup);
- pub = (Publication *) palloc(sizeof(Publication));
+ pub = palloc_object(Publication);
pub->oid = pubid;
pub->name = pstrdup(NameStr(pubform->pubname));
pub->alltables = pubform->puballtables;
*/
foreach(lc, pub_elem_tables)
{
- published_rel *table_info = (published_rel *) palloc(sizeof(published_rel));
+ published_rel *table_info = palloc_object(published_rel);
table_info->relid = lfirst_oid(lc);
table_info->pubid = pub_elem->oid;
TupleDesc desc = RelationGetDescr(rel);
int i;
- attnums = (int16 *) palloc(desc->natts * sizeof(int16));
+ attnums = palloc_array(int16, desc->natts);
for (i = 0; i < desc->natts; i++)
{
}
if (!stored)
{
- dep = (remoteDep *) palloc(sizeof(remoteDep));
+ dep = palloc_object(remoteDep);
dep->dbOid = sdepForm->dbid;
dep->count = 1;
remDeps = lappend(remDeps, dep);
* know that they will be used.
*/
max_slots = MAX_CATALOG_MULTI_INSERT_BYTES / sizeof(FormData_pg_shdepend);
- slot = palloc(sizeof(TupleTableSlot *) * max_slots);
+ slot = palloc_array(TupleTableSlot *, max_slots);
indstate = CatalogOpenIndexes(sdepRel);
subform = (Form_pg_subscription) GETSTRUCT(tup);
- sub = (Subscription *) palloc(sizeof(Subscription));
+ sub = palloc_object(Subscription);
sub->oid = subid;
sub->dbid = subform->subdbid;
sub->skiplsn = subform->subskiplsn;
relkind == RELKIND_PARTITIONED_TABLE) && !tables)
continue;
- relstate = (SubscriptionRelState *) palloc(sizeof(SubscriptionRelState));
+ relstate = palloc_object(SubscriptionRelState);
relstate->relid = subrel->srrelid;
relstate->state = subrel->srsubstate;
d = SysCacheGetAttr(SUBSCRIPTIONRELMAP, tup,
if (maxrels == 0)
{
maxrels = 8;
- srels = palloc(sizeof(SMgrRelation) * maxrels);
+ srels = palloc_array(SMgrRelation, maxrels);
}
else if (maxrels <= nrels)
{
maxrels *= 2;
- srels = repalloc(srels, sizeof(SMgrRelation) * maxrels);
+ srels = repalloc_array(srels, SMgrRelation, maxrels);
}
srels[nrels++] = srel;
projects / postgresql.git / commitdiff