}
else
{
- ipd = (ItemPointer) palloc(sizeof(ItemPointerData) * nipd);
+ ipd = palloc_array(ItemPointerData, nipd);
memcpy(ipd, ptr, sizeof(ItemPointerData) * nipd);
}
*nitems = nipd;
leafdepth = -1;
/* Start the scan at the root page */
- stack = (GinPostingTreeScanItem *) palloc0(sizeof(GinPostingTreeScanItem));
+ stack = palloc0_object(GinPostingTreeScanItem);
stack->depth = 0;
ItemPointerSetInvalid(&stack->parentkey);
stack->parentblk = InvalidBlockNumber;
stack->blkno, i)));
/* This is an internal page, recurse into the child. */
- ptr = (GinPostingTreeScanItem *) palloc(sizeof(GinPostingTreeScanItem));
+ ptr = palloc_object(GinPostingTreeScanItem);
ptr->depth = stack->depth + 1;
/*
leafdepth = -1;
/* Start the scan at the root page */
- stack = (GinScanItem *) palloc0(sizeof(GinScanItem));
+ stack = palloc0_object(GinScanItem);
stack->depth = 0;
stack->parenttup = NULL;
stack->parentblk = InvalidBlockNumber;
elog(DEBUG3, "split detected for blk: %u, parent blk: %u", stack->blkno, stack->parentblk);
- ptr = (GinScanItem *) palloc(sizeof(GinScanItem));
+ ptr = palloc_object(GinScanItem);
ptr->depth = stack->depth;
ptr->parenttup = CopyIndexTuple(stack->parenttup);
ptr->parentblk = stack->parentblk;
{
GinScanItem *ptr;
- ptr = (GinScanItem *) palloc(sizeof(GinScanItem));
+ ptr = palloc_object(GinScanItem);
ptr->depth = stack->depth + 1;
/* last tuple in layer has no high key */
if (i == maxoff && rightlink == InvalidBlockNumber)
{
ToastedAttribute *ta;
- ta = (ToastedAttribute *) palloc0(sizeof(ToastedAttribute));
+ ta = palloc0_object(ToastedAttribute);
VARATT_EXTERNAL_GET_POINTER(ta->toast_pointer, attr);
ta->blkno = ctx->blkno;
/*
* Initialize state for entire verification operation
*/
- state = palloc0(sizeof(BtreeCheckState));
+ state = palloc0_object(BtreeCheckState);
state->rel = rel;
state->heaprel = heaprel;
state->heapkeyspace = heapkeyspace;
* We remember the current value of basebackup_to_shell.shell_command to
* be certain that it can't change under us during the backup.
*/
- sink = palloc0(sizeof(bbsink_shell));
+ sink = palloc0_object(bbsink_shell);
*((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_shell_ops;
sink->base.bbs_next = next_sink;
sink->target_detail = detail_arg;
MemoryContextDelete(buildstate.tmpCtx);
- result = (IndexBuildResult *) palloc(sizeof(IndexBuildResult));
+ result = palloc_object(IndexBuildResult);
result->heap_tuples = reltuples;
result->index_tuples = buildstate.indtuples;
scan = RelationGetIndexScan(r, nkeys, norderbys);
- so = (BloomScanOpaque) palloc(sizeof(BloomScanOpaqueData));
+ so = (BloomScanOpaque) palloc_object(BloomScanOpaqueData);
initBloomState(&so->state, scan->indexRelation);
so->sign = NULL;
/* New search: have to calculate search signature */
ScanKey skey = scan->keyData;
- so->sign = palloc0(sizeof(BloomSignatureWord) * so->state.opts.bloomLength);
+ so->sign = palloc0_array(BloomSignatureWord, so->state.opts.bloomLength);
for (i = 0; i < scan->numberOfKeys; i++)
{
BloomOptions *opts;
int i;
- opts = (BloomOptions *) palloc0(sizeof(BloomOptions));
+ opts = palloc0_object(BloomOptions);
/* Convert DEFAULT_BLOOM_LENGTH from # of bits to # of words */
opts->bloomLength = (DEFAULT_BLOOM_LENGTH + SIGNWORDBITS - 1) / SIGNWORDBITS;
for (i = 0; i < INDEX_MAX_KEYS; i++)
GenericXLogState *gxlogState;
if (stats == NULL)
- stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+ stats = palloc0_object(IndexBulkDeleteResult);
initBloomState(&state, index);
return stats;
if (stats == NULL)
- stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+ stats = palloc0_object(IndexBulkDeleteResult);
/*
* Iterate over the pages: insert deleted pages into FSM and collect
{
Datum datum = PG_GETARG_DATUM(0);
int32 *nentries = (int32 *) PG_GETARG_POINTER(1);
- Datum *entries = (Datum *) palloc(sizeof(Datum));
+ Datum *entries = palloc_object(Datum);
/* Ensure that values stored in the index are not toasted */
if (is_varlena)
StrategyNumber strategy = PG_GETARG_UINT16(2);
bool **partialmatch = (bool **) PG_GETARG_POINTER(3);
Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4);
- Datum *entries = (Datum *) palloc(sizeof(Datum));
- QueryInfo *data = (QueryInfo *) palloc(sizeof(QueryInfo));
- bool *ptr_partialmatch = (bool *) palloc(sizeof(bool));
+ Datum *entries = palloc_object(Datum);
+ QueryInfo *data = palloc_object(QueryInfo);
+ bool *ptr_partialmatch = palloc_object(bool);
int btree_strat,
rhs_code;
data->orig_datum = datum;
data->entry_datum = entries[0];
data->typecmp = cmp_fns[rhs_code];
- *extra_data = (Pointer *) palloc(sizeof(Pointer));
+ *extra_data = palloc_object(Pointer);
**extra_data = (Pointer) data;
PG_RETURN_POINTER(entries);
static Datum
leftmostvalue_timetz(void)
{
- TimeTzADT *v = palloc(sizeof(TimeTzADT));
+ TimeTzADT *v = palloc_object(TimeTzADT);
v->time = 0;
v->zone = -24 * 3600; /* XXX is that true? */
static Datum
leftmostvalue_interval(void)
{
- Interval *v = palloc(sizeof(Interval));
+ Interval *v = palloc_object(Interval);
INTERVAL_NOBEGIN(v);
static Datum
leftmostvalue_macaddr(void)
{
- macaddr *v = palloc0(sizeof(macaddr));
+ macaddr *v = palloc0_object(macaddr);
return MacaddrPGetDatum(v);
}
static Datum
leftmostvalue_macaddr8(void)
{
- macaddr8 *v = palloc0(sizeof(macaddr8));
+ macaddr8 *v = palloc0_object(macaddr8);
return Macaddr8PGetDatum(v);
}
* palloc0 will create the UUID with all zeroes:
* "00000000-0000-0000-0000-000000000000"
*/
- pg_uuid_t *retval = (pg_uuid_t *) palloc0(sizeof(pg_uuid_t));
+ pg_uuid_t *retval = palloc0_object(pg_uuid_t);
return UUIDPGetDatum(retval);
}
if (entry->leafkey)
{
- inetKEY *r = (inetKEY *) palloc(sizeof(inetKEY));
+ inetKEY *r = palloc_object(inetKEY);
bool failure = false;
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
r->lower = convert_network_to_scalar(entry->key, INETOID, &failure);
Assert(!failure);
r->upper = r->lower;
{
char *r = (char *) palloc(2 * INTERVALSIZE);
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
if (entry->leafkey)
{
if (INTERVALSIZE != sizeof(Interval))
{
- intvKEY *r = palloc(sizeof(intvKEY));
+ intvKEY *r = palloc_object(intvKEY);
char *key = DatumGetPointer(entry->key);
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
memcpy(&r->lower, key, INTERVALSIZE);
memcpy(&r->upper, key + INTERVALSIZE, INTERVALSIZE);
if (entry->leafkey)
{
- timeKEY *r = (timeKEY *) palloc(sizeof(timeKEY));
+ timeKEY *r = palloc_object(timeKEY);
TimeTzADT *tz = DatumGetTimeTzADTP(entry->key);
TimeADT tmp;
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
/* We are using the time + zone only to compress */
tmp = tz->time + (tz->zone * INT64CONST(1000000));
if (TIMESTAMP_NOT_FINITE(a) || TIMESTAMP_NOT_FINITE(b))
{
- Interval *p = palloc(sizeof(Interval));
+ Interval *p = palloc_object(Interval);
p->day = INT_MAX;
p->month = INT_MAX;
if (TIMESTAMP_NOT_FINITE(a) || TIMESTAMP_NOT_FINITE(b))
{
- Interval *p = palloc(sizeof(Interval));
+ Interval *p = palloc_object(Interval);
p->day = INT_MAX;
p->month = INT_MAX;
if (entry->leafkey)
{
- tsKEY *r = (tsKEY *) palloc(sizeof(tsKEY));
+ tsKEY *r = palloc_object(tsKEY);
TimestampTz ts = DatumGetTimestampTz(entry->key);
Timestamp gmt;
gmt = tstz_to_ts_gmt(ts);
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
r->lower = r->upper = gmt;
gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page,
memcpy(&r[0], leaf, tinfo->size);
memcpy(&r[tinfo->size], leaf, tinfo->size);
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page,
entry->offset, false);
}
datum = entry->key;
}
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, datum, entry->rel, entry->page, entry->offset,
false);
return retval;
if (key != (GBT_VARKEY *) DatumGetPointer(entry->key))
{
- GISTENTRY *retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+ GISTENTRY *retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(key),
entry->rel, entry->page,
r = gbt_var_key_from_datum(leaf);
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page,
entry->offset, true);
GBT_VARKEY_R r = gbt_var_key_readable(key);
GISTENTRY *retval;
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(r.lower),
entry->rel, entry->page,
entry->offset, true);
char *r = (char *) palloc(2 * UUID_LEN);
pg_uuid_t *key = DatumGetUUIDP(entry->key);
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
memcpy(r, key, UUID_LEN);
memcpy(r + UUID_LEN, key, UUID_LEN);
if (key != DatumGetNDBOXP(entry->key))
{
- GISTENTRY *retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+ GISTENTRY *retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(key),
entry->rel, entry->page,
DictInt *d;
ListCell *l;
- d = (DictInt *) palloc0(sizeof(DictInt));
+ d = palloc0_object(DictInt);
d->maxlen = 6;
d->rejectlong = false;
d->absval = false;
char *in = (char *) PG_GETARG_POINTER(1);
int len = PG_GETARG_INT32(2);
char *txt;
- TSLexeme *res = palloc0(sizeof(TSLexeme) * 2);
+ TSLexeme *res = palloc0_array(TSLexeme, 2);
res[1].lexeme = NULL;
{
d->len = (d->len > 0) ? 2 * d->len : 16;
if (d->syn)
- d->syn = (Syn *) repalloc(d->syn, sizeof(Syn) * d->len);
+ d->syn = repalloc_array(d->syn, Syn, d->len);
else
- d->syn = (Syn *) palloc(sizeof(Syn) * d->len);
+ d->syn = palloc_array(Syn, d->len);
}
/* Save first word only if we will match it */
ListCell *l;
char *filename = NULL;
- d = (DictSyn *) palloc0(sizeof(DictSyn));
+ d = palloc0_object(DictSyn);
d->len = 0;
d->syn = NULL;
d->matchorig = true;
char *end;
int nsyns = 0;
- res = palloc(sizeof(TSLexeme));
+ res = palloc_object(TSLexeme);
pos = value;
while ((syn = find_word(pos, &end)) != NULL)
* we might as well get everything and not need to re-fetch it later in
* planning.
*/
- fdw_private = (FileFdwPlanState *) palloc(sizeof(FileFdwPlanState));
+ fdw_private = palloc_object(FileFdwPlanState);
fileGetOptions(foreigntableid,
&fdw_private->filename,
&fdw_private->is_program,
* Save state in node->fdw_state. We must save enough information to call
* BeginCopyFrom() again.
*/
- festate = (FileFdwExecutionState *) palloc(sizeof(FileFdwExecutionState));
+ festate = palloc_object(FileFdwExecutionState);
festate->filename = filename;
festate->is_program = is_program;
festate->options = options;
}
}
- retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(res),
entry->rel, entry->page,
entry->offset,
res = ghstore_alloc(true, siglen, NULL);
- retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(res),
entry->rel, entry->page,
entry->offset,
maxoff = OffsetNumberNext(maxoff);
/* sort before ... */
- costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff);
+ costvector = palloc_array(SPLITCOST, maxoff);
for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
{
costvector[j - 1].pos = j;
bool escaped = false;
state->plen = 16;
- state->pairs = (Pairs *) palloc(sizeof(Pairs) * state->plen);
+ state->pairs = palloc_array(Pairs, state->plen);
state->pcur = 0;
state->ptr = state->begin;
state->word = NULL;
static void
pushquery(WORKSTATE *state, int32 type, int32 val)
{
- NODE *tmp = (NODE *) palloc(sizeof(NODE));
+ NODE *tmp = palloc_object(NODE);
tmp->type = type;
tmp->val = val;
* extraction code in ginint4_queryextract.
*/
gcv.first = items;
- gcv.mapped_check = (bool *) palloc(sizeof(bool) * query->size);
+ gcv.mapped_check = palloc_array(bool, query->size);
for (i = 0; i < query->size; i++)
{
if (items[i].type == VAL)
nrm.curpol = in->curpol;
nrm.buflen = 16;
- nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
+ nrm.cur = nrm.buf = palloc_array(char, nrm.buflen);
/* get right operand */
infix(&nrm, false);
nrm.curpol = GETQUERY(query) + query->size - 1;
nrm.buflen = 32;
- nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
+ nrm.cur = nrm.buf = palloc_array(char, nrm.buflen);
*(nrm.cur) = '\0';
infix(&nrm, true);
/*
* Extract all the VAL items as things we want GIN to check for.
*/
- res = (Datum *) palloc(sizeof(Datum) * query->size);
+ res = palloc_array(Datum, query->size);
*nentries = 0;
for (i = 0; i < query->size; i++)
int32 *arr;
int32 i;
- res = (Datum *) palloc(sizeof(Datum) * (*nentries));
+ res = palloc_array(Datum, *nentries);
arr = ARRPTR(query);
for (i = 0; i < *nentries; i++)
errmsg("input array is too big (%d maximum allowed, %d current), use gist__intbig_ops opclass instead",
2 * num_ranges - 1, ARRNELEMS(r))));
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page, entry->offset, false);
errmsg("data is too sparse, recreate index using gist__intbig_ops opclass instead")));
r = resize_intArrayType(r, len);
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page, entry->offset, false);
PG_RETURN_POINTER(retval);
{
if (in != (ArrayType *) DatumGetPointer(entry->key))
{
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(in),
entry->rel, entry->page, entry->offset, false);
PG_RETURN_POINTER(retval);
{ /* not compressed value */
if (in != (ArrayType *) DatumGetPointer(entry->key))
{
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(in),
entry->rel, entry->page, entry->offset, false);
if (in != (ArrayType *) DatumGetPointer(entry->key))
pfree(in);
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page, entry->offset, false);
/*
* sort entries
*/
- costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff);
+ costvector = palloc_array(SPLITCOST, maxoff);
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
costvector[i - 1].pos = i;
ptr++;
}
- retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(res),
entry->rel, entry->page,
entry->offset, false);
}
res = _intbig_alloc(true, siglen, sign);
- retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(res),
entry->rel, entry->page,
entry->offset, false);
maxoff = OffsetNumberNext(maxoff);
/* sort before ... */
- costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff);
+ costvector = palloc_array(SPLITCOST, maxoff);
for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
{
costvector[j - 1].pos = j;
/* Push result into 'jsonb_state' unless it is a raw scalar. */
return *jsonb_state
? pushJsonbValue(jsonb_state, is_elem ? WJB_ELEM : WJB_VALUE, &out)
- : memcpy(palloc(sizeof(JsonbValue)), &out, sizeof(JsonbValue));
+ : memcpy(palloc_object(JsonbValue), &out, sizeof(JsonbValue));
}
return PLyMapping_ToJsonbValue(obj, jsonb_state);
}
- out = palloc(sizeof(JsonbValue));
+ out = palloc_object(JsonbValue);
if (obj == Py_None)
out->type = jbvNull;
item = NEXTVAL(item);
}
- retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(key),
entry->rel, entry->page,
entry->offset, false);
}
key = ltree_gist_alloc(true, sign, siglen, NULL, NULL);
- retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(key),
entry->rel, entry->page,
entry->offset, false);
maxoff = OffsetNumberNext(maxoff);
/* sort before ... */
- costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff);
+ costvector = palloc_array(SPLITCOST, maxoff);
for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
{
costvector[j - 1].pos = j;
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("array must not contain nulls")));
- a = (ltree **) palloc(sizeof(ltree *) * num);
+ a = palloc_array(ltree *, num);
while (num > 0)
{
num--;
ltree *val = DatumGetLtreeP(entry->key);
ltree_gist *key = ltree_gist_alloc(false, NULL, 0, val, 0);
- retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(key),
entry->rel, entry->page,
entry->offset, false);
if (PointerGetDatum(key) != entry->key)
{
- GISTENTRY *retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+ GISTENTRY *retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(key),
entry->rel, entry->page,
v->spl_right = (OffsetNumber *) palloc(nbytes);
v->spl_nleft = 0;
v->spl_nright = 0;
- array = (RIX *) palloc(sizeof(RIX) * (maxoff + 1));
+ array = palloc_array(RIX, maxoff + 1);
/* copy the data into RIXes, and sort the RIXes */
for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
errmsg("number of ltree labels (%d) exceeds the maximum allowed (%d)",
num + 1, LTREE_MAX_LEVELS)));
- list = lptr = (nodeitem *) palloc(sizeof(nodeitem) * (num + 1));
+ list = lptr = palloc_array(nodeitem, num + 1);
ptr = buf;
while (*ptr)
{
case LQPRS_WAITLEVEL:
if (ISLABEL(ptr))
{
- GETVAR(curqlevel) = lptr = (nodeitem *) palloc0(sizeof(nodeitem) * (numOR + 1));
+ GETVAR(curqlevel) = lptr = palloc0_array(nodeitem, numOR + 1);
lptr->start = ptr;
state = LQPRS_WAITDELIM;
curqlevel->numvar = 1;
}
else if (t_iseq(ptr, '!'))
{
- GETVAR(curqlevel) = lptr = (nodeitem *) palloc0(sizeof(nodeitem) * (numOR + 1));
+ GETVAR(curqlevel) = lptr = palloc0_array(nodeitem, numOR + 1);
lptr->start = ptr + 1;
lptr->wlen = -1; /* compensate for counting ! below */
state = LQPRS_WAITDELIM;
ltree **a,
*res;
- a = (ltree **) palloc(sizeof(ltree *) * fcinfo->nargs);
+ a = palloc_array(ltree *, fcinfo->nargs);
for (i = 0; i < fcinfo->nargs; i++)
a[i] = PG_GETARG_LTREE_P(i);
res = lca_inner(a, (int) fcinfo->nargs);
static bool
pushquery(QPRS_STATE *state, int32 type, int32 val, int32 distance, int32 lenval, uint16 flag)
{
- NODE *tmp = (NODE *) palloc(sizeof(NODE));
+ NODE *tmp = palloc_object(NODE);
tmp->type = type;
tmp->val = val;
nrm.curpol = in->curpol;
nrm.op = in->op;
nrm.buflen = 16;
- nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
+ nrm.cur = nrm.buf = palloc_array(char, nrm.buflen);
/* get right operand */
infix(&nrm, false);
nrm.curpol = GETQUERY(query);
nrm.buflen = 32;
- nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
+ nrm.cur = nrm.buf = palloc_array(char, nrm.buflen);
*(nrm.cur) = '\0';
nrm.op = GETOPERAND(query);
infix(&nrm, true);
nrm.curpol = GETQUERY(query);
nrm.buflen = 32;
- nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
+ nrm.cur = nrm.buf = palloc_array(char, nrm.buflen);
*(nrm.cur) = '\0';
nrm.op = GETOPERAND(query);
infix(&nrm, true);
* Initialize output functions for all indexed datatypes; simplifies
* calling them later.
*/
- columns = palloc(sizeof(brin_column_state *) * RelationGetDescr(indexRel)->natts);
+ columns = palloc_array(brin_column_state *, RelationGetDescr(indexRel)->natts);
for (attno = 1; attno <= bdesc->bd_tupdesc->natts; attno++)
{
Oid output;
/* Save arguments for reuse */
mctx = MemoryContextSwitchTo(fctx->multi_call_memory_ctx);
- uargs = palloc(sizeof(ua_page_stats));
+ uargs = palloc_object(ua_page_stats);
uargs->relid = RelationGetRelid(rel);
uargs->blkno = blkno;
*/
mctx = MemoryContextSwitchTo(fctx->multi_call_memory_ctx);
- uargs = palloc(sizeof(ua_page_items));
+ uargs = palloc_object(ua_page_items);
uargs->page = palloc(BLCKSZ);
memcpy(uargs->page, BufferGetPage(buffer), BLCKSZ);
fctx = SRF_FIRSTCALL_INIT();
mctx = MemoryContextSwitchTo(fctx->multi_call_memory_ctx);
- uargs = palloc(sizeof(ua_page_items));
+ uargs = palloc_object(ua_page_items);
uargs->page = get_page_from_raw(raw_page);
opaq->flags,
(GIN_DATA | GIN_LEAF | GIN_COMPRESSED))));
- inter_call_data = palloc(sizeof(gin_leafpage_items_state));
+ inter_call_data = palloc_object(gin_leafpage_items_state);
/* Build a tuple descriptor for our result type */
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
page = verify_hash_page(raw_page, LH_BUCKET_PAGE | LH_OVERFLOW_PAGE);
- uargs = palloc(sizeof(struct user_args));
+ uargs = palloc_object(struct user_args);
uargs->page = page;
fctx = SRF_FIRSTCALL_INIT();
mctx = MemoryContextSwitchTo(fctx->multi_call_memory_ctx);
- inter_call_data = palloc(sizeof(heap_page_items_state));
+ inter_call_data = palloc_object(heap_page_items_state);
/* Build a tuple descriptor for our result type */
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
}
/* build set of raw flags */
- flags = (Datum *) palloc0(sizeof(Datum) * bitcnt);
+ flags = palloc0_array(Datum, bitcnt);
/* decode t_infomask */
if ((t_infomask & HEAP_HASNULL) != 0)
if (options == NULL)
{
- options = palloc0(sizeof(overexplain_options));
+ options = palloc0_object(overexplain_options);
SetExplainExtensionState(es, es_extension_id, options);
}
int32 i;
*nentries = trglen;
- entries = (Datum *) palloc(sizeof(Datum) * trglen);
+ entries = palloc_array(Datum, trglen);
ptr = GETARR(trg);
for (i = 0; i < trglen; i++)
* Pointers, but we just put the same value in each element.
*/
trglen = ARRNELEM(trg);
- *extra_data = (Pointer *) palloc(sizeof(Pointer) * trglen);
+ *extra_data = palloc_array(Pointer, trglen);
for (i = 0; i < trglen; i++)
(*extra_data)[i] = (Pointer) graph;
}
if (trglen > 0)
{
- entries = (Datum *) palloc(sizeof(Datum) * trglen);
+ entries = palloc_array(Datum, trglen);
ptr = GETARR(trg);
for (i = 0; i < trglen; i++)
{
* function, promoting all GIN_MAYBE keys to GIN_TRUE will
* give a conservative result.
*/
- boolcheck = (bool *) palloc(sizeof(bool) * nkeys);
+ boolcheck = palloc_array(bool, nkeys);
for (i = 0; i < nkeys; i++)
boolcheck[i] = (check[i] != GIN_FALSE);
if (!trigramsMatchGraph(extra_data[0], boolcheck))
text *val = DatumGetTextPP(entry->key);
res = generate_trgm(VARDATA_ANY(val), VARSIZE_ANY_EXHDR(val));
- retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(res),
entry->rel, entry->page,
entry->offset, false);
}
res = gtrgm_alloc(true, siglen, sign);
- retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(res),
entry->rel, entry->page,
entry->offset, false);
if (key != (text *) DatumGetPointer(entry->key))
{
/* need to pass back the decompressed item */
- retval = palloc(sizeof(GISTENTRY));
+ retval = palloc_object(GISTENTRY);
gistentryinit(*retval, PointerGetDatum(key),
entry->rel, entry->page, entry->offset, entry->leafkey);
PG_RETURN_POINTER(retval);
SPLITCOST *costvector;
/* cache the sign data for each existing item */
- cache = (CACHESIGN *) palloc(sizeof(CACHESIGN) * (maxoff + 1));
+ cache = palloc_array(CACHESIGN, maxoff + 1);
cache_sign = palloc(siglen * (maxoff + 1));
for (k = FirstOffsetNumber; k <= maxoff; k = OffsetNumberNext(k))
union_r = GETSIGN(datum_r);
/* sort before ... */
- costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff);
+ costvector = palloc_array(SPLITCOST, maxoff);
for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
{
costvector[j - 1].pos = j;
colorInfo->expandable = true;
colorInfo->containsNonWord = false;
- colorInfo->wordChars = (trgm_mb_char *)
- palloc(sizeof(trgm_mb_char) * charsCount);
+ colorInfo->wordChars = palloc_array(trgm_mb_char, charsCount);
colorInfo->wordCharsCount = 0;
/* Extract all the chars in this color */
- chars = (pg_wchar *) palloc(sizeof(pg_wchar) * charsCount);
+ chars = palloc_array(pg_wchar, charsCount);
pg_reg_getcharacters(regex, i, chars, charsCount);
/*
* original NFA.
*/
arcsCount = pg_reg_getnumoutarcs(trgmNFA->regex, key->nstate);
- arcs = (regex_arc_t *) palloc(sizeof(regex_arc_t) * arcsCount);
+ arcs = palloc_array(regex_arc_t, arcsCount);
pg_reg_getoutarcs(trgmNFA->regex, key->nstate, arcs, arcsCount);
for (i = 0; i < arcsCount; i++)
static void
addKeyToQueue(TrgmNFA *trgmNFA, TrgmStateKey *key)
{
- TrgmStateKey *keyCopy = (TrgmStateKey *) palloc(sizeof(TrgmStateKey));
+ TrgmStateKey *keyCopy = palloc_object(TrgmStateKey);
memcpy(keyCopy, key, sizeof(TrgmStateKey));
trgmNFA->keysQueue = lappend(trgmNFA->keysQueue, keyCopy);
TrgmStateKey *key = (TrgmStateKey *) lfirst(cell);
arcsCount = pg_reg_getnumoutarcs(trgmNFA->regex, key->nstate);
- arcs = (regex_arc_t *) palloc(sizeof(regex_arc_t) * arcsCount);
+ arcs = palloc_array(regex_arc_t, arcsCount);
pg_reg_getoutarcs(trgmNFA->regex, key->nstate, arcs, arcsCount);
for (i = 0; i < arcsCount; i++)
}
/* Checks were successful, add new arc */
- arc = (TrgmArc *) palloc(sizeof(TrgmArc));
+ arc = palloc_object(TrgmArc);
arc->target = getState(trgmNFA, destKey);
arc->ctrgm.colors[0] = key->prefix.colors[0];
arc->ctrgm.colors[1] = key->prefix.colors[1];
int cnumber;
/* Collect color trigrams from all arcs */
- colorTrgms = (ColorTrgmInfo *) palloc0(sizeof(ColorTrgmInfo) * arcsCount);
+ colorTrgms = palloc0_array(ColorTrgmInfo, arcsCount);
trgmNFA->colorTrgms = colorTrgms;
i = 0;
foreach(cell, state->arcs)
{
TrgmArc *arc = (TrgmArc *) lfirst(cell);
- TrgmArcInfo *arcInfo = (TrgmArcInfo *) palloc(sizeof(TrgmArcInfo));
+ TrgmArcInfo *arcInfo = palloc_object(TrgmArcInfo);
ColorTrgmInfo *trgmInfo = &colorTrgms[i];
arcInfo->source = state;
}
/* Collect array of all arcs */
- arcs = (TrgmPackArcInfo *)
- palloc(sizeof(TrgmPackArcInfo) * trgmNFA->arcsCount);
+ arcs = palloc_array(TrgmPackArcInfo, trgmNFA->arcsCount);
arcIndex = 0;
hash_seq_init(&scan_status, trgmNFA->states);
while ((state = (TrgmState *) hash_seq_search(&scan_status)) != NULL)
appendStringInfoString(&buf, ";\n");
arcsCount = pg_reg_getnumoutarcs(regex, state);
- arcs = (regex_arc_t *) palloc(sizeof(regex_arc_t) * arcsCount);
+ arcs = palloc_array(regex_arc_t, arcsCount);
pg_reg_getoutarcs(regex, state, arcs, arcsCount);
for (i = 0; i < arcsCount; i++)
* number of entries allocated. We'll repurpose these fields before
* returning.
*/
- items = palloc0(sizeof(corrupt_items));
+ items = palloc0_object(corrupt_items);
items->next = 0;
items->count = 64;
items->tids = palloc(items->count * sizeof(ItemPointerData));
errmsg("could not read WAL at LSN %X/%08X",
LSN_FORMAT_ARGS(lsn))));
- private_data = (ReadLocalXLogPageNoWaitPrivate *)
- palloc0(sizeof(ReadLocalXLogPageNoWaitPrivate));
+ private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
xlogreader = XLogReaderAllocate(wal_segment_size, NULL,
XL_ROUTINE(.page_read = &read_local_xlog_page_no_wait,
/* Construct and save block_fpi_info */
bitcnt = pg_popcount((const char *) &blk->bimg_info,
sizeof(uint8));
- flags = (Datum *) palloc0(sizeof(Datum) * bitcnt);
+ flags = palloc0_array(Datum, bitcnt);
if ((blk->bimg_info & BKPIMAGE_HAS_HOLE) != 0)
flags[cnt++] = CStringGetTextDatum("HAS_HOLE");
if (blk->apply_image)
if (!len)
len = 8192;
- mbuf = palloc(sizeof *mbuf);
+ mbuf = palloc_object(MBuf);
mbuf->data = palloc(len);
mbuf->buf_end = mbuf->data + len;
mbuf->data_end = mbuf->data;
{
MBuf *mbuf;
- mbuf = palloc(sizeof *mbuf);
+ mbuf = palloc_object(MBuf);
mbuf->data = data;
mbuf->buf_end = mbuf->data + len;
mbuf->data_end = mbuf->data + len;
res = 0;
}
- pf = palloc0(sizeof(*pf));
+ pf = palloc0_object(PullFilter);
pf->buflen = res;
pf->op = op;
pf->priv = priv;
res = 0;
}
- mp = palloc0(sizeof(*mp));
+ mp = palloc0_object(PushFilter);
mp->block_size = res;
mp->op = op;
mp->priv = priv;
ResourceOwnerRememberOSSLDigest(digest->owner, digest);
/* The PX_MD object is allocated in the current memory context. */
- h = palloc(sizeof(*h));
+ h = palloc_object(PX_MD);
h->result_size = digest_result_size;
h->block_size = digest_block_size;
h->reset = digest_reset;
od->evp_ciph = i->ciph->cipher_func();
/* The PX_Cipher is allocated in current memory context */
- c = palloc(sizeof(*c));
+ c = palloc_object(PX_Cipher);
c->block_size = gen_ossl_block_size;
c->key_size = gen_ossl_key_size;
c->iv_size = gen_ossl_iv_size;
return res;
}
- ctx = palloc0(sizeof(*ctx));
+ ctx = palloc0_object(PGP_CFB);
ctx->ciph = ciph;
ctx->block_size = px_cipher_block_size(ciph);
ctx->resync = resync;
/*
* init
*/
- st = palloc0(sizeof(*st));
+ st = palloc0_object(struct ZipStat);
st->buf_len = ZIP_OUT_BUF;
st->stream.zalloc = z_alloc;
st->stream.zfree = z_free;
&& ctx->compress_algo != PGP_COMPR_ZIP)
return PXE_PGP_UNSUPPORTED_COMPR;
- dec = palloc0(sizeof(*dec));
+ dec = palloc0_object(struct DecomprData);
dec->buf_len = ZIP_OUT_BUF;
*priv_p = dec;
int pkttype, PGP_Context *ctx)
{
int res;
- struct PktData *pkt = palloc(sizeof(*pkt));
+ struct PktData *pkt = palloc_object(struct PktData);
pkt->type = pkttype;
pkt->len = len;
PGP_Context *ctx = arg;
struct MDCBufData *st;
- st = palloc0(sizeof(*st));
+ st = palloc0_object(struct MDCBufData);
st->buflen = sizeof(st->buf);
st->ctx = ctx;
*priv_p = st;
if (res < 0)
return res;
- st = palloc0(sizeof(*st));
+ st = palloc0_object(struct EncStat);
st->ciph = ciph;
*priv_p = st;
{
struct PktStreamStat *st;
- st = palloc(sizeof(*st));
+ st = palloc_object(struct PktStreamStat);
st->final_done = 0;
st->pkt_block = 1 << STREAM_BLOCK_SHIFT;
*priv_p = st;
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("mismatched array dimensions")));
- keys = (char **) palloc(sizeof(char *) * key_count);
- values = (char **) palloc(sizeof(char *) * val_count);
+ keys = palloc_array(char *, key_count);
+ values = palloc_array(char *, val_count);
for (i = 0; i < key_count; i++)
{
attinmeta = TupleDescGetAttInMetadata(tupdesc);
funcctx->attinmeta = attinmeta;
- state = (pgp_armor_headers_state *) palloc(sizeof(pgp_armor_headers_state));
+ state = palloc_object(pgp_armor_headers_state);
res = pgp_extract_armor_headers((uint8 *) VARDATA_ANY(data),
VARSIZE_ANY_EXHDR(data),
{
PGP_PubKey *pk;
- pk = palloc0(sizeof(*pk));
+ pk = palloc0_object(PGP_PubKey);
*pk_p = pk;
return 0;
}
return PXE_HASH_UNUSABLE_FOR_HMAC;
}
- h = palloc(sizeof(*h));
+ h = palloc_object(PX_HMAC);
h->p.ipad = palloc(bs);
h->p.opad = palloc(bs);
h->md = md;
PX_Combo *cx;
- cx = palloc0(sizeof(*cx));
+ cx = palloc0_object(PX_Combo);
buf = pstrdup(name);
err = parse_cipher_name(buf, &s_cipher, &s_pad);
seg_in(PG_FUNCTION_ARGS)
{
char *str = PG_GETARG_CSTRING(0);
- SEG *result = palloc(sizeof(SEG));
+ SEG *result = palloc_object(SEG);
yyscan_t scanner;
seg_scanner_init(str, &scanner);
/*
* Emit segments to the left output page, and compute its bounding box.
*/
- seg_l = (SEG *) palloc(sizeof(SEG));
+ seg_l = palloc_object(SEG);
memcpy(seg_l, sort_items[0].data, sizeof(SEG));
*left++ = sort_items[0].index;
v->spl_nleft++;
/*
* Likewise for the right page.
*/
- seg_r = (SEG *) palloc(sizeof(SEG));
+ seg_r = palloc_object(SEG);
memcpy(seg_r, sort_items[firstright].data, sizeof(SEG));
*right++ = sort_items[firstright].index;
v->spl_nright++;
SEG *b = PG_GETARG_SEG_P(1);
SEG *n;
- n = (SEG *) palloc(sizeof(*n));
+ n = palloc_object(SEG);
/* take max of upper endpoints */
if (a->upper > b->upper)
SEG *b = PG_GETARG_SEG_P(1);
SEG *n;
- n = (SEG *) palloc(sizeof(*n));
+ n = palloc_object(SEG);
/* take min of upper endpoints */
if (a->upper < b->upper)
*/
oldcxt = MemoryContextSwitchTo(CurTransactionContext);
- plabel = palloc0(sizeof(pending_label));
+ plabel = palloc0_object(pending_label);
plabel->subid = GetCurrentSubTransactionId();
if (new_label)
plabel->label = pstrdup(new_label);
*/
oldctx = MemoryContextSwitchTo(avc_mem_cxt);
- cache = palloc0(sizeof(avc_cache));
+ cache = palloc0_object(avc_cache);
cache->hash = hash;
cache->scontext = pstrdup(scontext);
}
else
{
- newp = *eplan = (EPlan *) palloc(sizeof(EPlan));
+ newp = *eplan = palloc_object(EPlan);
(*nplans) = i = 0;
}
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
/* Create a user function context for cross-call persistence */
- fctx = (SSLExtensionInfoContext *) palloc(sizeof(SSLExtensionInfoContext));
+ fctx = palloc_object(SSLExtensionInfoContext);
/* Construct tuple descriptor */
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
funcctx->max_calls = num_tuples;
/* allocate memory for user context */
- fctx = (normal_rand_fctx *) palloc(sizeof(normal_rand_fctx));
+ fctx = palloc_object(normal_rand_fctx);
/*
* Use fctx to keep track of upper and lower bounds from call to call.
SPIcontext = MemoryContextSwitchTo(per_query_ctx);
- catdesc = (crosstab_cat_desc *) palloc(sizeof(crosstab_cat_desc));
+ catdesc = palloc_object(crosstab_cat_desc);
catdesc->catname = catname;
catdesc->attidx = i;
TestDecodingData *data;
bool enable_streaming = false;
- data = palloc0(sizeof(TestDecodingData));
+ data = palloc0_object(TestDecodingData);
data->context = AllocSetContextCreate(ctx->context,
"text conversion context",
ALLOCSET_DEFAULT_SIZES);
static void
system_rows_initsamplescan(SampleScanState *node, int eflags)
{
- node->tsm_state = palloc0(sizeof(SystemRowsSamplerData));
+ node->tsm_state = palloc0_object(SystemRowsSamplerData);
/* Note the above leaves tsm_state->step equal to zero */
}
static void
system_time_initsamplescan(SampleScanState *node, int eflags)
{
- node->tsm_state = palloc0(sizeof(SystemTimeSamplerData));
+ node->tsm_state = palloc0_object(SystemTimeSamplerData);
/* Note the above leaves tsm_state->step equal to zero */
}
TrieChar *curnode;
if (!node)
- node = (TrieChar *) palloc0(sizeof(TrieChar) * 256);
+ node = palloc0_array(TrieChar, 256);
Assert(lenstr > 0); /* else str[0] doesn't exist */
if (trgquoted && state > 0)
{
/* Ignore first and end quotes */
- trgstore = (char *) palloc(sizeof(char) * (trglen - 2));
+ trgstore = palloc_array(char, trglen - 2);
trgstorelen = 0;
for (int i = 1; i < trglen - 1; i++)
{
}
else
{
- trgstore = (char *) palloc(sizeof(char) * trglen);
+ trgstore = palloc_array(char, trglen);
trgstorelen = trglen;
memcpy(trgstore, trg, trgstorelen);
}
/* return a result only if we made at least one substitution */
if (buf.data != NULL)
{
- res = (TSLexeme *) palloc0(sizeof(TSLexeme) * 2);
+ res = palloc0_array(TSLexeme, 2);
res->lexeme = buf.data;
res->flags = TSL_FILTER;
}
{
int32 docsize = VARSIZE_ANY_EXHDR(document);
xmlXPathCompExprPtr comppath;
- xpath_workspace *workspace = (xpath_workspace *)
- palloc0(sizeof(xpath_workspace));
+ xpath_workspace *workspace = palloc0_object(xpath_workspace);
workspace->doctree = NULL;
workspace->ctxt = NULL;
else
{
/* No parameters */
- params = (const char **) palloc(sizeof(char *));
+ params = palloc_object(const char *);
params[0] = NULL;
}
projects / postgresql.git / commitdiff