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;
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;
*ptr = NULL;
return 0;
}
- rptr = (RelFileLocator *) palloc(nrels * sizeof(RelFileLocator));
+ rptr = palloc_array(RelFileLocator, nrels);
*ptr = rptr;
for (pending = pendingDeletes; pending != NULL; pending = pending->next)
{
/*
* Create the VacAttrStats struct.
*/
- stats = (VacAttrStats *) palloc0(sizeof(VacAttrStats));
+ stats = palloc0_object(VacAttrStats);
stats->attstattarget = attstattarget;
/*
NULL);
/* Save the operator info for compute_stats routines */
- mystats = (StdAnalyzeData *) palloc(sizeof(StdAnalyzeData));
+ mystats = palloc_object(StdAnalyzeData);
mystats->eqopr = eqopr;
mystats->eqfunc = OidIsValid(eqopr) ? get_opcode(eqopr) : InvalidOid;
mystats->ltopr = ltopr;
/* Must copy the target values into anl_context */
old_context = MemoryContextSwitchTo(stats->anl_context);
- corrs = (float4 *) palloc(sizeof(float4));
+ corrs = palloc_object(float4);
MemoryContextSwitchTo(old_context);
/*----------
/* Use a permanent memory context for the result list */
old_context = MemoryContextSwitchTo(cluster_context);
- rtc = (RelToCluster *) palloc(sizeof(RelToCluster));
+ rtc = palloc_object(RelToCluster);
rtc->tableOid = index->indrelid;
rtc->indexOid = index->indexrelid;
rtcs = lappend(rtcs, rtc);
/* Use a permanent memory context for the result list */
old_context = MemoryContextSwitchTo(cluster_context);
- rtc = (RelToCluster *) palloc(sizeof(RelToCluster));
+ rtc = palloc_object(RelToCluster);
rtc->tableOid = relid;
rtc->indexOid = indexrelid;
rtcs = lappend(rtcs, rtc);
/* Support external use for option sanity checking */
if (opts_out == NULL)
- opts_out = (CopyFormatOptions *) palloc0(sizeof(CopyFormatOptions));
+ opts_out = palloc0_object(CopyFormatOptions);
opts_out->file_encoding = -1;
{
CopyMultiInsertBuffer *buffer;
- buffer = (CopyMultiInsertBuffer *) palloc(sizeof(CopyMultiInsertBuffer));
+ buffer = palloc_object(CopyMultiInsertBuffer);
memset(buffer->slots, 0, sizeof(TupleTableSlot *) * MAX_BUFFERED_TUPLES);
buffer->resultRelInfo = rri;
buffer->bistate = (rri->ri_FdwRoutine == NULL) ? GetBulkInsertState() : NULL;
};
/* Allocate workspace and zero all fields */
- cstate = (CopyFromStateData *) palloc0(sizeof(CopyFromStateData));
+ cstate = palloc0_object(CopyFromStateData);
/*
* We allocate everything used by a cstate in a new memory context. This
/* Allocate workspace and zero all fields */
- cstate = (CopyToStateData *) palloc0(sizeof(CopyToStateData));
+ cstate = palloc0_object(CopyToStateData);
/*
* We allocate everything used by a cstate in a new memory context. This
DestReceiver *
CreateCopyDestReceiver(void)
{
- DR_copy *self = (DR_copy *) palloc(sizeof(DR_copy));
+ DR_copy *self = palloc_object(DR_copy);
self->pub.receiveSlot = copy_dest_receive;
self->pub.rStartup = copy_dest_startup;
DestReceiver *
CreateIntoRelDestReceiver(IntoClause *intoClause)
{
- DR_intorel *self = (DR_intorel *) palloc0(sizeof(DR_intorel));
+ DR_intorel *self = palloc0_object(DR_intorel);
self->pub.receiveSlot = intorel_receive;
self->pub.rStartup = intorel_startup;
classForm->oid);
/* Prepare a rel info element and add it to the list. */
- relinfo = (CreateDBRelInfo *) palloc(sizeof(CreateDBRelInfo));
+ relinfo = palloc_object(CreateDBRelInfo);
if (OidIsValid(classForm->reltablespace))
relinfo->rlocator.spcOid = classForm->reltablespace;
else
int i = 0,
l = list_length(filterlist);
- data = (Datum *) palloc(l * sizeof(Datum));
+ data = palloc_array(Datum, l);
foreach(lc, filterlist)
{
oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
- obj = palloc0(sizeof(SQLDropObject));
+ obj = palloc0_object(SQLDropObject);
obj->address = *object;
obj->original = original;
obj->normal = normal;
oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
- command = palloc(sizeof(CollectedCommand));
+ command = palloc_object(CollectedCommand);
command->type = SCT_Simple;
command->in_extension = creating_extension;
oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
- command = palloc(sizeof(CollectedCommand));
+ command = palloc_object(CollectedCommand);
command->type = SCT_AlterTable;
command->in_extension = creating_extension;
oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
- newsub = palloc(sizeof(CollectedATSubcmd));
+ newsub = palloc_object(CollectedATSubcmd);
newsub->address = address;
newsub->parsetree = copyObject(subcmd);
/*
* This is tedious, but necessary.
*/
- icopy = palloc(sizeof(InternalGrant));
+ icopy = palloc_object(InternalGrant);
memcpy(icopy, istmt, sizeof(InternalGrant));
icopy->objects = list_copy(istmt->objects);
icopy->grantees = list_copy(istmt->grantees);
icopy->col_privs = lappend(icopy->col_privs, copyObject(lfirst(cell)));
/* Now collect it, using the copied InternalGrant */
- command = palloc(sizeof(CollectedCommand));
+ command = palloc_object(CollectedCommand);
command->type = SCT_Grant;
command->in_extension = creating_extension;
command->d.grant.istmt = icopy;
oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
- command = palloc(sizeof(CollectedCommand));
+ command = palloc_object(CollectedCommand);
command->type = SCT_AlterOpFamily;
command->in_extension = creating_extension;
ObjectAddressSet(command->d.opfam.address,
oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
- command = palloc0(sizeof(CollectedCommand));
+ command = palloc0_object(CollectedCommand);
command->type = SCT_CreateOpClass;
command->in_extension = creating_extension;
ObjectAddressSet(command->d.createopc.address,
oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
- command = palloc0(sizeof(CollectedCommand));
+ command = palloc0_object(CollectedCommand);
command->type = SCT_AlterTSConfig;
command->in_extension = creating_extension;
ObjectAddressSet(command->d.atscfg.address,
TSConfigRelationId, cfgId);
- command->d.atscfg.dictIds = palloc(sizeof(Oid) * ndicts);
+ command->d.atscfg.dictIds = palloc_array(Oid, ndicts);
memcpy(command->d.atscfg.dictIds, dictIds, sizeof(Oid) * ndicts);
command->d.atscfg.ndicts = ndicts;
command->parsetree = (Node *) copyObject(stmt);
oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
- command = palloc0(sizeof(CollectedCommand));
+ command = palloc0_object(CollectedCommand);
command->type = SCT_AlterDefaultPrivileges;
command->d.defprivs.objtype = stmt->action->objtype;
command->in_extension = creating_extension;
{
ExplainWorkersState *wstate;
- wstate = (ExplainWorkersState *) palloc(sizeof(ExplainWorkersState));
+ wstate = palloc_object(ExplainWorkersState);
wstate->num_workers = num_workers;
wstate->worker_inited = (bool *) palloc0(num_workers * sizeof(bool));
wstate->worker_str = (StringInfoData *)
{
SerializeDestReceiver *self;
- self = (SerializeDestReceiver *) palloc0(sizeof(SerializeDestReceiver));
+ self = palloc0_object(SerializeDestReceiver);
self->pub.receiveSlot = serializeAnalyzeReceive;
self->pub.rStartup = serializeAnalyzeStartup;
ExplainState *
NewExplainState(void)
{
- ExplainState *es = (ExplainState *) palloc0(sizeof(ExplainState));
+ ExplainState *es = palloc0_object(ExplainState);
/* Set default options (most fields can be left as zeroes). */
es->costs = true;
int i;
i = pg_nextpower2_32(extension_id + 1);
- es->extension_state = (void **)
- repalloc0(es->extension_state,
- es->extension_state_allocated * sizeof(void *),
- i * sizeof(void *));
+ es->extension_state = repalloc0_array(es->extension_state, void *, es->extension_state_allocated, i);
es->extension_state_allocated = i;
}
/*
* Flat-copy the struct. Pointer fields share values with original.
*/
- acontrol = (ExtensionControlFile *) palloc(sizeof(ExtensionControlFile));
+ acontrol = palloc_object(ExtensionControlFile);
memcpy(acontrol, pcontrol, sizeof(ExtensionControlFile));
/*
return evi;
}
- evi = (ExtensionVersionInfo *) palloc(sizeof(ExtensionVersionInfo));
+ evi = palloc_object(ExtensionVersionInfo);
evi->name = pstrdup(versionname);
evi->reachable = NIL;
evi->installable = false;
{
SQLFunctionParseInfoPtr pinfo;
- pinfo = (SQLFunctionParseInfoPtr) palloc0(sizeof(SQLFunctionParseInfo));
+ pinfo = palloc0_object(SQLFunctionParseInfo);
pinfo->fname = funcname;
pinfo->nargs = list_length(parameterTypes);
DestReceiver *
CreateTransientRelDestReceiver(Oid transientoid)
{
- DR_transientrel *self = (DR_transientrel *) palloc0(sizeof(DR_transientrel));
+ DR_transientrel *self = palloc0_object(DR_transientrel);
self->pub.receiveSlot = transientrel_receive;
self->pub.rStartup = transientrel_startup;
* include all rows.
*/
tupdesc = matviewRel->rd_att;
- opUsedForQual = (Oid *) palloc0(sizeof(Oid) * relnatts);
+ opUsedForQual = palloc0_array(Oid, relnatts);
foundUniqueIndex = false;
indexoidlist = RelationGetIndexList(matviewRel);
#endif
/* Save the info */
- member = (OpFamilyMember *) palloc0(sizeof(OpFamilyMember));
+ member = palloc0_object(OpFamilyMember);
member->is_func = false;
member->object = operOid;
member->number = item->number;
get_func_name(funcOid));
#endif
/* Save the info */
- member = (OpFamilyMember *) palloc0(sizeof(OpFamilyMember));
+ member = palloc0_object(OpFamilyMember);
member->is_func = true;
member->object = funcOid;
member->number = item->number;
#endif
/* Save the info */
- member = (OpFamilyMember *) palloc0(sizeof(OpFamilyMember));
+ member = palloc0_object(OpFamilyMember);
member->is_func = false;
member->object = operOid;
member->number = item->number;
#endif
/* Save the info */
- member = (OpFamilyMember *) palloc0(sizeof(OpFamilyMember));
+ member = palloc0_object(OpFamilyMember);
member->is_func = true;
member->object = funcOid;
member->number = item->number;
item->number, maxOpNumber)));
processTypesSpec(item->class_args, &lefttype, &righttype);
/* Save the info */
- member = (OpFamilyMember *) palloc0(sizeof(OpFamilyMember));
+ member = palloc0_object(OpFamilyMember);
member->is_func = false;
member->number = item->number;
member->lefttype = lefttype;
item->number, maxProcNumber)));
processTypesSpec(item->class_args, &lefttype, &righttype);
/* Save the info */
- member = (OpFamilyMember *) palloc0(sizeof(OpFamilyMember));
+ member = palloc0_object(OpFamilyMember);
member->is_func = true;
member->number = item->number;
member->lefttype = lefttype;
if (roles == NIL)
{
*num_roles = 1;
- role_oids = (Datum *) palloc(*num_roles * sizeof(Datum));
+ role_oids = palloc_array(Datum, *num_roles);
role_oids[0] = ObjectIdGetDatum(ACL_ID_PUBLIC);
return role_oids;
* Ordinarily there'd be exactly one, but we must cope with duplicate
* mentions, since CREATE/ALTER POLICY historically have allowed that.
*/
- role_oids = (Datum *) palloc(num_roles * sizeof(Datum));
+ role_oids = palloc_array(Datum, num_roles);
for (i = 0, j = 0; i < num_roles; i++)
{
if (roles[i] != roleid)
nitems = ARR_DIMS(policy_roles)[0];
- role_oids = (Datum *) palloc(nitems * sizeof(Datum));
+ role_oids = palloc_array(Datum, nitems);
for (i = 0; i < nitems; i++)
role_oids[i] = ObjectIdGetDatum(roles[i]);
*/
if (!found)
{
- oldrel = palloc(sizeof(PublicationRelInfo));
+ oldrel = palloc_object(PublicationRelInfo);
oldrel->whereClause = NULL;
oldrel->columns = NIL;
oldrel->relation = table_open(oldrelid,
continue;
}
- pub_rel = palloc(sizeof(PublicationRelInfo));
+ pub_rel = palloc_object(PublicationRelInfo);
pub_rel->relation = rel;
pub_rel->whereClause = t->whereClause;
pub_rel->columns = t->columns;
/* find_all_inheritors already got lock */
rel = table_open(childrelid, NoLock);
- pub_rel = palloc(sizeof(PublicationRelInfo));
+ pub_rel = palloc_object(PublicationRelInfo);
pub_rel->relation = rel;
/* child inherits WHERE clause from parent */
pub_rel->whereClause = t->whereClause;
MemoryContext oldcxt;
oldcxt = MemoryContextSwitchTo(TopMemoryContext);
- provider = palloc(sizeof(LabelProvider));
+ provider = palloc_object(LabelProvider);
provider->provider_name = pstrdup(provider_name);
provider->hook = hook;
label_provider_list = lappend(label_provider_list, provider);
ALLOCSET_DEFAULT_SIZES);
oldcxt = MemoryContextSwitchTo(memcxt);
- datums = (Datum *) palloc(sizeof(Datum) * list_length(publist));
+ datums = palloc_array(Datum, list_length(publist));
check_duplicates_in_publist(publist, datums);
{
char state;
XLogRecPtr statelsn;
- SubRemoveRels *remove_rel = palloc(sizeof(SubRemoveRels));
+ SubRemoveRels *remove_rel = palloc_object(SubRemoveRels);
/*
* Lock pg_subscription_rel with AccessExclusiveLock to
Assert(colDef->cooked_default == NULL);
- rawEnt = (RawColumnDefault *) palloc(sizeof(RawColumnDefault));
+ rawEnt = palloc_object(RawColumnDefault);
rawEnt->attnum = attnum;
rawEnt->raw_default = colDef->raw_default;
rawEnt->generated = colDef->generated;
{
CookedConstraint *cooked;
- cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
+ cooked = palloc_object(CookedConstraint);
cooked->contype = CONSTR_DEFAULT;
cooked->conoid = InvalidOid; /* until created */
cooked->name = NULL;
* Not there, so add it. Note that we make a copy of the relation's
* existing descriptor before anything interesting can happen to it.
*/
- tab = (AlteredTableInfo *) palloc0(sizeof(AlteredTableInfo));
+ tab = palloc0_object(AlteredTableInfo);
tab->relid = relid;
tab->rel = NULL; /* set later */
tab->relkind = rel->rd_rel->relkind;
{
RawColumnDefault *rawEnt;
- rawEnt = (RawColumnDefault *) palloc(sizeof(RawColumnDefault));
+ rawEnt = palloc_object(RawColumnDefault);
rawEnt->attnum = attribute->attnum;
rawEnt->raw_default = copyObject(colDef->raw_default);
rawEnt->generated = colDef->generated;
defval = expression_planner(defval);
/* Add the new default to the newvals list */
- newval = (NewColumnValue *) palloc0(sizeof(NewColumnValue));
+ newval = palloc0_object(NewColumnValue);
newval->attnum = attribute->attnum;
newval->expr = defval;
newval->is_generated = (colDef->generated != '\0');
/* SET DEFAULT */
RawColumnDefault *rawEnt;
- rawEnt = (RawColumnDefault *) palloc(sizeof(RawColumnDefault));
+ rawEnt = palloc_object(RawColumnDefault);
rawEnt->attnum = attnum;
rawEnt->raw_default = newDefault;
rawEnt->generated = '\0';
false, false);
/* Prepare to store the new expression, in the catalogs */
- rawEnt = (RawColumnDefault *) palloc(sizeof(RawColumnDefault));
+ rawEnt = palloc_object(RawColumnDefault);
rawEnt->attnum = attnum;
rawEnt->raw_default = newExpr;
rawEnt->generated = attgenerated;
/* Prepare for table rewrite */
defval = (Expr *) build_column_default(rel, attnum);
- newval = (NewColumnValue *) palloc0(sizeof(NewColumnValue));
+ newval = palloc0_object(NewColumnValue);
newval->attnum = attnum;
newval->expr = expression_planner(defval);
newval->is_generated = true;
{
NewConstraint *newcon;
- newcon = (NewConstraint *) palloc0(sizeof(NewConstraint));
+ newcon = palloc0_object(NewConstraint);
newcon->name = ccon->name;
newcon->contype = ccon->contype;
newcon->qual = ccon->expr;
false);
if (map)
{
- mapped_pkattnum = palloc(sizeof(AttrNumber) * numfks);
+ mapped_pkattnum = palloc_array(AttrNumber, numfks);
for (int j = 0; j < numfks; j++)
mapped_pkattnum[j] = map->attnums[pkattnum[j] - 1];
}
tab = ATGetQueueEntry(wqueue, rel);
- newcon = (NewConstraint *) palloc0(sizeof(NewConstraint));
+ newcon = palloc0_object(NewConstraint);
newcon->name = get_constraint_name(parentConstr);
newcon->contype = CONSTR_FOREIGN;
newcon->refrelid = RelationGetRelid(pkrel);
AlteredTableInfo *tab;
NewConstraint *newcon;
- newcon = (NewConstraint *) palloc0(sizeof(NewConstraint));
+ newcon = palloc0_object(NewConstraint);
newcon->name = fkconstraint->conname;
newcon->contype = CONSTR_FOREIGN;
newcon->refrelid = currcon->confrelid;
/* for now this is all we need */
fkconstraint->conname = pstrdup(NameStr(con->conname));
- newcon = (NewConstraint *) palloc0(sizeof(NewConstraint));
+ newcon = palloc0_object(NewConstraint);
newcon->name = fkconstraint->conname;
newcon->contype = CONSTR_FOREIGN;
newcon->refrelid = con->confrelid;
}
/* Queue validation for phase 3 */
- newcon = (NewConstraint *) palloc0(sizeof(NewConstraint));
+ newcon = palloc0_object(NewConstraint);
newcon->name = constrName;
newcon->contype = CONSTR_CHECK;
newcon->refrelid = InvalidOid;
* Add a work queue item to make ATRewriteTable update the column
* contents.
*/
- newval = (NewColumnValue *) palloc0(sizeof(NewColumnValue));
+ newval = palloc0_object(NewColumnValue);
newval->attnum = attnum;
newval->expr = (Expr *) transform;
newval->is_generated = false;
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
- oc = (OnCommitItem *) palloc(sizeof(OnCommitItem));
+ oc = palloc_object(OnCommitItem);
oc->relid = relid;
oc->oncommit = action;
oc->creating_subid = GetCurrentSubTransactionId();
idxes = RelationGetIndexList(rel);
attachRelIdxs = RelationGetIndexList(attachrel);
- attachrelIdxRels = palloc(sizeof(Relation) * list_length(attachRelIdxs));
- attachInfos = palloc(sizeof(IndexInfo *) * list_length(attachRelIdxs));
+ attachrelIdxRels = palloc_array(Relation, list_length(attachRelIdxs));
+ attachInfos = palloc_array(IndexInfo *, list_length(attachRelIdxs));
/* Build arrays of all existing indexes and their IndexInfos */
foreach_oid(cldIdxId, attachRelIdxs)
}
/* Build trigdesc */
- trigdesc = (TriggerDesc *) palloc0(sizeof(TriggerDesc));
+ trigdesc = palloc0_object(TriggerDesc);
trigdesc->triggers = triggers;
trigdesc->numtriggers = numtrigs;
for (i = 0; i < numtrigs; i++)
if (trigdesc == NULL || trigdesc->numtriggers <= 0)
return NULL;
- newdesc = (TriggerDesc *) palloc(sizeof(TriggerDesc));
+ newdesc = palloc_object(TriggerDesc);
memcpy(newdesc, trigdesc, sizeof(TriggerDesc));
trigger = (Trigger *) palloc(trigdesc->numtriggers * sizeof(Trigger));
oldcxt = MemoryContextSwitchTo(CurTransactionContext);
- table = (AfterTriggersTableData *) palloc0(sizeof(AfterTriggersTableData));
+ table = palloc0_object(AfterTriggersTableData);
table->relid = relid;
table->cmdType = cmdType;
qs->tables = lappend(qs->tables, table);
MemoryContextSwitchTo(oldcxt);
/* Now build the TransitionCaptureState struct, in caller's context */
- state = (TransitionCaptureState *) palloc0(sizeof(TransitionCaptureState));
+ state = palloc0_object(TransitionCaptureState);
state->tcs_delete_old_table = need_old_del;
state->tcs_update_old_table = need_old_upd;
state->tcs_update_new_table = need_new_upd;
* know that they will be used.
*/
max_slots = MAX_CATALOG_MULTI_INSERT_BYTES / sizeof(FormData_pg_ts_config_map);
- slot = palloc(sizeof(TupleTableSlot *) * max_slots);
+ slot = palloc_array(TupleTableSlot *, max_slots);
ScanKeyInit(&skey,
Anum_pg_ts_config_map_mapcfg,
{
if (strcmp(strVal(val), list[j].alias) == 0)
{
- TSTokenTypeItem *ts = (TSTokenTypeItem *) palloc0(sizeof(TSTokenTypeItem));
+ TSTokenTypeItem *ts = palloc0_object(TSTokenTypeItem);
ts->num = list[j].lexid;
ts->name = pstrdup(strVal(val));
* Convert list of dictionary names to array of dict OIDs
*/
ndict = list_length(stmt->dicts);
- dictIds = (Oid *) palloc(sizeof(Oid) * ndict);
+ dictIds = palloc_array(Oid, ndict);
i = 0;
foreach(c, stmt->dicts)
{
/* Allocate the slots to use and initialize them */
nslots = Min(ntoken * ndict,
MAX_CATALOG_MULTI_INSERT_BYTES / sizeof(FormData_pg_ts_config_map));
- slot = palloc(sizeof(TupleTableSlot *) * nslots);
+ slot = palloc_array(TupleTableSlot *, nslots);
for (i = 0; i < nslots; i++)
slot[i] = MakeSingleTupleTableSlot(RelationGetDescr(relMap),
&TTSOpsHeapTuple);
}
/* Build the RelToCheck entry with enough space for all atts */
- rtc = (RelToCheck *) palloc(sizeof(RelToCheck));
+ rtc = palloc_object(RelToCheck);
rtc->rel = rel;
rtc->natts = 0;
- rtc->atts = (int *) palloc(sizeof(int) * RelationGetNumberOfAttributes(rel));
+ rtc->atts = palloc_array(int, RelationGetNumberOfAttributes(rel));
result = lappend(result, rtc);
}
else
{
Oid objectId;
- Oid *newmembers = palloc(sizeof(Oid));
+ Oid *newmembers = palloc_object(Oid);
/*
* The values for these options can be taken directly from 'popt'.
if (memlist->n_members == 0)
return NULL;
- result = palloc(sizeof(RevokeRoleGrantAction) * memlist->n_members);
+ result = palloc_array(RevokeRoleGrantAction, memlist->n_members);
for (i = 0; i < memlist->n_members; i++)
result[i] = RRG_NOOP;
return result;
/*
* Compute the number of parallel vacuum workers to launch
*/
- will_parallel_vacuum = (bool *) palloc0(sizeof(bool) * nindexes);
+ will_parallel_vacuum = palloc0_array(bool, nindexes);
parallel_workers = parallel_vacuum_compute_workers(indrels, nindexes,
nrequested_workers,
will_parallel_vacuum);
return NULL;
}
- pvs = (ParallelVacuumState *) palloc0(sizeof(ParallelVacuumState));
+ pvs = palloc0_object(ParallelVacuumState);
pvs->indrels = indrels;
pvs->nindexes = nindexes;
pvs->will_parallel_vacuum = will_parallel_vacuum;
if (indstats->istat_updated)
{
- istats[i] = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+ istats[i] = palloc0_object(IndexBulkDeleteResult);
memcpy(istats[i], &indstats->istat, sizeof(IndexBulkDeleteResult));
}
else
}
/* Set up the primary fmgr lookup information */
- finfo = palloc0(sizeof(FmgrInfo));
+ finfo = palloc0_object(FmgrInfo);
fcinfo = palloc0(SizeForFunctionCallInfo(2));
fmgr_info(cmpfuncid, finfo);
fmgr_info_set_expr((Node *) node, finfo);
/* allocate scratch memory used by all steps of AND/OR */
if (boolexpr->boolop != NOT_EXPR)
- scratch.d.boolexpr.anynull = (bool *) palloc(sizeof(bool));
+ scratch.d.boolexpr.anynull = palloc_object(bool);
/*
* For each argument evaluate the argument itself, then
ReleaseTupleDesc(tupDesc);
/* create workspace for column values */
- values = (Datum *) palloc(sizeof(Datum) * ncolumns);
- nulls = (bool *) palloc(sizeof(bool) * ncolumns);
+ values = palloc_array(Datum, ncolumns);
+ nulls = palloc_array(bool, ncolumns);
/* create shared composite-type-lookup cache struct */
- rowcachep = palloc(sizeof(ExprEvalRowtypeCache));
+ rowcachep = palloc_object(ExprEvalRowtypeCache);
rowcachep->cacheptr = NULL;
/* emit code to evaluate the composite input value */
scratch.opcode = EEOP_IOCOERCE_SAFE;
/* lookup the source type's output function */
- scratch.d.iocoerce.finfo_out = palloc0(sizeof(FmgrInfo));
+ scratch.d.iocoerce.finfo_out = palloc0_object(FmgrInfo);
scratch.d.iocoerce.fcinfo_data_out = palloc0(SizeForFunctionCallInfo(1));
getTypeOutputInfo(exprType((Node *) iocoerce->arg),
1, InvalidOid, NULL, NULL);
/* lookup the result type's input function */
- scratch.d.iocoerce.finfo_in = palloc0(sizeof(FmgrInfo));
+ scratch.d.iocoerce.finfo_in = palloc0_object(FmgrInfo);
scratch.d.iocoerce.fcinfo_data_in = palloc0(SizeForFunctionCallInfo(3));
getTypeInputInfo(iocoerce->resulttype,
elemstate->parent = state->parent;
elemstate->ext_params = state->ext_params;
- elemstate->innermost_caseval = (Datum *) palloc(sizeof(Datum));
- elemstate->innermost_casenull = (bool *) palloc(sizeof(bool));
+ elemstate->innermost_caseval = palloc_object(Datum);
+ elemstate->innermost_casenull = palloc_object(bool);
ExecInitExprRec(acoerce->elemexpr, elemstate,
&elemstate->resvalue, &elemstate->resnull);
if (elemstate)
{
/* Set up workspace for array_map */
- scratch.d.arraycoerce.amstate =
- (ArrayMapState *) palloc0(sizeof(ArrayMapState));
+ scratch.d.arraycoerce.amstate = palloc0_object(ArrayMapState);
}
else
{
if (caseExpr->arg != NULL)
{
/* Evaluate testexpr into caseval/casenull workspace */
- caseval = palloc(sizeof(Datum));
- casenull = palloc(sizeof(bool));
+ caseval = palloc_object(Datum);
+ casenull = palloc_object(bool);
ExecInitExprRec(caseExpr->arg, state,
caseval, casenull);
*/
scratch.opcode = EEOP_ARRAYEXPR;
scratch.d.arrayexpr.elemvalues =
- (Datum *) palloc(sizeof(Datum) * nelems);
+ palloc_array(Datum, nelems);
scratch.d.arrayexpr.elemnulls =
- (bool *) palloc(sizeof(bool) * nelems);
+ palloc_array(bool, nelems);
scratch.d.arrayexpr.nelems = nelems;
/* fill remaining fields of step */
/* space for the individual field datums */
scratch.d.row.elemvalues =
- (Datum *) palloc(sizeof(Datum) * nelems);
+ palloc_array(Datum, nelems);
scratch.d.row.elemnulls =
- (bool *) palloc(sizeof(bool) * nelems);
+ palloc_array(bool, nelems);
/* as explained above, make sure any extra columns are null */
memset(scratch.d.row.elemnulls, true, sizeof(bool) * nelems);
BTORDER_PROC, lefttype, righttype, opfamily);
/* Set up the primary fmgr lookup information */
- finfo = palloc0(sizeof(FmgrInfo));
+ finfo = palloc0_object(FmgrInfo);
fcinfo = palloc0(SizeForFunctionCallInfo(2));
fmgr_info(proc, finfo);
fmgr_info_set_expr((Node *) node, finfo);
*/
/* Perform function lookup */
- finfo = palloc0(sizeof(FmgrInfo));
+ finfo = palloc0_object(FmgrInfo);
fcinfo = palloc0(SizeForFunctionCallInfo(2));
fmgr_info(typentry->cmp_proc, finfo);
fmgr_info_set_expr((Node *) node, finfo);
scratch.opcode = EEOP_MINMAX;
/* allocate space to store arguments */
- scratch.d.minmax.values =
- (Datum *) palloc(sizeof(Datum) * nelems);
- scratch.d.minmax.nulls =
- (bool *) palloc(sizeof(bool) * nelems);
+ scratch.d.minmax.values = palloc_array(Datum, nelems);
+ scratch.d.minmax.nulls = palloc_array(bool, nelems);
scratch.d.minmax.nelems = nelems;
scratch.d.minmax.op = minmaxexpr->op;
/* allocate space for storing all the arguments */
if (nnamed)
{
- scratch.d.xmlexpr.named_argvalue =
- (Datum *) palloc(sizeof(Datum) * nnamed);
- scratch.d.xmlexpr.named_argnull =
- (bool *) palloc(sizeof(bool) * nnamed);
+ scratch.d.xmlexpr.named_argvalue = palloc_array(Datum, nnamed);
+ scratch.d.xmlexpr.named_argnull = palloc_array(bool, nnamed);
}
else
{
if (nargs)
{
- scratch.d.xmlexpr.argvalue =
- (Datum *) palloc(sizeof(Datum) * nargs);
- scratch.d.xmlexpr.argnull =
- (bool *) palloc(sizeof(bool) * nargs);
+ scratch.d.xmlexpr.argvalue = palloc_array(Datum, nargs);
+ scratch.d.xmlexpr.argnull = palloc_array(bool, nargs);
}
else
{
{
JsonConstructorExprState *jcstate;
- jcstate = palloc0(sizeof(JsonConstructorExprState));
+ jcstate = palloc0_object(JsonConstructorExprState);
scratch.opcode = EEOP_JSON_CONSTRUCTOR;
scratch.d.json_constructor.jcstate = jcstate;
jcstate->constructor = ctor;
- jcstate->arg_values = (Datum *) palloc(sizeof(Datum) * nargs);
- jcstate->arg_nulls = (bool *) palloc(sizeof(bool) * nargs);
- jcstate->arg_types = (Oid *) palloc(sizeof(Oid) * nargs);
+ jcstate->arg_values = palloc_array(Datum, nargs);
+ jcstate->arg_nulls = palloc_array(bool, nargs);
+ jcstate->arg_types = palloc_array(Oid, nargs);
jcstate->nargs = nargs;
foreach(lc, args)
if (es->steps_alloc == 0)
{
es->steps_alloc = 16;
- es->steps = palloc(sizeof(ExprEvalStep) * es->steps_alloc);
+ es->steps = palloc_array(ExprEvalStep, es->steps_alloc);
}
else if (es->steps_alloc == es->steps_len)
{
FUNC_MAX_ARGS)));
/* Allocate function lookup data and parameter workspace for this call */
- scratch->d.func.finfo = palloc0(sizeof(FmgrInfo));
+ scratch->d.func.finfo = palloc0_object(FmgrInfo);
scratch->d.func.fcinfo_data = palloc0(SizeForFunctionCallInfo(nargs));
flinfo = scratch->d.func.finfo;
fcinfo = scratch->d.func.fcinfo_data;
* during executor initialization. That means we don't need typcache.c to
* provide compiled exprs.
*/
- constraint_ref = (DomainConstraintRef *)
- palloc(sizeof(DomainConstraintRef));
+ constraint_ref = palloc_object(DomainConstraintRef);
InitDomainConstraintRef(ctest->resulttype,
constraint_ref,
CurrentMemoryContext,
if (scratch->d.domaincheck.checkvalue == NULL)
{
scratch->d.domaincheck.checkvalue =
- (Datum *) palloc(sizeof(Datum));
+ palloc_object(Datum);
scratch->d.domaincheck.checknull =
- (bool *) palloc(sizeof(bool));
+ palloc_object(bool);
}
/*
ExprEvalStep scratch2 = {0};
/* Yes, so make output workspace for MAKE_READONLY */
- domainval = (Datum *) palloc(sizeof(Datum));
- domainnull = (bool *) palloc(sizeof(bool));
+ domainval = palloc_object(Datum);
+ domainnull = palloc_object(bool);
/* Emit MAKE_READONLY */
scratch2.opcode = EEOP_MAKE_READONLY;
* one column to hash or an initial value plus one column.
*/
if ((int64) numCols + (init_value != 0) > 1)
- iresult = palloc(sizeof(NullableDatum));
+ iresult = palloc_object(NullableDatum);
/* find the highest attnum so we deform the tuple to that point */
for (int i = 0; i < numCols; i++)
* than one expression to hash or an initial value plus one expression.
*/
if ((int64) num_exprs + (init_value != 0) > 1)
- iresult = palloc(sizeof(NullableDatum));
+ iresult = palloc_object(NullableDatum);
if (init_value == 0)
{
funcid = hashfunc_oids[i];
/* Allocate hash function lookup data. */
- finfo = palloc0(sizeof(FmgrInfo));
+ finfo = palloc0_object(FmgrInfo);
fcinfo = palloc0(SizeForFunctionCallInfo(1));
fmgr_info(funcid, finfo);
InvokeFunctionExecuteHook(foid);
/* Set up the primary fmgr lookup information */
- finfo = palloc0(sizeof(FmgrInfo));
+ finfo = palloc0_object(FmgrInfo);
fcinfo = palloc0(SizeForFunctionCallInfo(2));
fmgr_info(foid, finfo);
fmgr_info_set_expr(NULL, finfo);
InvokeFunctionExecuteHook(foid);
/* Set up the primary fmgr lookup information */
- finfo = palloc0(sizeof(FmgrInfo));
+ finfo = palloc0_object(FmgrInfo);
fcinfo = palloc0(SizeForFunctionCallInfo(2));
fmgr_info(foid, finfo);
fmgr_info_set_expr(NULL, finfo);
Datum *resv, bool *resnull,
ExprEvalStep *scratch)
{
- JsonExprState *jsestate = palloc0(sizeof(JsonExprState));
+ JsonExprState *jsestate = palloc0_object(JsonExprState);
ListCell *argexprlc;
ListCell *argnamelc;
List *jumps_return_null = NIL;
{
Expr *argexpr = (Expr *) lfirst(argexprlc);
String *argname = lfirst_node(String, argnamelc);
- JsonPathVariable *var = palloc(sizeof(*var));
+ JsonPathVariable *var = palloc_object(JsonPathVariable);
var->name = argname->sval;
var->namelen = strlen(var->name);
FunctionCallInfo fcinfo;
getTypeInputInfo(jsexpr->returning->typid, &typinput, &typioparam);
- finfo = palloc0(sizeof(FmgrInfo));
+ finfo = palloc0_object(FmgrInfo);
fcinfo = palloc0(SizeForFunctionCallInfo(3));
fmgr_info(typinput, finfo);
fmgr_info_set_expr((Node *) jsexpr->returning, finfo);
oldcontext = MemoryContextSwitchTo(metacxt);
- hashtable = (TupleHashTable) palloc(sizeof(TupleHashTableData));
+ hashtable = palloc_object(TupleHashTableData);
hashtable->numCols = numCols;
hashtable->keyColIdx = keyColIdx;
/*
* allocate space for result arrays
*/
- relationDescs = (RelationPtr) palloc(len * sizeof(Relation));
- indexInfoArray = (IndexInfo **) palloc(len * sizeof(IndexInfo *));
+ relationDescs = palloc_array(Relation, len);
+ indexInfoArray = palloc_array(IndexInfo *, len);
resultRelInfo->ri_NumIndices = len;
resultRelInfo->ri_IndexRelationDescs = relationDescs;
nParamExec = list_length(queryDesc->plannedstmt->paramExecTypes);
estate->es_param_exec_vals = (ParamExecData *)
- palloc0(nParamExec * sizeof(ParamExecData));
+ palloc0_array(ParamExecData, nParamExec);
}
/* We now require all callers to provide sourceText */
if (plannedstmt->rowMarks)
{
estate->es_rowmarks = (ExecRowMark **)
- palloc0(estate->es_range_table_size * sizeof(ExecRowMark *));
+ palloc0_array(ExecRowMark *, estate->es_range_table_size);
foreach(l, plannedstmt->rowMarks)
{
PlanRowMark *rc = (PlanRowMark *) lfirst(l);
if (relation)
CheckValidRowMarkRel(relation, rc->markType);
- erm = (ExecRowMark *) palloc(sizeof(ExecRowMark));
+ erm = palloc_object(ExecRowMark);
erm->relation = relation;
erm->relid = relid;
erm->rti = rc->rti;
int n = resultRelInfo->ri_TrigDesc->numtriggers;
resultRelInfo->ri_TrigFunctions = (FmgrInfo *)
- palloc0(n * sizeof(FmgrInfo));
+ palloc0_array(FmgrInfo, n);
resultRelInfo->ri_TrigWhenExprs = (ExprState **)
- palloc0(n * sizeof(ExprState *));
+ palloc0_array(ExprState *, n);
if (instrument_options)
resultRelInfo->ri_TrigInstrument = InstrAlloc(n, instrument_options, false);
}
ExecAuxRowMark *
ExecBuildAuxRowMark(ExecRowMark *erm, List *targetlist)
{
- ExecAuxRowMark *aerm = (ExecAuxRowMark *) palloc0(sizeof(ExecAuxRowMark));
+ ExecAuxRowMark *aerm = palloc0_object(ExecAuxRowMark);
char resname[32];
aerm->rowmark = erm;
* EvalPlanQualBegin().
*/
epqstate->tuple_table = NIL;
- epqstate->relsubs_slot = (TupleTableSlot **)
- palloc0(rtsize * sizeof(TupleTableSlot *));
+ epqstate->relsubs_slot = palloc0_array(TupleTableSlot *, rtsize);
/* ... and remember data that EvalPlanQualBegin will need */
epqstate->plan = subplan;
/* now make the internal param workspace ... */
i = list_length(parentestate->es_plannedstmt->paramExecTypes);
- rcestate->es_param_exec_vals = (ParamExecData *)
- palloc0(i * sizeof(ParamExecData));
+ rcestate->es_param_exec_vals = palloc0_array(ParamExecData, i);
/* ... and copy down all values, whether really needed or not */
while (--i >= 0)
{
* EvalPlanQualFetchRowMark() can efficiently access the to be fetched
* rowmark.
*/
- epqstate->relsubs_rowmark = (ExecAuxRowMark **)
- palloc0(rtsize * sizeof(ExecAuxRowMark *));
+ epqstate->relsubs_rowmark = palloc0_array(ExecAuxRowMark *, rtsize);
foreach(l, epqstate->arowMarks)
{
ExecAuxRowMark *earm = (ExecAuxRowMark *) lfirst(l);
ExecSetParamPlanMulti(sendParams, GetPerTupleExprContext(estate));
/* Allocate object for return value. */
- pei = palloc0(sizeof(ParallelExecutorInfo));
+ pei = palloc0_object(ParallelExecutorInfo);
pei->finished = false;
pei->planstate = planstate;
if (!isIdxSafeToSkipDuplicates)
{
if (eq == NULL)
- eq = palloc0(sizeof(*eq) * outslot->tts_tupleDescriptor->natts);
+ eq = palloc0_array(TypeCacheEntry *, outslot->tts_tupleDescriptor->natts);
if (!tuples_equal(outslot, searchslot, eq, NULL))
continue;
Assert(equalTupleDescs(desc, outslot->tts_tupleDescriptor));
- eq = palloc0(sizeof(*eq) * outslot->tts_tupleDescriptor->natts);
+ eq = palloc0_array(TypeCacheEntry *, outslot->tts_tupleDescriptor->natts);
/* Start a heap scan. */
InitDirtySnapshot(snap);
indexbitmap = RelationGetIndexAttrBitmap(rel,
INDEX_ATTR_BITMAP_PRIMARY_KEY);
- eq = palloc0(sizeof(*eq) * searchslot->tts_tupleDescriptor->natts);
+ eq = palloc0_array(TypeCacheEntry *, searchslot->tts_tupleDescriptor->natts);
/*
* Start a heap scan using SnapshotAny to identify dead tuples that are
if (!isIdxSafeToSkipDuplicates)
{
if (eq == NULL)
- eq = palloc0(sizeof(*eq) * scanslot->tts_tupleDescriptor->natts);
+ eq = palloc0_array(TypeCacheEntry *, scanslot->tts_tupleDescriptor->natts);
if (!tuples_equal(scanslot, searchslot, eq, NULL))
continue;
int32 *atttypmods;
AttInMetadata *attinmeta;
- attinmeta = (AttInMetadata *) palloc(sizeof(AttInMetadata));
+ attinmeta = palloc_object(AttInMetadata);
/* "Bless" the tupledesc so that we can make rowtype datums with it */
attinmeta->tupdesc = BlessTupleDesc(tupdesc);
{
TupOutputState *tstate;
- tstate = (TupOutputState *) palloc(sizeof(TupOutputState));
+ tstate = palloc_object(TupOutputState);
tstate->slot = MakeSingleTupleTableSlot(tupdesc, tts_ops);
tstate->dest = dest;
Form_pg_proc procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
int nargs;
- pinfo = (SQLFunctionParseInfoPtr) palloc0(sizeof(SQLFunctionParseInfo));
+ pinfo = (SQLFunctionParseInfoPtr) palloc0_object(SQLFunctionParseInfo);
/* Function's name (only) can be used to qualify argument names */
pinfo->fname = pstrdup(NameStr(procedureStruct->proname));
DestReceiver *
CreateSQLFunctionDestReceiver(void)
{
- DR_sqlfunction *self = (DR_sqlfunction *) palloc0(sizeof(DR_sqlfunction));
+ DR_sqlfunction *self = palloc0_object(DR_sqlfunction);
self->pub.receiveSlot = sqlfunction_receive;
self->pub.rStartup = sqlfunction_startup;
aggstate->hash_tapeset = LogicalTapeSetCreate(true, NULL, -1);
- aggstate->hash_spills = palloc(sizeof(HashAggSpill) * aggstate->num_hashes);
+ aggstate->hash_spills = palloc_array(HashAggSpill, aggstate->num_hashes);
for (int setno = 0; setno < aggstate->num_hashes; setno++)
{
}
#endif
- spill->partitions = palloc0(sizeof(LogicalTape *) * npartitions);
- spill->ntuples = palloc0(sizeof(int64) * npartitions);
- spill->hll_card = palloc0(sizeof(hyperLogLogState) * npartitions);
+ spill->partitions = palloc0_array(LogicalTape *, npartitions);
+ spill->ntuples = palloc0_array(int64, npartitions);
+ spill->hll_card = palloc0_array(hyperLogLogState, npartitions);
for (int i = 0; i < npartitions; i++)
spill->partitions[i] = LogicalTapeCreate(tapeset);
hashagg_batch_new(LogicalTape *input_tape, int setno,
int64 input_tuples, double input_card, int used_bits)
{
- HashAggBatch *batch = palloc0(sizeof(HashAggBatch));
+ HashAggBatch *batch = palloc0_object(HashAggBatch);
batch->setno = setno;
batch->used_bits = used_bits;
aggstate->maxsets = numGroupingSets;
aggstate->numphases = numPhases;
- aggstate->aggcontexts = (ExprContext **)
- palloc0(sizeof(ExprContext *) * numGroupingSets);
+ aggstate->aggcontexts = palloc0_array(ExprContext *, numGroupingSets);
/*
* Create expression contexts. We need three or more, one for
* For each phase, prepare grouping set data and fmgr lookup data for
* compare functions. Accumulate all_grouped_cols in passing.
*/
- aggstate->phases = palloc0(numPhases * sizeof(AggStatePerPhaseData));
+ aggstate->phases = palloc0_array(AggStatePerPhaseData, numPhases);
aggstate->num_hashes = numHashes;
if (numHashes)
{
- aggstate->perhash = palloc0(sizeof(AggStatePerHashData) * numHashes);
+ aggstate->perhash = palloc0_array(AggStatePerHashData, numHashes);
aggstate->phases[0].numsets = 0;
- aggstate->phases[0].gset_lengths = palloc(numHashes * sizeof(int));
- aggstate->phases[0].grouped_cols = palloc(numHashes * sizeof(Bitmapset *));
+ aggstate->phases[0].gset_lengths = palloc_array(int, numHashes);
+ aggstate->phases[0].grouped_cols = palloc_array(Bitmapset *, numHashes);
}
phase = 0;
* Build a separate function for each subset of columns that
* need to be compared.
*/
- phasedata->eqfunctions =
- (ExprState **) palloc0(aggnode->numCols * sizeof(ExprState *));
+ phasedata->eqfunctions = palloc0_array(ExprState *, aggnode->numCols);
/* for each grouping set */
for (int k = 0; k < phasedata->numsets; k++)
* allocate my private per-agg working storage
*/
econtext = aggstate->ss.ps.ps_ExprContext;
- econtext->ecxt_aggvalues = (Datum *) palloc0(sizeof(Datum) * numaggs);
- econtext->ecxt_aggnulls = (bool *) palloc0(sizeof(bool) * numaggs);
+ econtext->ecxt_aggvalues = palloc0_array(Datum, numaggs);
+ econtext->ecxt_aggnulls = palloc0_array(bool, numaggs);
- peraggs = (AggStatePerAgg) palloc0(sizeof(AggStatePerAggData) * numaggs);
- pertransstates = (AggStatePerTrans) palloc0(sizeof(AggStatePerTransData) * numtrans);
+ peraggs = palloc0_array(AggStatePerAggData, numaggs);
+ pertransstates = palloc0_array(AggStatePerTransData, numtrans);
aggstate->peragg = peraggs;
aggstate->pertrans = pertransstates;
- aggstate->all_pergroups =
- (AggStatePerGroup *) palloc0(sizeof(AggStatePerGroup)
- * (numGroupingSets + numHashes));
+ aggstate->all_pergroups = palloc0_array(AggStatePerGroup, numGroupingSets + numHashes);
pergroups = aggstate->all_pergroups;
if (node->aggstrategy != AGG_HASHED)
{
for (i = 0; i < numGroupingSets; i++)
{
- pergroups[i] = (AggStatePerGroup) palloc0(sizeof(AggStatePerGroupData)
- * numaggs);
+ pergroups[i] = palloc0_array(AggStatePerGroupData, numaggs);
}
aggstate->pergroups = pergroups;
pfree(ops);
}
- pertrans->sortstates = (Tuplesortstate **)
- palloc0(sizeof(Tuplesortstate *) * numGroupingSets);
+ pertrans->sortstates = palloc0_array(Tuplesortstate *, numGroupingSets);
}
{
AsyncRequest *areq;
- areq = palloc(sizeof(AsyncRequest));
+ areq = palloc_object(AsyncRequest);
areq->requestor = (PlanState *) appendstate;
areq->requestee = appendplanstates[i];
areq->request_index = i;
*/
ExecAssignExprContext(estate, &scanstate->ss.ps);
- scanstate->funcstates = palloc(nfuncs * sizeof(FunctionScanPerFuncState));
+ scanstate->funcstates = palloc_array(FunctionScanPerFuncState, nfuncs);
natts = 0;
i = 0;
int i;
gm_state->gm_nkeys = node->numCols;
- gm_state->gm_sortkeys =
- palloc0(sizeof(SortSupportData) * node->numCols);
+ gm_state->gm_sortkeys = palloc0_array(SortSupportData, node->numCols);
for (i = 0; i < node->numCols; i++)
{
for (i = 0; i < nreaders; i++)
{
/* Allocate the tuple array with length MAX_TUPLE_STORE */
- gm_state->gm_tuple_buffers[i].tuple =
- (MinimalTuple *) palloc0(sizeof(MinimalTuple) * MAX_TUPLE_STORE);
+ gm_state->gm_tuple_buffers[i].tuple = palloc0_array(MinimalTuple, MAX_TUPLE_STORE);
/* Initialize tuple slot for worker */
gm_state->gm_slots[i + 1] =
*/
if (OidIsValid(hash->skewTable))
{
- hashstate->skew_hashfunction = palloc0(sizeof(FmgrInfo));
+ hashstate->skew_hashfunction = palloc0_object(FmgrInfo);
hashstate->skew_collation = linitial_oid(node->hashcollations);
fmgr_info(outer_hashfuncid[0], hashstate->skew_hashfunction);
}
/* accumulate stats from old hash table, if wanted */
/* (this should match ExecShutdownHash) */
if (hashNode->ps.instrument && !hashNode->hinstrument)
- hashNode->hinstrument = (HashInstrumentation *)
- palloc0(sizeof(HashInstrumentation));
+ hashNode->hinstrument = palloc0_object(HashInstrumentation);
if (hashNode->hinstrument)
ExecHashAccumInstrumentation(hashNode->hinstrument,
hashNode->hashtable);
* Now create an array to mark the attribute numbers of the keys that
* need to be converted from cstring to name.
*/
- indexstate->ioss_NameCStringAttNums = (AttrNumber *)
- palloc(sizeof(AttrNumber) * namecount);
+ indexstate->ioss_NameCStringAttNums = palloc_array(AttrNumber, namecount);
for (int attnum = 0; attnum < indnkeyatts; attnum++)
{
ReorderTuple *rt;
int i;
- rt = (ReorderTuple *) palloc(sizeof(ReorderTuple));
+ rt = palloc_object(ReorderTuple);
rt->htup = ExecCopySlotHeapTuple(slot);
- rt->orderbyvals =
- (Datum *) palloc(sizeof(Datum) * scandesc->numberOfOrderBys);
- rt->orderbynulls =
- (bool *) palloc(sizeof(bool) * scandesc->numberOfOrderBys);
+ rt->orderbyvals = palloc_array(Datum, scandesc->numberOfOrderBys);
+ rt->orderbynulls = palloc_array(bool, scandesc->numberOfOrderBys);
for (i = 0; i < node->iss_NumOrderByKeys; i++)
{
if (!orderbynulls[i])
oldcontext = MemoryContextSwitchTo(mstate->tableContext);
/* Allocate a new key */
- entry->key = key = (MemoizeKey *) palloc(sizeof(MemoizeKey));
+ entry->key = key = palloc_object(MemoizeKey);
key->params = ExecCopySlotMinimalTuple(mstate->probeslot);
/* Update the total cache memory utilization */
oldcontext = MemoryContextSwitchTo(mstate->tableContext);
- tuple = (MemoizeTuple *) palloc(sizeof(MemoizeTuple));
+ tuple = palloc_object(MemoizeTuple);
tuple->mintuple = ExecCopySlotMinimalTuple(slot);
tuple->next = NULL;
mergestate->ms_prune_state = NULL;
}
- mergeplanstates = (PlanState **) palloc(nplans * sizeof(PlanState *));
+ mergeplanstates = palloc_array(PlanState *, nplans);
mergestate->mergeplans = mergeplanstates;
mergestate->ms_nplans = nplans;
- mergestate->ms_slots = (TupleTableSlot **) palloc0(sizeof(TupleTableSlot *) * nplans);
+ mergestate->ms_slots = palloc0_array(TupleTableSlot *, nplans);
mergestate->ms_heap = binaryheap_allocate(nplans, heap_compare_slots,
mergestate);
* initialize sort-key information
*/
mergestate->ms_nkeys = node->numCols;
- mergestate->ms_sortkeys = palloc0(sizeof(SortSupportData) * node->numCols);
+ mergestate->ms_sortkeys = palloc0_array(SortSupportData, node->numCols);
for (i = 0; i < node->numCols; i++)
{
oldContext = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
- values = palloc(sizeof(*values) * natts);
- nulls = palloc(sizeof(*nulls) * natts);
+ values = palloc_array(Datum, natts);
+ nulls = palloc_array(bool, natts);
slot_getallattrs(slot);
memcpy(nulls, slot->tts_isnull, sizeof(*nulls) * natts);
if (resultRelInfo->ri_Slots == NULL)
{
- resultRelInfo->ri_Slots = palloc(sizeof(TupleTableSlot *) *
- resultRelInfo->ri_BatchSize);
- resultRelInfo->ri_PlanSlots = palloc(sizeof(TupleTableSlot *) *
- resultRelInfo->ri_BatchSize);
+ resultRelInfo->ri_Slots = palloc_array(TupleTableSlot *, resultRelInfo->ri_BatchSize);
+ resultRelInfo->ri_PlanSlots = palloc_array(TupleTableSlot *, resultRelInfo->ri_BatchSize);
}
/*
mtstate->mt_done = false;
mtstate->mt_nrels = nrels;
- mtstate->resultRelInfo = (ResultRelInfo *)
- palloc(nrels * sizeof(ResultRelInfo));
+ mtstate->resultRelInfo = palloc_array(ResultRelInfo, nrels);
mtstate->mt_merge_pending_not_matched = NULL;
mtstate->mt_merge_inserted = 0;
/* Create workspace for per-tlist-entry expr state & SRF-is-done state */
state->nelems = list_length(node->plan.targetlist);
- state->elems = (Node **)
- palloc(sizeof(Node *) * state->nelems);
- state->elemdone = (ExprDoneCond *)
- palloc(sizeof(ExprDoneCond) * state->nelems);
+ state->elems = palloc_array(Node *, state->nelems);
+ state->elemdone = palloc_array(ExprDoneCond, state->nelems);
/*
* Build expressions to evaluate targetlist. We can't use
ListCell *arg;
scanstate->donetuples = 0;
- params = (Datum *) palloc(list_length(scanstate->args) * sizeof(Datum));
+ params = palloc_array(Datum, list_length(scanstate->args));
i = 0;
foreach(arg, scanstate->args)
scanstate->notnulls = tf->notnulls;
/* these are allocated now and initialized later */
- scanstate->in_functions = palloc(sizeof(FmgrInfo) * tupdesc->natts);
- scanstate->typioparams = palloc(sizeof(Oid) * tupdesc->natts);
+ scanstate->in_functions = palloc_array(FmgrInfo, tupdesc->natts);
+ scanstate->typioparams = palloc_array(Oid, tupdesc->natts);
/*
* Fill in the necessary fmgr infos.
else
elog(ERROR, "could not identify CTID variable");
- tidopexpr = (TidOpExpr *) palloc(sizeof(TidOpExpr));
+ tidopexpr = palloc_object(TidOpExpr);
tidopexpr->inclusive = false; /* for now */
switch (expr->opno)
foreach(l, node->tidquals)
{
Expr *expr = (Expr *) lfirst(l);
- TidExpr *tidexpr = (TidExpr *) palloc0(sizeof(TidExpr));
+ TidExpr *tidexpr = palloc0_object(TidExpr);
if (is_opclause(expr))
{
numfuncs = winstate->numfuncs;
numaggs = winstate->numaggs;
econtext = winstate->ss.ps.ps_ExprContext;
- econtext->ecxt_aggvalues = (Datum *) palloc0(sizeof(Datum) * numfuncs);
- econtext->ecxt_aggnulls = (bool *) palloc0(sizeof(bool) * numfuncs);
+ econtext->ecxt_aggvalues = palloc0_array(Datum, numfuncs);
+ econtext->ecxt_aggnulls = palloc0_array(bool, numfuncs);
/*
* allocate per-wfunc/per-agg state information.
*/
- perfunc = (WindowStatePerFunc) palloc0(sizeof(WindowStatePerFuncData) * numfuncs);
- peragg = (WindowStatePerAgg) palloc0(sizeof(WindowStatePerAggData) * numaggs);
+ perfunc = palloc0_array(WindowStatePerFuncData, numfuncs);
+ peragg = palloc0_array(WindowStatePerAggData, numaggs);
winstate->perfunc = perfunc;
winstate->peragg = peragg;
if (winobj->ignore_nulls == PARSER_IGNORE_NULLS)
{
- winobj->notnull_info = palloc0(sizeof(uint8 *) * numargs);
- winobj->num_notnull_info = palloc0(sizeof(int64) * numargs);
+ winobj->notnull_info = palloc0_array(uint8 *, numargs);
+ winobj->num_notnull_info = palloc0_array(int64, numargs);
}
}
SPI_result = 0;
numberOfAttributes = rel->rd_att->natts;
- v = (Datum *) palloc(numberOfAttributes * sizeof(Datum));
- n = (bool *) palloc(numberOfAttributes * sizeof(bool));
+ v = palloc_array(Datum, numberOfAttributes);
+ n = palloc_array(bool, numberOfAttributes);
/* fetch old values and nulls */
heap_deform_tuple(tuple, rel->rd_att, v, n);
ALLOCSET_DEFAULT_SIZES);
MemoryContextSwitchTo(tuptabcxt);
- _SPI_current->tuptable = tuptable = (SPITupleTable *)
- palloc0(sizeof(SPITupleTable));
+ _SPI_current->tuptable = tuptable = palloc0_object(SPITupleTable);
tuptable->tuptabcxt = tuptabcxt;
tuptable->subid = GetCurrentSubTransactionId();
/* set up initial allocations */
tuptable->alloced = 128;
- tuptable->vals = (HeapTuple *) palloc(tuptable->alloced * sizeof(HeapTuple));
+ tuptable->vals = palloc_array(HeapTuple, tuptable->alloced);
tuptable->numvals = 0;
tuptable->tupdesc = CreateTupleDescCopy(typeinfo);
oldcxt = MemoryContextSwitchTo(plancxt);
/* Copy the _SPI_plan struct and subsidiary data into the new context */
- newplan = (SPIPlanPtr) palloc0(sizeof(_SPI_plan));
+ newplan = palloc0_object(_SPI_plan);
newplan->magic = _SPI_PLAN_MAGIC;
newplan->plancxt = plancxt;
newplan->parse_mode = plan->parse_mode;
newplan->nargs = plan->nargs;
if (plan->nargs > 0)
{
- newplan->argtypes = (Oid *) palloc(plan->nargs * sizeof(Oid));
+ newplan->argtypes = palloc_array(Oid, plan->nargs);
memcpy(newplan->argtypes, plan->argtypes, plan->nargs * sizeof(Oid));
}
else
oldcxt = MemoryContextSwitchTo(plancxt);
/* Copy the SPI plan into its own context */
- newplan = (SPIPlanPtr) palloc0(sizeof(_SPI_plan));
+ newplan = palloc0_object(_SPI_plan);
newplan->magic = _SPI_PLAN_MAGIC;
newplan->plancxt = plancxt;
newplan->parse_mode = plan->parse_mode;
newplan->nargs = plan->nargs;
if (plan->nargs > 0)
{
- newplan->argtypes = (Oid *) palloc(plan->nargs * sizeof(Oid));
+ newplan->argtypes = palloc_array(Oid, plan->nargs);
memcpy(newplan->argtypes, plan->argtypes, plan->nargs * sizeof(Oid));
}
else
if (tdata->tg_newtable)
{
EphemeralNamedRelation enr =
- palloc(sizeof(EphemeralNamedRelationData));
+ palloc_object(EphemeralNamedRelationData);
int rc;
enr->md.name = tdata->tg_trigger->tgnewtable;
if (tdata->tg_oldtable)
{
EphemeralNamedRelation enr =
- palloc(sizeof(EphemeralNamedRelationData));
+ palloc_object(EphemeralNamedRelationData);
int rc;
enr->md.name = tdata->tg_trigger->tgoldtable;
{
TQueueDestReceiver *self;
- self = (TQueueDestReceiver *) palloc0(sizeof(TQueueDestReceiver));
+ self = palloc0_object(TQueueDestReceiver);
self->pub.receiveSlot = tqueueReceiveSlot;
self->pub.rStartup = tqueueStartupReceiver;
TupleQueueReader *
CreateTupleQueueReader(shm_mq_handle *handle)
{
- TupleQueueReader *reader = palloc0(sizeof(TupleQueueReader));
+ TupleQueueReader *reader = palloc0_object(TupleQueueReader);
reader->queue = handle;
DestReceiver *
CreateTuplestoreDestReceiver(void)
{
- TStoreState *self = (TStoreState *) palloc0(sizeof(TStoreState));
+ TStoreState *self = palloc0_object(TStoreState);
self->pub.receiveSlot = tstoreReceiveSlot_notoast; /* might change */
self->pub.rStartup = tstoreStartupReceiver;
fdwform = (Form_pg_foreign_data_wrapper) GETSTRUCT(tp);
- fdw = (ForeignDataWrapper *) palloc(sizeof(ForeignDataWrapper));
+ fdw = palloc_object(ForeignDataWrapper);
fdw->fdwid = fdwid;
fdw->owner = fdwform->fdwowner;
fdw->fdwname = pstrdup(NameStr(fdwform->fdwname));
serverform = (Form_pg_foreign_server) GETSTRUCT(tp);
- server = (ForeignServer *) palloc(sizeof(ForeignServer));
+ server = palloc_object(ForeignServer);
server->serverid = serverid;
server->servername = pstrdup(NameStr(serverform->srvname));
server->owner = serverform->srvowner;
MappingUserName(userid), server->servername)));
}
- um = (UserMapping *) palloc(sizeof(UserMapping));
+ um = palloc_object(UserMapping);
um->umid = ((Form_pg_user_mapping) GETSTRUCT(tp))->oid;
um->userid = userid;
um->serverid = serverid;
elog(ERROR, "cache lookup failed for foreign table %u", relid);
tableform = (Form_pg_foreign_table) GETSTRUCT(tp);
- ft = (ForeignTable *) palloc(sizeof(ForeignTable));
+ ft = palloc_object(ForeignTable);
ft->relid = relid;
ft->serverid = tableform->ftserver;
/* We have valid cached data --- does the caller want a copy? */
if (makecopy)
{
- fdwroutine = (FdwRoutine *) palloc(sizeof(FdwRoutine));
+ fdwroutine = palloc_object(FdwRoutine);
memcpy(fdwroutine, relation->rd_fdwroutine, sizeof(FdwRoutine));
return fdwroutine;
}
if (num_attributes == 0)
return;
- attrs = palloc(sizeof(LLVMAttributeRef) * num_attributes);
+ attrs = palloc_array(LLVMAttributeRef, num_attributes);
LLVMGetAttributesAtIndex(v_from, index, attrs);
for (int attno = 0; attno < num_attributes; attno++)
LLVMOrcCLookupSet LookupSet, size_t LookupSetSize)
{
#if LLVM_VERSION_MAJOR > 14
- LLVMOrcCSymbolMapPairs symbols = palloc0(sizeof(LLVMOrcCSymbolMapPair) * LookupSetSize);
+ LLVMOrcCSymbolMapPairs symbols = palloc0_array(LLVMOrcCSymbolMapPair, LookupSetSize);
#else
- LLVMOrcCSymbolMapPairs symbols = palloc0(sizeof(LLVMJITCSymbolMapPair) * LookupSetSize);
+ LLVMOrcCSymbolMapPairs symbols = palloc0_array(LLVMJITCSymbolMapPair, LookupSetSize);
#endif
LLVMErrorRef error;
LLVMOrcMaterializationUnitRef mu;
b = LLVMCreateBuilderInContext(lc);
- attcheckattnoblocks = palloc(sizeof(LLVMBasicBlockRef) * natts);
- attstartblocks = palloc(sizeof(LLVMBasicBlockRef) * natts);
- attisnullblocks = palloc(sizeof(LLVMBasicBlockRef) * natts);
- attcheckalignblocks = palloc(sizeof(LLVMBasicBlockRef) * natts);
- attalignblocks = palloc(sizeof(LLVMBasicBlockRef) * natts);
- attstoreblocks = palloc(sizeof(LLVMBasicBlockRef) * natts);
+ attcheckattnoblocks = palloc_array(LLVMBasicBlockRef, natts);
+ attstartblocks = palloc_array(LLVMBasicBlockRef, natts);
+ attisnullblocks = palloc_array(LLVMBasicBlockRef, natts);
+ attcheckalignblocks = palloc_array(LLVMBasicBlockRef, natts);
+ attalignblocks = palloc_array(LLVMBasicBlockRef, natts);
+ attstoreblocks = palloc_array(LLVMBasicBlockRef, natts);
known_alignment = 0;
"v.econtext.aggnulls");
/* allocate blocks for each op upfront, so we can do jumps easily */
- opblocks = palloc(sizeof(LLVMBasicBlockRef) * state->steps_len);
+ opblocks = palloc_array(LLVMBasicBlockRef, state->steps_len);
for (int opno = 0; opno < state->steps_len; opno++)
opblocks[opno] = l_bb_append_v(eval_fn, "b.op.%d.start", opno);
v_nullsp = l_ptr_const(nulls, l_ptr(TypeStorageBool));
/* create blocks for checking args */
- b_checknulls = palloc(sizeof(LLVMBasicBlockRef) * nargs);
+ b_checknulls = palloc_array(LLVMBasicBlockRef, nargs);
for (int argno = 0; argno < nargs; argno++)
{
b_checknulls[argno] =
*/
{
- CompiledExprState *cstate = palloc0(sizeof(CompiledExprState));
+ CompiledExprState *cstate = palloc0_object(CompiledExprState);
cstate->context = context;
cstate->funcname = funcname;
elog(ERROR, "parameter mismatch: %s expects %d passed %d",
funcname, LLVMCountParams(v_fn), nargs + 2);
- params = palloc(sizeof(LLVMValueRef) * (2 + nargs));
+ params = palloc_array(LLVMValueRef, (2 + nargs));
params[argno++] = v_state;
params[argno++] = l_ptr_const(op, l_ptr(StructExprEvalStep));
BipartiteMatchState *
BipartiteMatch(int u_size, int v_size, short **adjacency)
{
- BipartiteMatchState *state = palloc(sizeof(BipartiteMatchState));
+ BipartiteMatchState *state = palloc_object(BipartiteMatchState);
if (u_size < 0 || u_size >= SHRT_MAX ||
v_size < 0 || v_size >= SHRT_MAX)
dsa_pointer control;
/* Allocate the backend-local object representing the hash table. */
- hash_table = palloc(sizeof(dshash_table));
+ hash_table = palloc_object(dshash_table);
/* Allocate the control object in shared memory. */
control = dsa_allocate(area, sizeof(dshash_table_control));
dsa_pointer control;
/* Allocate the backend-local object representing the hash table. */
- hash_table = palloc(sizeof(dshash_table));
+ hash_table = palloc_object(dshash_table);
/* Find the control object in shared memory. */
control = handle;
{
IntegerSet *intset;
- intset = (IntegerSet *) palloc(sizeof(IntegerSet));
+ intset = palloc_object(IntegerSet);
intset->context = CurrentMemoryContext;
intset->mem_used = GetMemoryChunkSpace(intset);
{
pairingheap *heap;
- heap = (pairingheap *) palloc(sizeof(pairingheap));
+ heap = palloc_object(pairingheap);
pairingheap_initialize(heap, compare, arg);
return heap;
rbt_freefunc freefunc,
void *arg)
{
- RBTree *tree = (RBTree *) palloc(sizeof(RBTree));
+ RBTree *tree = palloc_object(RBTree);
Assert(node_size > sizeof(RBTNode));
errcode(ERRCODE_PROTOCOL_VIOLATION),
errmsg("client selected an invalid SASL authentication mechanism"));
- ctx = palloc0(sizeof(*ctx));
+ ctx = palloc0_object(struct oauth_ctx);
ctx->state = OAUTH_STATE_INIT;
ctx->port = port;
errmsg("validation of OAuth token requested without a validator loaded"));
/* Call the validation function from the validator module */
- ret = palloc0(sizeof(ValidatorModuleResult));
+ ret = palloc0_object(ValidatorModuleResult);
if (!ValidatorCallbacks->validate_cb(validator_module_state, token,
port->user_name, ret))
{
"OAuth validator", libname, "validate_cb"));
/* Allocate memory for validator library private state data */
- validator_module_state = (ValidatorModuleState *) palloc0(sizeof(ValidatorModuleState));
+ validator_module_state = palloc0_object(ValidatorModuleState);
validator_module_state->sversion = PG_VERSION_NUM;
if (ValidatorCallbacks->startup_cb != NULL)
ValidatorCallbacks->startup_cb(validator_module_state);
/* Shut down the library before cleaning up its state. */
- mcb = palloc0(sizeof(*mcb));
+ mcb = palloc0_object(MemoryContextCallback);
mcb->func = shutdown_validator_library;
MemoryContextRegisterResetCallback(CurrentMemoryContext, mcb);
scram_state *state;
bool got_secret;
- state = (scram_state *) palloc0(sizeof(scram_state));
+ state = palloc0_object(scram_state);
state->port = port;
state->state = SCRAM_AUTH_INIT;
if (token->string[0] != '/')
return 0; /* nothing to compile */
- token->regex = (regex_t *) palloc0(sizeof(regex_t));
+ token->regex = palloc0_object(regex_t);
wstr = palloc((strlen(token->string + 1) + 1) * sizeof(pg_wchar));
wlen = pg_mb2wchar_with_len(token->string + 1,
wstr, strlen(token->string + 1));
* to this list.
*/
oldcxt = MemoryContextSwitchTo(tokenize_context);
- tok_line = (TokenizedAuthLine *) palloc0(sizeof(TokenizedAuthLine));
+ tok_line = palloc0_object(TokenizedAuthLine);
tok_line->fields = current_line;
tok_line->file_name = pstrdup(filename);
tok_line->line_num = line_number;
AuthToken *token;
HbaLine *parsedline;
- parsedline = palloc0(sizeof(HbaLine));
+ parsedline = palloc0_object(HbaLine);
parsedline->sourcefile = pstrdup(file_name);
parsedline->linenumber = line_num;
parsedline->rawline = pstrdup(tok_line->raw_line);
}
/* If no matching entry was found, then implicitly reject. */
- hba = palloc0(sizeof(HbaLine));
+ hba = palloc0_object(HbaLine);
hba->auth_method = uaImplicitReject;
port->hba = hba;
}
Assert(tok_line->fields != NIL);
field = list_head(tok_line->fields);
- parsedline = palloc0(sizeof(IdentLine));
+ parsedline = palloc0_object(IdentLine);
parsedline->linenumber = line_num;
/* Get the map token (must exist) */
int latch_pos PG_USED_FOR_ASSERTS_ONLY;
/* allocate the Port struct and copy the ClientSocket contents to it */
- port = palloc0(sizeof(Port));
+ port = palloc0_object(Port);
port->sock = client_sock->sock;
memcpy(&port->raddr.addr, &client_sock->raddr.addr, client_sock->raddr.salen);
port->raddr.salen = client_sock->raddr.salen;
*/
#define FLATCOPY(newnode, node, nodetype) \
- ( (newnode) = (nodetype *) palloc(sizeof(nodetype)), \
+ ( (newnode) = palloc_object(nodetype), \
memcpy((newnode), (node), sizeof(nodetype)) )
#define MUTATE(newfield, oldfield, fieldtype) \
{
JumbleState *jstate;
- jstate = (JumbleState *) palloc(sizeof(JumbleState));
+ jstate = palloc_object(JumbleState);
/* Set up workspace for query jumbling */
jstate->jumble = (unsigned char *) palloc(JUMBLE_SIZE);
* Create the TBMPrivateIterator struct, with enough trailing space to
* serve the needs of the TBMIterateResult sub-struct.
*/
- iterator = (TBMPrivateIterator *) palloc(sizeof(TBMPrivateIterator));
+ iterator = palloc_object(TBMPrivateIterator);
iterator->tbm = tbm;
/*
* Create the TBMSharedIterator struct, with enough trailing space to
* serve the needs of the TBMIterateResult sub-struct.
*/
- iterator = (TBMSharedIterator *) palloc0(sizeof(TBMSharedIterator));
+ iterator = palloc0_object(TBMSharedIterator);
istate = (TBMSharedIteratorState *) dsa_get_address(dsa, dp);
* directly; 0 will not be used
*/
- edge_table = (Edge *) palloc((num_gene + 1) * sizeof(Edge));
+ edge_table = palloc_array(Edge, num_gene + 1);
return edge_table;
}
cur_rel_index - 1);
/* Make it into a single-rel clump */
- cur_clump = (Clump *) palloc(sizeof(Clump));
+ cur_clump = palloc_object(Clump);
cur_clump->joinrel = cur_rel;
cur_clump->size = 1;
void
pmx(PlannerInfo *root, Gene *tour1, Gene *tour2, Gene *offspring, int num_gene)
{
- int *failed = (int *) palloc((num_gene + 1) * sizeof(int));
- int *from = (int *) palloc((num_gene + 1) * sizeof(int));
- int *indx = (int *) palloc((num_gene + 1) * sizeof(int));
- int *check_list = (int *) palloc((num_gene + 1) * sizeof(int));
+ int *failed = palloc_array(int, num_gene + 1);
+ int *from = palloc_array(int, num_gene + 1);
+ int *indx = palloc_array(int, num_gene + 1);
+ int *check_list = palloc_array(int, num_gene + 1);
int left,
right,
int i;
/* pool */
- new_pool = (Pool *) palloc(sizeof(Pool));
+ new_pool = palloc_object(Pool);
new_pool->size = pool_size;
new_pool->string_length = string_length;
/* all chromosome */
- new_pool->data = (Chromosome *) palloc(pool_size * sizeof(Chromosome));
+ new_pool->data = palloc_array(Chromosome, pool_size);
/* all gene */
chromo = (Chromosome *) new_pool->data; /* vector of all chromos */
for (i = 0; i < pool_size; i++)
- chromo[i].string = palloc((string_length + 1) * sizeof(Gene));
+ chromo[i].string = palloc_array(Gene, string_length + 1);
return new_pool;
}
{
Chromosome *chromo;
- chromo = (Chromosome *) palloc(sizeof(Chromosome));
- chromo->string = (Gene *) palloc((string_length + 1) * sizeof(Gene));
+ chromo = palloc_object(Chromosome);
+ chromo->string = palloc_array(Gene, string_length + 1);
return chromo;
}
* palloc one extra location so that nodes numbered 1..n can be indexed
* directly; 0 will not be used
*/
- city_table = (City *) palloc((num_gene + 1) * sizeof(City));
+ city_table = palloc_array(City, num_gene + 1);
return city_table;
}
}
/* No matching var found, so make a new clause-pair data structure */
- rqelem = (RangeQueryClause *) palloc(sizeof(RangeQueryClause));
+ rqelem = palloc_object(RangeQueryClause);
rqelem->var = var;
if (is_lobound)
{
* whichever is less.
*/
arrlen = Min(parallel_workers, numpaths);
- costarr = (Cost *) palloc(sizeof(Cost) * arrlen);
+ costarr = palloc_array(Cost, arrlen);
/* The first few paths will each be claimed by a different worker. */
path_index = 0;
/* Cache the result in suitably long-lived workspace */
oldcontext = MemoryContextSwitchTo(root->planner_cxt);
- cache = (MergeScanSelCache *) palloc(sizeof(MergeScanSelCache));
+ cache = palloc_object(MergeScanSelCache);
cache->opfamily = pathkey->pk_opfamily;
cache->collation = pathkey->pk_eclass->ec_collation;
cache->cmptype = pathkey->pk_cmptype;
* which will be used to sort these arguments at the next step.
*/
i = -1;
- matches = (OrArgIndexMatch *) palloc(sizeof(OrArgIndexMatch) * n);
+ matches = palloc_array(OrArgIndexMatch, n);
foreach(lc, orargs)
{
Node *arg = lfirst(lc);
* same set of clauses; keep only the cheapest-to-scan of any such groups.
* The surviving paths are put into an array for qsort'ing.
*/
- pathinfoarray = (PathClauseUsage **)
- palloc(npaths * sizeof(PathClauseUsage *));
+ pathinfoarray = palloc_array(PathClauseUsage *, npaths);
clauselist = NIL;
npaths = 0;
foreach(l, paths)
Bitmapset *clauseids;
ListCell *lc;
- result = (PathClauseUsage *) palloc(sizeof(PathClauseUsage));
+ result = palloc_object(PathClauseUsage);
result->path = path;
/* Recursively find the quals and preds used by the path */
Assert(nparts > 0);
joinrel->boundinfo = boundinfo;
joinrel->nparts = nparts;
- joinrel->part_rels =
- (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * nparts);
+ joinrel->part_rels = palloc0_array(RelOptInfo *, nparts);
}
else
{
* In order to find relations with the same oid we first build an array of
* candidates and then sort it by oid.
*/
- candidates = (SelfJoinCandidate *) palloc(sizeof(SelfJoinCandidate) *
- numRels);
+ candidates = palloc_array(SelfJoinCandidate, numRels);
i = -1;
j = 0;
while ((i = bms_next_member(relids, i)) >= 0)
Assert(grouping_map);
- new_grpColIdx = palloc0(sizeof(AttrNumber) * list_length(groupClause));
+ new_grpColIdx = palloc0_array(AttrNumber, list_length(groupClause));
i = 0;
foreach(lc, groupClause)
* Convert SortGroupClause lists into arrays of attr indexes and equality
* operators, as wanted by executor.
*/
- partColIdx = (AttrNumber *) palloc(sizeof(AttrNumber) * numPart);
- partOperators = (Oid *) palloc(sizeof(Oid) * numPart);
- partCollations = (Oid *) palloc(sizeof(Oid) * numPart);
+ partColIdx = palloc_array(AttrNumber, numPart);
+ partOperators = palloc_array(Oid, numPart);
+ partCollations = palloc_array(Oid, numPart);
partNumCols = 0;
foreach(lc, wc->partitionClause)
partNumCols++;
}
- ordColIdx = (AttrNumber *) palloc(sizeof(AttrNumber) * numOrder);
- ordOperators = (Oid *) palloc(sizeof(Oid) * numOrder);
- ordCollations = (Oid *) palloc(sizeof(Oid) * numOrder);
+ ordColIdx = palloc_array(AttrNumber, numOrder);
+ ordOperators = palloc_array(Oid, numOrder);
+ ordCollations = palloc_array(Oid, numOrder);
ordNumCols = 0;
foreach(lc, wc->orderClause)
Oid *dupCollations;
ListCell *slitem;
- dupColIdx = (AttrNumber *) palloc(sizeof(AttrNumber) * numCols);
- dupOperators = (Oid *) palloc(sizeof(Oid) * numCols);
- dupCollations = (Oid *) palloc(sizeof(Oid) * numCols);
+ dupColIdx = palloc_array(AttrNumber, numCols);
+ dupOperators = palloc_array(Oid, numCols);
+ dupCollations = palloc_array(Oid, numCols);
foreach(slitem, distinctList)
{
* prepare_sort_from_pathkeys ... maybe unify sometime?
*/
Assert(numCols >= 0 && numCols <= list_length(pathkeys));
- uniqColIdx = (AttrNumber *) palloc(sizeof(AttrNumber) * numCols);
- uniqOperators = (Oid *) palloc(sizeof(Oid) * numCols);
- uniqCollations = (Oid *) palloc(sizeof(Oid) * numCols);
+ uniqColIdx = palloc_array(AttrNumber, numCols);
+ uniqOperators = palloc_array(Oid, numCols);
+ uniqCollations = palloc_array(Oid, numCols);
foreach(lc, pathkeys)
{
* convert SortGroupClause list into arrays of attr indexes and comparison
* operators, as wanted by executor
*/
- cmpColIdx = (AttrNumber *) palloc(sizeof(AttrNumber) * numCols);
- cmpOperators = (Oid *) palloc(sizeof(Oid) * numCols);
- cmpCollations = (Oid *) palloc(sizeof(Oid) * numCols);
- cmpNullsFirst = (bool *) palloc(sizeof(bool) * numCols);
+ cmpColIdx = palloc_array(AttrNumber, numCols);
+ cmpOperators = palloc_array(Oid, numCols);
+ cmpCollations = palloc_array(Oid, numCols);
+ cmpNullsFirst = palloc_array(bool, numCols);
foreach(slitem, groupList)
{
* Fill groupbyattnos[k] with a bitmapset of the column attnos of RTE k
* that are GROUP BY items.
*/
- groupbyattnos = (Bitmapset **) palloc0(sizeof(Bitmapset *) *
- (list_length(parse->rtable) + 1));
+ groupbyattnos = palloc0_array(Bitmapset *, list_length(parse->rtable) + 1);
foreach(lc, root->processed_groupClause)
{
SortGroupClause *sgc = lfirst_node(SortGroupClause, lc);
* allocate the surplusvars[] array until we find something.
*/
if (surplusvars == NULL)
- surplusvars = (Bitmapset **) palloc0(sizeof(Bitmapset *) *
- (list_length(parse->rtable) + 1));
+ surplusvars = palloc0_array(Bitmapset *, list_length(parse->rtable) + 1);
/* Remember the attnos of the removable columns */
surplusvars[relid] = bms_difference(relattnos, best_keycolumns);
* than before. (This means that when we are done, there will be no Vars
* of level 1, which is why the subquery can become an initplan.)
*/
- subroot = (PlannerInfo *) palloc(sizeof(PlannerInfo));
+ subroot = palloc_object(PlannerInfo);
memcpy(subroot, root, sizeof(PlannerInfo));
subroot->query_level++;
subroot->parent_root = root;
List *sets;
int maxref = 0;
ListCell *lc_set;
- grouping_sets_data *gd = palloc0(sizeof(grouping_sets_data));
+ grouping_sets_data *gd = palloc0_object(grouping_sets_data);
/*
* We don't currently make any attempt to optimize the groupClause when
List *result = NIL;
ListCell *lc;
int nActive = 0;
- WindowClauseSortData *actives = palloc(sizeof(WindowClauseSortData)
- * list_length(windowClause));
+ WindowClauseSortData *actives = palloc_array(WindowClauseSortData,
+ list_length(windowClause));
/* First, construct an array of the active windows */
foreach(lc, windowClause)
root->simple_rte_array[rc->rti] != NULL);
/* flat copy is enough since all fields are scalars */
- newrc = (PlanRowMark *) palloc(sizeof(PlanRowMark));
+ newrc = palloc_object(PlanRowMark);
memcpy(newrc, rc, sizeof(PlanRowMark));
/* adjust indexes ... but *not* the rowmarkId */
RangeTblEntry *newrte;
/* flat copy to duplicate all the scalar fields */
- newrte = (RangeTblEntry *) palloc(sizeof(RangeTblEntry));
+ newrte = palloc_object(RangeTblEntry);
memcpy(newrte, rte, sizeof(RangeTblEntry));
/* zap unneeded sub-structure */
static inline Var *
copyVar(Var *var)
{
- Var *newvar = (Var *) palloc(sizeof(Var));
+ Var *newvar = palloc_object(Var);
*newvar = *var;
return newvar;
* Make a modifiable copy of join node, but don't bother copying its
* subnodes (yet).
*/
- j = (JoinExpr *) palloc(sizeof(JoinExpr));
+ j = palloc_object(JoinExpr);
memcpy(j, jtnode, sizeof(JoinExpr));
jtlink = (Node *) j;
{
reduce_outer_joins_pass1_state *result;
- result = (reduce_outer_joins_pass1_state *)
- palloc(sizeof(reduce_outer_joins_pass1_state));
+ result = palloc_object(reduce_outer_joins_pass1_state);
result->relids = NULL;
result->contains_outer = false;
result->sub_states = NIL;
{
reduce_outer_joins_partial_state *statep;
- statep = palloc(sizeof(reduce_outer_joins_partial_state));
+ statep = palloc_object(reduce_outer_joins_partial_state);
statep->full_join_rti = rtindex;
statep->unreduced_side = relids;
state2->partial_reduced = lappend(state2->partial_reduced, statep);
* If the inputs all agree on type and typmod of a particular column, use
* that typmod; else use -1.
*/
- colTypmods = (int32 *) palloc(list_length(colTypes) * sizeof(int32));
+ colTypmods = palloc_array(int32, list_length(colTypes));
foreach(tlistl, input_tlists)
{
int i;
/* Allocate an array that's certainly big enough */
- appinfos = (AppendRelInfo **)
- palloc(sizeof(AppendRelInfo *) * bms_num_members(relids));
+ appinfos = palloc_array(AppendRelInfo *, bms_num_members(relids));
i = -1;
while ((i = bms_next_member(relids, i)) >= 0)
WindowFuncLists *
find_window_functions(Node *clause, Index maxWinRef)
{
- WindowFuncLists *lists = palloc(sizeof(WindowFuncLists));
+ WindowFuncLists *lists = palloc_object(WindowFuncLists);
lists->numWindowFuncs = 0;
lists->maxWinRef = maxWinRef;
get_typlenbyvalalign(coltype, &typlen, &typbyval, &typalign);
- elems = (Datum *) palloc(sizeof(Datum) * list_length(exprs));
- nulls = (bool *) palloc(sizeof(bool) * list_length(exprs));
+ elems = palloc_array(Datum, list_length(exprs));
+ nulls = palloc_array(bool, list_length(exprs));
foreach_node(Const, value, exprs)
{
elems[i] = value->constvalue;
int i;
i = pg_nextpower2_32(extension_id + 1);
- glob->extension_state = (void **)
- repalloc0(glob->extension_state,
- glob->extension_state_allocated * sizeof(void *),
- i * sizeof(void *));
+ glob->extension_state = repalloc0_array(glob->extension_state, void *,
+ glob->extension_state_allocated, i);
glob->extension_state_allocated = i;
}
int i;
i = pg_nextpower2_32(extension_id + 1);
- root->extension_state = (void **)
- repalloc0(root->extension_state,
- root->extension_state_allocated * sizeof(void *),
- i * sizeof(void *));
+ root->extension_state = repalloc0_array(root->extension_state, void *,
+ root->extension_state_allocated, i);
root->extension_state_allocated = i;
}
int i;
i = pg_nextpower2_32(extension_id + 1);
- rel->extension_state = (void **)
- repalloc0(rel->extension_state,
- rel->extension_state_allocated * sizeof(void *),
- i * sizeof(void *));
+ rel->extension_state = repalloc0_array(rel->extension_state, void *,
+ rel->extension_state_allocated, i);
rel->extension_state_allocated = i;
}
projects / postgresql.git / commitdiff