index e488f5e234b3ff274f19a7beb68e3cc54ec8181b..d33f33f1703a633b210557bcac7b51321bb58665 100644 (file)
@@ -554,12 +554,10 @@ report_corruption_internal(Tuplestorestate *tupstore, TupleDesc tupdesc,
BlockNumber blkno, OffsetNumber offnum,
AttrNumber attnum, char *msg)
{
- Datum values[HEAPCHECK_RELATION_COLS];
- bool nulls[HEAPCHECK_RELATION_COLS];
+ Datum values[HEAPCHECK_RELATION_COLS] = {0};
+ bool nulls[HEAPCHECK_RELATION_COLS] = {0};
HeapTuple tuple;
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
values[0] = Int64GetDatum(blkno);
values[1] = Int32GetDatum(offnum);
values[2] = Int32GetDatum(attnum);
index d42e4e962848b2c4241bf14f1fe2b11128831b23..d4b1c7630349bfdce7bfae0e8a7ad2aa604e4b87 100644 (file)
@@ -26,9 +26,7 @@ blcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
double *indexPages)
{
IndexOptInfo *index = path->indexinfo;
- GenericCosts costs;
-
- MemSet(&costs, 0, sizeof(costs));
+ GenericCosts costs = {0};
/* We have to visit all index tuples anyway */
costs.numIndexTuples = index->tuples;
index 879276e6dece94fab01987520735102f0e0afdb8..f4c959ecab9fbe4ec2096eee4e02bb4e42dd1a6b 100644 (file)
for (;;)
{
Datum values[7];
- bool nulls[7];
+ bool nulls[7] = {0};
/*
* This loop is called once for every attribute of every tuple in the
else
attno++;
- MemSet(nulls, 0, sizeof(nulls));
-
if (unusedItem)
{
values[0] = UInt16GetDatum(offset);
BrinMetaPageData *meta;
TupleDesc tupdesc;
Datum values[4];
- bool nulls[4];
+ bool nulls[4] = {0};
HeapTuple htup;
if (!superuser())
/* Extract values from the metapage */
meta = (BrinMetaPageData *) PageGetContents(page);
- MemSet(nulls, 0, sizeof(nulls));
values[0] = CStringGetTextDatum(psprintf("0x%08X", meta->brinMagic));
values[1] = Int32GetDatum(meta->brinVersion);
values[2] = Int32GetDatum(meta->pagesPerRange);
index 5287dbe1a308c9e0b2c9f288a3f1e06e31ea864a..81815392d70ad2018f9d8bc78db06616624ec44c 100644 (file)
Page page;
int j;
Datum values[9];
- bool nulls[9];
+ bool nulls[9] = {0};
HashPageStat stat;
HeapTuple tuple;
TupleDesc tupleDesc;
elog(ERROR, "return type must be a row type");
tupleDesc = BlessTupleDesc(tupleDesc);
- MemSet(nulls, 0, sizeof(nulls));
-
j = 0;
values[j++] = Int32GetDatum(stat.live_items);
values[j++] = Int32GetDatum(stat.dead_items);
Page page;
Datum result;
Datum values[3];
- bool nulls[3];
+ bool nulls[3] = {0};
uint32 hashkey;
HeapTuple tuple;
FuncCallContext *fctx;
itup = (IndexTuple) PageGetItem(uargs->page, id);
- MemSet(nulls, 0, sizeof(nulls));
-
j = 0;
values[j++] = Int32GetDatum((int32) uargs->offset);
values[j++] = PointerGetDatum(&itup->t_tid);
int i,
j;
Datum values[3];
- bool nulls[3];
+ bool nulls[3] = {0};
uint32 *freep;
if (!superuser())
elog(ERROR, "return type must be a row type");
tupleDesc = BlessTupleDesc(tupleDesc);
- MemSet(nulls, 0, sizeof(nulls));
-
j = 0;
values[j++] = Int64GetDatum((int64) bitmapblkno);
values[j++] = Int32GetDatum(bitmapbit);
int i,
j;
Datum values[16];
- bool nulls[16];
+ bool nulls[16] = {0};
Datum spares[HASH_MAX_SPLITPOINTS];
Datum mapp[HASH_MAX_BITMAPS];
metad = HashPageGetMeta(page);
- MemSet(nulls, 0, sizeof(nulls));
-
j = 0;
values[j++] = Int64GetDatum((int64) metad->hashm_magic);
values[j++] = Int64GetDatum((int64) metad->hashm_version);
index a654234c6bd7f261074a0eb7d9dbd47b3c58650c..2ff70405cf8f558b8e5f118487b94828655ae67b 100644 (file)
heap_tuple_infomask_flags(PG_FUNCTION_ARGS)
{
#define HEAP_TUPLE_INFOMASK_COLS 2
- Datum values[HEAP_TUPLE_INFOMASK_COLS];
- bool nulls[HEAP_TUPLE_INFOMASK_COLS];
+ Datum values[HEAP_TUPLE_INFOMASK_COLS] = {0};
+ bool nulls[HEAP_TUPLE_INFOMASK_COLS] = {0};
uint16 t_infomask = PG_GETARG_INT16(0);
uint16 t_infomask2 = PG_GETARG_INT16(1);
int cnt = 0;
bitcnt = pg_popcount((const char *) &t_infomask, sizeof(uint16)) +
pg_popcount((const char *) &t_infomask2, sizeof(uint16));
- /* Initialize values and NULL flags arrays */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
/* If no flags, return a set of empty arrays */
if (bitcnt <= 0)
{
index 13eee4a137942e0f3a6172c8006732dc8b391bf1..ee20e9b085096792af1ef62dad5c54b406fa54fa 100644 (file)
static void
apw_start_leader_worker(void)
{
- BackgroundWorker worker;
+ BackgroundWorker worker = {0};
BackgroundWorkerHandle *handle;
BgwHandleStatus status;
pid_t pid;
- MemSet(&worker, 0, sizeof(BackgroundWorker));
worker.bgw_flags = BGWORKER_SHMEM_ACCESS;
worker.bgw_start_time = BgWorkerStart_ConsistentState;
strcpy(worker.bgw_library_name, "pg_prewarm");
static void
apw_start_database_worker(void)
{
- BackgroundWorker worker;
+ BackgroundWorker worker = {0};
BackgroundWorkerHandle *handle;
- MemSet(&worker, 0, sizeof(BackgroundWorker));
worker.bgw_flags =
BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_ConsistentState;
index 4acfddcdb870430d016cb60d99c1705f8eaae1fa..b4d4231dc617325e4584de0f81817f159c126d84 100644 (file)
{
pgssGlobalStats stats;
TupleDesc tupdesc;
- Datum values[PG_STAT_STATEMENTS_INFO_COLS];
- bool nulls[PG_STAT_STATEMENTS_INFO_COLS];
+ Datum values[PG_STAT_STATEMENTS_INFO_COLS] = {0};
+ bool nulls[PG_STAT_STATEMENTS_INFO_COLS] = {0};
if (!pgss || !pgss_hash)
ereport(ERROR,
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
elog(ERROR, "return type must be a row type");
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
/* Read global statistics for pg_stat_statements */
{
volatile pgssSharedState *s = (volatile pgssSharedState *) pgss;
index 4e2e9ea9bbe43cf8d9ebdb5b0f5da52c62b31c17..a95f73ec7960073e1c7d6d25ef118694b535c0ed 100644 (file)
@@ -75,7 +75,7 @@ pg_visibility_map(PG_FUNCTION_ARGS)
Buffer vmbuffer = InvalidBuffer;
TupleDesc tupdesc;
Datum values[2];
- bool nulls[2];
+ bool nulls[2] = {0};
rel = relation_open(relid, AccessShareLock);
@@ -88,7 +88,6 @@ pg_visibility_map(PG_FUNCTION_ARGS)
errmsg("invalid block number")));
tupdesc = pg_visibility_tupdesc(false, false);
- MemSet(nulls, 0, sizeof(nulls));
mapbits = (int32) visibilitymap_get_status(rel, blkno, &vmbuffer);
if (vmbuffer != InvalidBuffer)
Page page;
TupleDesc tupdesc;
Datum values[3];
- bool nulls[3];
+ bool nulls[3] = {0};
rel = relation_open(relid, AccessShareLock);
errmsg("invalid block number")));
tupdesc = pg_visibility_tupdesc(false, true);
- MemSet(nulls, 0, sizeof(nulls));
mapbits = (int32) visibilitymap_get_status(rel, blkno, &vmbuffer);
if (vmbuffer != InvalidBuffer)
if (info->next < info->count)
{
Datum values[3];
- bool nulls[3];
+ bool nulls[3] = {0};
HeapTuple tuple;
- MemSet(nulls, 0, sizeof(nulls));
values[0] = Int64GetDatum(info->next);
values[1] = BoolGetDatum((info->bits[info->next] & (1 << 0)) != 0);
values[2] = BoolGetDatum((info->bits[info->next] & (1 << 1)) != 0);
if (info->next < info->count)
{
Datum values[4];
- bool nulls[4];
+ bool nulls[4] = {0};
HeapTuple tuple;
- MemSet(nulls, 0, sizeof(nulls));
values[0] = Int64GetDatum(info->next);
values[1] = BoolGetDatum((info->bits[info->next] & (1 << 0)) != 0);
values[2] = BoolGetDatum((info->bits[info->next] & (1 << 1)) != 0);
@@ -266,7 +262,7 @@ pg_visibility_map_summary(PG_FUNCTION_ARGS)
int64 all_frozen = 0;
TupleDesc tupdesc;
Datum values[2];
- bool nulls[2];
+ bool nulls[2] = {0};
rel = relation_open(relid, AccessShareLock);
@@ -300,7 +296,6 @@ pg_visibility_map_summary(PG_FUNCTION_ARGS)
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "all_frozen", INT8OID, -1, 0);
tupdesc = BlessTupleDesc(tupdesc);
- MemSet(nulls, 0, sizeof(nulls));
values[0] = Int64GetDatum(all_visible);
values[1] = Int64GetDatum(all_frozen);
index a082dfb3310c932368cad494689b4d29bfc5853f..90817876347cbb13a2922498fc8d7e946f78267d 100644 (file)
@@ -229,8 +229,8 @@ pg_get_wal_record_info(PG_FUNCTION_ARGS)
{
#define PG_GET_WAL_RECORD_INFO_COLS 11
Datum result;
- Datum values[PG_GET_WAL_RECORD_INFO_COLS];
- bool nulls[PG_GET_WAL_RECORD_INFO_COLS];
+ Datum values[PG_GET_WAL_RECORD_INFO_COLS] = {0};
+ bool nulls[PG_GET_WAL_RECORD_INFO_COLS] = {0};
XLogRecPtr lsn;
XLogRecPtr curr_lsn;
XLogRecPtr first_record;
@@ -266,9 +266,6 @@ pg_get_wal_record_info(PG_FUNCTION_ARGS)
errmsg("could not read WAL at %X/%X",
LSN_FORMAT_ARGS(first_record))));
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
GetWALRecordInfo(xlogreader, first_record, values, nulls,
PG_GET_WAL_RECORD_INFO_COLS);
@@ -334,8 +331,8 @@ GetWALRecordsInfo(FunctionCallInfo fcinfo, XLogRecPtr start_lsn,
XLogRecPtr first_record;
XLogReaderState *xlogreader;
ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
- Datum values[PG_GET_WAL_RECORDS_INFO_COLS];
- bool nulls[PG_GET_WAL_RECORDS_INFO_COLS];
+ Datum values[PG_GET_WAL_RECORDS_INFO_COLS] = {0};
+ bool nulls[PG_GET_WAL_RECORDS_INFO_COLS] = {0};
SetSingleFuncCall(fcinfo, 0);
@@ -343,9 +340,6 @@ GetWALRecordsInfo(FunctionCallInfo fcinfo, XLogRecPtr start_lsn,
Assert(xlogreader);
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
while (ReadNextXLogRecord(xlogreader, first_record) &&
xlogreader->EndRecPtr <= end_lsn)
{
@@ -556,17 +550,15 @@ GetWalStats(FunctionCallInfo fcinfo, XLogRecPtr start_lsn,
#define PG_GET_WAL_STATS_COLS 9
XLogRecPtr first_record;
XLogReaderState *xlogreader;
- XLogStats stats;
+ XLogStats stats = {0};
ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
- Datum values[PG_GET_WAL_STATS_COLS];
- bool nulls[PG_GET_WAL_STATS_COLS];
+ Datum values[PG_GET_WAL_STATS_COLS] = {0};
+ bool nulls[PG_GET_WAL_STATS_COLS] = {0};
SetSingleFuncCall(fcinfo, 0);
xlogreader = InitXLogReaderState(start_lsn, &first_record);
- MemSet(&stats, 0, sizeof(stats));
-
while (ReadNextXLogRecord(xlogreader, first_record) &&
xlogreader->EndRecPtr <= end_lsn)
{
@@ -578,9 +570,6 @@ GetWalStats(FunctionCallInfo fcinfo, XLogRecPtr start_lsn,
pfree(xlogreader->private_data);
XLogReaderFree(xlogreader);
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
GetXLogSummaryStats(&stats, rsinfo, values, nulls,
PG_GET_WAL_STATS_COLS,
stats_per_record);
index e1048e47ff3501dd692b6cc85b93f24e820dfe5b..d69ac1c93df2aa076f0a7b8520014e28346fb442 100644 (file)
HeapTuple tuple;
TupleDesc tupleDesc;
Datum values[8];
- bool nulls[8];
+ bool nulls[8] = {0};
Buffer metabuf;
HashMetaPage metap;
float8 free_percent;
/*
* Build and return the tuple
*/
- MemSet(nulls, 0, sizeof(nulls));
values[0] = Int32GetDatum(stats.version);
values[1] = Int64GetDatum((int64) stats.bucket_pages);
values[2] = Int64GetDatum((int64) stats.overflow_pages);
index cffb6f83107288ed58bea0fd6dfaf71b9b1f1af8..939d114f02e4ecb8ba7baa5d3fc0b373c33430d9 100644 (file)
while ((entry = (ConnCacheEntry *) hash_seq_search(&scan)))
{
ForeignServer *server;
- Datum values[POSTGRES_FDW_GET_CONNECTIONS_COLS];
- bool nulls[POSTGRES_FDW_GET_CONNECTIONS_COLS];
+ Datum values[POSTGRES_FDW_GET_CONNECTIONS_COLS] = {0};
+ bool nulls[POSTGRES_FDW_GET_CONNECTIONS_COLS] = {0};
/* We only look for open remote connections */
if (!entry->conn)
server = GetForeignServerExtended(entry->serverid, FSV_MISSING_OK);
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
/*
* The foreign server may have been dropped in current explicit
* transaction. It is not possible to drop the server from another
index 955a428e3dab0b1b8fc4a6b9c552460170663a28..cfac539008426a1b1997358dd698953f4df0b5f3 100644 (file)
{
RelOptInfo *outerrel = fpinfo->outerrel;
PgFdwRelationInfo *ofpinfo;
- AggClauseCosts aggcosts;
+ AggClauseCosts aggcosts = {0};
double input_rows;
int numGroupCols;
double numGroups = 1;
input_rows = ofpinfo->rows;
/* Collect statistics about aggregates for estimating costs. */
- MemSet(&aggcosts, 0, sizeof(AggClauseCosts));
if (root->parse->hasAggs)
{
get_agg_clause_costs(root, AGGSPLIT_SIMPLE, &aggcosts);
index 41b31c5c6f1c64660807ee38be0012aa5544cc6c..803d169f578b6abc3b04a36934075af694acf5fb 100644 (file)
{
GlobalTransaction gxact = &status->array[status->currIdx++];
PGPROC *proc = &ProcGlobal->allProcs[gxact->pgprocno];
- Datum values[5];
- bool nulls[5];
+ Datum values[5] = {0};
+ bool nulls[5] = {0};
HeapTuple tuple;
Datum result;
/*
* Form tuple with appropriate data.
*/
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
values[0] = TransactionIdGetDatum(proc->xid);
values[1] = CStringGetTextDatum(gxact->gid);
index 02bd919ff640fb46e3112bc16ada02466ecdde58..61e0f4a29cad6a3bafcdf48d70f4b1ed87d487c1 100644 (file)
{
#define PG_STOP_BACKUP_V2_COLS 3
TupleDesc tupdesc;
- Datum values[PG_STOP_BACKUP_V2_COLS];
- bool nulls[PG_STOP_BACKUP_V2_COLS];
+ Datum values[PG_STOP_BACKUP_V2_COLS] = {0};
+ bool nulls[PG_STOP_BACKUP_V2_COLS] = {0};
bool waitforarchive = PG_GETARG_BOOL(0);
XLogRecPtr stoppoint;
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
elog(ERROR, "return type must be a row type");
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
if (status != SESSION_BACKUP_RUNNING)
ereport(ERROR,
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
index 5f1726c0957a35cd9995eef878346a45caf5b043..17ff617fba410a9553d8c087572d15d66fa91ba4 100644 (file)
Acl *old_acl;
Acl *new_acl;
HeapTuple newtuple;
- Datum values[Natts_pg_default_acl];
- bool nulls[Natts_pg_default_acl];
- bool replaces[Natts_pg_default_acl];
int noldmembers;
int nnewmembers;
Oid *oldmembers;
}
else
{
+ Datum values[Natts_pg_default_acl] = {0};
+ bool nulls[Natts_pg_default_acl] = {0};
+ bool replaces[Natts_pg_default_acl] = {0};
Oid defAclOid;
- /* Prepare to insert or update pg_default_acl entry */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
- MemSet(replaces, false, sizeof(replaces));
-
if (isNew)
{
/* insert new entry */
@@ -1662,9 +1657,9 @@ ExecGrant_Attribute(InternalGrant *istmt, Oid relOid, const char *relname,
AclMode avail_goptions;
bool need_update;
HeapTuple newtuple;
- Datum values[Natts_pg_attribute];
- bool nulls[Natts_pg_attribute];
- bool replaces[Natts_pg_attribute];
+ Datum values[Natts_pg_attribute] = {0};
+ bool nulls[Natts_pg_attribute] = {0};
+ bool replaces[Natts_pg_attribute] = {0};
int noldmembers;
int nnewmembers;
Oid *oldmembers;
@@ -1745,9 +1740,6 @@ ExecGrant_Attribute(InternalGrant *istmt, Oid relOid, const char *relname,
nnewmembers = aclmembers(new_acl, &newmembers);
/* finished building new ACL value, now insert it */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
- MemSet(replaces, false, sizeof(replaces));
/*
* If the updated ACL is empty, we can set attacl to null, and maybe even
Acl *new_acl;
Oid grantorId;
HeapTuple newtuple;
- Datum values[Natts_pg_class];
- bool nulls[Natts_pg_class];
- bool replaces[Natts_pg_class];
+ Datum values[Natts_pg_class] = {0};
+ bool nulls[Natts_pg_class] = {0};
+ bool replaces[Natts_pg_class] = {0};
int nnewmembers;
Oid *newmembers;
ObjectType objtype;
nnewmembers = aclmembers(new_acl, &newmembers);
/* finished building new ACL value, now insert it */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
- MemSet(replaces, false, sizeof(replaces));
-
replaces[Anum_pg_class_relacl - 1] = true;
values[Anum_pg_class_relacl - 1] = PointerGetDatum(new_acl);
Oid grantorId;
Oid ownerId;
HeapTuple newtuple;
- Datum values[Natts_pg_database];
- bool nulls[Natts_pg_database];
- bool replaces[Natts_pg_database];
+ Datum values[Natts_pg_database] = {0};
+ bool nulls[Natts_pg_database] = {0};
+ bool replaces[Natts_pg_database] = {0};
int noldmembers;
int nnewmembers;
Oid *oldmembers;
nnewmembers = aclmembers(new_acl, &newmembers);
/* finished building new ACL value, now insert it */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
- MemSet(replaces, false, sizeof(replaces));
-
replaces[Anum_pg_database_datacl - 1] = true;
values[Anum_pg_database_datacl - 1] = PointerGetDatum(new_acl);
Oid ownerId;
HeapTuple tuple;
HeapTuple newtuple;
- Datum values[Natts_pg_foreign_data_wrapper];
- bool nulls[Natts_pg_foreign_data_wrapper];
- bool replaces[Natts_pg_foreign_data_wrapper];
+ Datum values[Natts_pg_foreign_data_wrapper] = {0};
+ bool nulls[Natts_pg_foreign_data_wrapper] = {0};
+ bool replaces[Natts_pg_foreign_data_wrapper] = {0};
int noldmembers;
int nnewmembers;
Oid *oldmembers;
nnewmembers = aclmembers(new_acl, &newmembers);
/* finished building new ACL value, now insert it */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
- MemSet(replaces, false, sizeof(replaces));
-
replaces[Anum_pg_foreign_data_wrapper_fdwacl - 1] = true;
values[Anum_pg_foreign_data_wrapper_fdwacl - 1] = PointerGetDatum(new_acl);
Oid ownerId;
HeapTuple tuple;
HeapTuple newtuple;
- Datum values[Natts_pg_foreign_server];
- bool nulls[Natts_pg_foreign_server];
- bool replaces[Natts_pg_foreign_server];
+ Datum values[Natts_pg_foreign_server] = {0};
+ bool nulls[Natts_pg_foreign_server] = {0};
+ bool replaces[Natts_pg_foreign_server] = {0};
int noldmembers;
int nnewmembers;
Oid *oldmembers;
nnewmembers = aclmembers(new_acl, &newmembers);
/* finished building new ACL value, now insert it */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
- MemSet(replaces, false, sizeof(replaces));
-
replaces[Anum_pg_foreign_server_srvacl - 1] = true;
values[Anum_pg_foreign_server_srvacl - 1] = PointerGetDatum(new_acl);
Oid ownerId;
HeapTuple tuple;
HeapTuple newtuple;
- Datum values[Natts_pg_proc];
- bool nulls[Natts_pg_proc];
- bool replaces[Natts_pg_proc];
+ Datum values[Natts_pg_proc] = {0};
+ bool nulls[Natts_pg_proc] = {0};
+ bool replaces[Natts_pg_proc] = {0};
int noldmembers;
int nnewmembers;
Oid *oldmembers;
nnewmembers = aclmembers(new_acl, &newmembers);
/* finished building new ACL value, now insert it */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
- MemSet(replaces, false, sizeof(replaces));
-
replaces[Anum_pg_proc_proacl - 1] = true;
values[Anum_pg_proc_proacl - 1] = PointerGetDatum(new_acl);
Oid ownerId;
HeapTuple tuple;
HeapTuple newtuple;
- Datum values[Natts_pg_language];
- bool nulls[Natts_pg_language];
- bool replaces[Natts_pg_language];
+ Datum values[Natts_pg_language] = {0};
+ bool nulls[Natts_pg_language] = {0};
+ bool replaces[Natts_pg_language] = {0};
int noldmembers;
int nnewmembers;
Oid *oldmembers;
nnewmembers = aclmembers(new_acl, &newmembers);
/* finished building new ACL value, now insert it */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
- MemSet(replaces, false, sizeof(replaces));
-
replaces[Anum_pg_language_lanacl - 1] = true;
values[Anum_pg_language_lanacl - 1] = PointerGetDatum(new_acl);
Oid grantorId;
Oid ownerId;
HeapTuple newtuple;
- Datum values[Natts_pg_largeobject_metadata];
- bool nulls[Natts_pg_largeobject_metadata];
- bool replaces[Natts_pg_largeobject_metadata];
+ Datum values[Natts_pg_largeobject_metadata] = {0};
+ bool nulls[Natts_pg_largeobject_metadata] = {0};
+ bool replaces[Natts_pg_largeobject_metadata] = {0};
int noldmembers;
int nnewmembers;
Oid *oldmembers;
nnewmembers = aclmembers(new_acl, &newmembers);
/* finished building new ACL value, now insert it */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
- MemSet(replaces, false, sizeof(replaces));
-
replaces[Anum_pg_largeobject_metadata_lomacl - 1] = true;
values[Anum_pg_largeobject_metadata_lomacl - 1]
= PointerGetDatum(new_acl);
Oid ownerId;
HeapTuple tuple;
HeapTuple newtuple;
- Datum values[Natts_pg_namespace];
- bool nulls[Natts_pg_namespace];
- bool replaces[Natts_pg_namespace];
+ Datum values[Natts_pg_namespace] = {0};
+ bool nulls[Natts_pg_namespace] = {0};
+ bool replaces[Natts_pg_namespace] = {0};
int noldmembers;
int nnewmembers;
Oid *oldmembers;
nnewmembers = aclmembers(new_acl, &newmembers);
/* finished building new ACL value, now insert it */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
- MemSet(replaces, false, sizeof(replaces));
-
replaces[Anum_pg_namespace_nspacl - 1] = true;
values[Anum_pg_namespace_nspacl - 1] = PointerGetDatum(new_acl);
Oid grantorId;
Oid ownerId;
HeapTuple newtuple;
- Datum values[Natts_pg_tablespace];
- bool nulls[Natts_pg_tablespace];
- bool replaces[Natts_pg_tablespace];
+ Datum values[Natts_pg_tablespace] = {0};
+ bool nulls[Natts_pg_tablespace] = {0};
+ bool replaces[Natts_pg_tablespace] = {0};
int noldmembers;
int nnewmembers;
Oid *oldmembers;
nnewmembers = aclmembers(new_acl, &newmembers);
/* finished building new ACL value, now insert it */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
- MemSet(replaces, false, sizeof(replaces));
-
replaces[Anum_pg_tablespace_spcacl - 1] = true;
values[Anum_pg_tablespace_spcacl - 1] = PointerGetDatum(new_acl);
Oid grantorId;
Oid ownerId;
HeapTuple newtuple;
- Datum values[Natts_pg_type];
- bool nulls[Natts_pg_type];
- bool replaces[Natts_pg_type];
+ Datum values[Natts_pg_type] = {0};
+ bool nulls[Natts_pg_type] = {0};
+ bool replaces[Natts_pg_type] = {0};
int noldmembers;
int nnewmembers;
Oid *oldmembers;
nnewmembers = aclmembers(new_acl, &newmembers);
/* finished building new ACL value, now insert it */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
- MemSet(replaces, false, sizeof(replaces));
-
replaces[Anum_pg_type_typacl - 1] = true;
values[Anum_pg_type_typacl - 1] = PointerGetDatum(new_acl);
{
/* finished building new ACL value, now insert it */
HeapTuple newtuple;
- Datum values[Natts_pg_parameter_acl];
- bool nulls[Natts_pg_parameter_acl];
- bool replaces[Natts_pg_parameter_acl];
-
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
- MemSet(replaces, false, sizeof(replaces));
+ Datum values[Natts_pg_parameter_acl] = {0};
+ bool nulls[Natts_pg_parameter_acl] = {0};
+ bool replaces[Natts_pg_parameter_acl] = {0};
replaces[Anum_pg_parameter_acl_paracl - 1] = true;
values[Anum_pg_parameter_acl_paracl - 1] = PointerGetDatum(new_acl);
@@ -6419,17 +6367,13 @@ recordExtensionInitPrivWorker(Oid objoid, Oid classoid, int objsubid, Acl *new_a
/* If we find an entry, update it with the latest ACL. */
if (HeapTupleIsValid(oldtuple))
{
- Datum values[Natts_pg_init_privs];
- bool nulls[Natts_pg_init_privs];
- bool replace[Natts_pg_init_privs];
+ Datum values[Natts_pg_init_privs] = {0};
+ bool nulls[Natts_pg_init_privs] = {0};
+ bool replace[Natts_pg_init_privs] = {0};
/* If we have a new ACL to set, then update the row with it. */
if (new_acl)
{
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
- MemSet(replace, false, sizeof(replace));
-
values[Anum_pg_init_privs_initprivs - 1] = PointerGetDatum(new_acl);
replace[Anum_pg_init_privs_initprivs - 1] = true;
@@ -6446,8 +6390,8 @@ recordExtensionInitPrivWorker(Oid objoid, Oid classoid, int objsubid, Acl *new_a
}
else
{
- Datum values[Natts_pg_init_privs];
- bool nulls[Natts_pg_init_privs];
+ Datum values[Natts_pg_init_privs] = {0};
+ bool nulls[Natts_pg_init_privs] = {0};
/*
* Only add a new entry if the new ACL is non-NULL.
@@ -6458,8 +6402,6 @@ recordExtensionInitPrivWorker(Oid objoid, Oid classoid, int objsubid, Acl *new_a
if (new_acl)
{
/* No entry found, so add it. */
- MemSet(nulls, false, sizeof(nulls));
-
values[Anum_pg_init_privs_objoid - 1] = ObjectIdGetDatum(objoid);
values[Anum_pg_init_privs_classoid - 1] = ObjectIdGetDatum(classoid);
values[Anum_pg_init_privs_objsubid - 1] = Int32GetDatum(objsubid);
index de10923391022a594e21f1222b835e9b904ea864..5cbd72ce1096912f11f3a844bc8e9a0b20808e64 100644 (file)
@@ -1635,12 +1635,11 @@ recordDependencyOnSingleRelExpr(const ObjectAddress *depender,
bool reverse_self)
{
find_expr_references_context context;
- RangeTblEntry rte;
+ RangeTblEntry rte = {0};
context.addrs = new_object_addresses();
/* We gin up a rather bogus rangetable list to handle Vars */
- MemSet(&rte, 0, sizeof(rte));
rte.type = T_RangeTblEntry;
rte.rtekind = RTE_RELATION;
rte.relid = relId;
index e770ea6eb84bc7aafe4f9939b10d291cc59f9383..9b03579e6e01f690ca0cf03267c85cc3a6572fb4 100644 (file)
/* clear the missing value if any */
if (attStruct->atthasmissing)
{
- Datum valuesAtt[Natts_pg_attribute];
- bool nullsAtt[Natts_pg_attribute];
- bool replacesAtt[Natts_pg_attribute];
+ Datum valuesAtt[Natts_pg_attribute] = {0};
+ bool nullsAtt[Natts_pg_attribute] = {0};
+ bool replacesAtt[Natts_pg_attribute] = {0};
/* update the tuple - set atthasmissing and attmissingval */
- MemSet(valuesAtt, 0, sizeof(valuesAtt));
- MemSet(nullsAtt, false, sizeof(nullsAtt));
- MemSet(replacesAtt, false, sizeof(replacesAtt));
-
valuesAtt[Anum_pg_attribute_atthasmissing - 1] =
BoolGetDatum(false);
replacesAtt[Anum_pg_attribute_atthasmissing - 1] = true;
void
SetAttrMissing(Oid relid, char *attname, char *value)
{
- Datum valuesAtt[Natts_pg_attribute];
- bool nullsAtt[Natts_pg_attribute];
- bool replacesAtt[Natts_pg_attribute];
+ Datum valuesAtt[Natts_pg_attribute] = {0};
+ bool nullsAtt[Natts_pg_attribute] = {0};
+ bool replacesAtt[Natts_pg_attribute] = {0};
Datum missingval;
Form_pg_attribute attStruct;
Relation attrrel,
@@ -2041,10 +2037,6 @@ SetAttrMissing(Oid relid, char *attname, char *value)
Int32GetDatum(attStruct->atttypmod));
/* update the tuple - set atthasmissing and attmissingval */
- MemSet(valuesAtt, 0, sizeof(valuesAtt));
- MemSet(nullsAtt, false, sizeof(nullsAtt));
- MemSet(replacesAtt, false, sizeof(replacesAtt));
-
valuesAtt[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(true);
replacesAtt[Anum_pg_attribute_atthasmissing - 1] = true;
valuesAtt[Anum_pg_attribute_attmissingval - 1] = missingval;
Relation pg_partitioned_table;
HeapTuple tuple;
Datum values[Natts_pg_partitioned_table];
- bool nulls[Natts_pg_partitioned_table];
+ bool nulls[Natts_pg_partitioned_table] = {0};
ObjectAddress myself;
ObjectAddress referenced;
ObjectAddresses *addrs;
pg_partitioned_table = table_open(PartitionedRelationId, RowExclusiveLock);
- MemSet(nulls, false, sizeof(nulls));
-
/* Only this can ever be NULL */
if (!partexprDatum)
nulls[Anum_pg_partitioned_table_partexprs - 1] = true;
index c5d463ac55e5d546ed7ce2149264b161a9fffb03..d7192f35e3f365bd3c8f8242934e7848542974bb 100644 (file)
Datum exprsDatum;
Datum predDatum;
Datum values[Natts_pg_index];
- bool nulls[Natts_pg_index];
+ bool nulls[Natts_pg_index] = {0};
Relation pg_index;
HeapTuple tuple;
int i;
/*
* Build a pg_index tuple
*/
- MemSet(nulls, false, sizeof(nulls));
-
values[Anum_pg_index_indexrelid - 1] = ObjectIdGetDatum(indexoid);
values[Anum_pg_index_indrelid - 1] = ObjectIdGetDatum(heapoid);
values[Anum_pg_index_indnatts - 1] = Int16GetDatum(indexInfo->ii_NumIndexAttrs);
index c5d4a9912ea7073801f0c05bf2b80e8cbcc0a381..1a14093a9a05e6cf5a5048e19dac2ee745c8a98c 100644 (file)
@@ -111,15 +111,12 @@ StoreAttrDefault(Relation rel, AttrNumber attnum,
Expr *expr2 = (Expr *) expr;
EState *estate = NULL;
ExprContext *econtext;
- Datum valuesAtt[Natts_pg_attribute];
- bool nullsAtt[Natts_pg_attribute];
- bool replacesAtt[Natts_pg_attribute];
+ Datum valuesAtt[Natts_pg_attribute] = {0};
+ bool nullsAtt[Natts_pg_attribute] = {0};
+ bool replacesAtt[Natts_pg_attribute] = {0};
Datum missingval = (Datum) 0;
bool missingIsNull = true;
- MemSet(valuesAtt, 0, sizeof(valuesAtt));
- MemSet(nullsAtt, false, sizeof(nullsAtt));
- MemSet(replacesAtt, false, sizeof(replacesAtt));
valuesAtt[Anum_pg_attribute_atthasdef - 1] = true;
replacesAtt[Anum_pg_attribute_atthasdef - 1] = true;
index 4857f6468d281931f7263396d4f00e13668c2c47..1812bb7fcc96aca54f5de155493134b44dd5e047 100644 (file)
@@ -47,7 +47,7 @@ CastCreate(Oid sourcetypeid, Oid targettypeid, Oid funcid, char castcontext,
HeapTuple tuple;
Oid castid;
Datum values[Natts_pg_cast];
- bool nulls[Natts_pg_cast];
+ bool nulls[Natts_pg_cast] = {0};
ObjectAddress myself,
referenced;
ObjectAddresses *addrs;
@@ -78,8 +78,6 @@ CastCreate(Oid sourcetypeid, Oid targettypeid, Oid funcid, char castcontext,
values[Anum_pg_cast_castcontext - 1] = CharGetDatum(castcontext);
values[Anum_pg_cast_castmethod - 1] = CharGetDatum(castmethod);
- MemSet(nulls, false, sizeof(nulls));
-
tuple = heap_form_tuple(RelationGetDescr(relation), values, nulls);
CatalogTupleInsert(relation, tuple);
index 2decee909b36619cd33f9ead7e6a3f8cbe41b697..0570e811d1ef7af648183a2eb08d8ef7be1b0da8 100644 (file)
@@ -74,8 +74,8 @@ ParameterAclCreate(const char *parameter)
Relation rel;
TupleDesc tupDesc;
HeapTuple tuple;
- Datum values[Natts_pg_parameter_acl];
- bool nulls[Natts_pg_parameter_acl];
+ Datum values[Natts_pg_parameter_acl] = {0};
+ bool nulls[Natts_pg_parameter_acl] = {0};
/*
* To prevent cluttering pg_parameter_acl with useless entries, insist
@@ -98,8 +98,6 @@ ParameterAclCreate(const char *parameter)
*/
rel = table_open(ParameterAclRelationId, RowExclusiveLock);
tupDesc = RelationGetDescr(rel);
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
parameterId = GetNewOidWithIndex(rel,
ParameterAclOidIndexId,
Anum_pg_parameter_acl_oid);
index c365de3a72af1357032316efc53ac393052d758d..ade3bf3acad5b4e81fbd7d40984293a089d74bc1 100644 (file)
HeapTuple pubtuple = NULL;
HeapTuple rettuple;
Oid relid = list_nth_oid(tables, funcctx->call_cntr);
- Datum values[NUM_PUBLICATION_TABLES_ELEM];
- bool nulls[NUM_PUBLICATION_TABLES_ELEM];
+ Datum values[NUM_PUBLICATION_TABLES_ELEM] = {0};
+ bool nulls[NUM_PUBLICATION_TABLES_ELEM] = {0};
/*
* Form tuple with appropriate data.
*/
- MemSet(nulls, 0, sizeof(nulls));
- MemSet(values, 0, sizeof(values));
publication = GetPublicationByName(pubname, false);
index 1901b434c588bb62b2f3d712582472141376f7f8..099d369b2f4ae2f7004e3c3a7dcba66c7420e4bc 100644 (file)
@@ -689,8 +689,8 @@ createdb(ParseState *pstate, const CreatedbStmt *stmt)
volatile Oid dst_deftablespace;
Relation pg_database_rel;
HeapTuple tuple;
- Datum new_record[Natts_pg_database];
- bool new_record_nulls[Natts_pg_database];
+ Datum new_record[Natts_pg_database] = {0};
+ bool new_record_nulls[Natts_pg_database] = {0};
Oid dboid = InvalidOid;
Oid datdba;
ListCell *option;
@@ -1296,9 +1296,6 @@ createdb(ParseState *pstate, const CreatedbStmt *stmt)
(dblocprovider != COLLPROVIDER_ICU && !dbiculocale));
/* Form tuple */
- MemSet(new_record, 0, sizeof(new_record));
- MemSet(new_record_nulls, false, sizeof(new_record_nulls));
-
new_record[Anum_pg_database_oid - 1] = ObjectIdGetDatum(dboid);
new_record[Anum_pg_database_datname - 1] =
DirectFunctionCall1(namein, CStringGetDatum(dbname));
@@ -1822,9 +1819,6 @@ movedb(const char *dbname, const char *tblspcname)
newtuple;
Oid src_tblspcoid,
dst_tblspcoid;
- Datum new_record[Natts_pg_database];
- bool new_record_nulls[Natts_pg_database];
- bool new_record_repl[Natts_pg_database];
ScanKeyData scankey;
SysScanDesc sysscan;
AclResult aclresult;
PG_ENSURE_ERROR_CLEANUP(movedb_failure_callback,
PointerGetDatum(&fparms));
{
+ Datum new_record[Natts_pg_database] = {0};
+ bool new_record_nulls[Natts_pg_database] = {0};
+ bool new_record_repl[Natts_pg_database] = {0};
+
/*
* Copy files from the old tablespace to the new one
*/
(errcode(ERRCODE_UNDEFINED_DATABASE),
errmsg("database \"%s\" does not exist", dbname)));
- MemSet(new_record, 0, sizeof(new_record));
- MemSet(new_record_nulls, false, sizeof(new_record_nulls));
- MemSet(new_record_repl, false, sizeof(new_record_repl));
-
new_record[Anum_pg_database_dattablespace - 1] = ObjectIdGetDatum(dst_tblspcoid);
new_record_repl[Anum_pg_database_dattablespace - 1] = true;
@@ -2194,9 +2188,9 @@ AlterDatabase(ParseState *pstate, AlterDatabaseStmt *stmt, bool isTopLevel)
DefElem *dallowconnections = NULL;
DefElem *dconnlimit = NULL;
DefElem *dtablespace = NULL;
- Datum new_record[Natts_pg_database];
- bool new_record_nulls[Natts_pg_database];
- bool new_record_repl[Natts_pg_database];
+ Datum new_record[Natts_pg_database] = {0};
+ bool new_record_nulls[Natts_pg_database] = {0};
+ bool new_record_repl[Natts_pg_database] = {0};
/* Extract options from the statement node tree */
foreach(option, stmt->options)
@@ -2305,10 +2299,6 @@ AlterDatabase(ParseState *pstate, AlterDatabaseStmt *stmt, bool isTopLevel)
/*
* Build an updated tuple, perusing the information just obtained
*/
- MemSet(new_record, 0, sizeof(new_record));
- MemSet(new_record_nulls, false, sizeof(new_record_nulls));
- MemSet(new_record_repl, false, sizeof(new_record_repl));
-
if (distemplate)
{
new_record[Anum_pg_database_datistemplate - 1] = BoolGetDatum(dbistemplate);
@@ -2492,8 +2482,8 @@ AlterDatabaseOwner(const char *dbname, Oid newOwnerId)
if (datForm->datdba != newOwnerId)
{
Datum repl_val[Natts_pg_database];
- bool repl_null[Natts_pg_database];
- bool repl_repl[Natts_pg_database];
+ bool repl_null[Natts_pg_database] = {0};
+ bool repl_repl[Natts_pg_database] = {0};
Acl *newAcl;
Datum aclDatum;
bool isNull;
@@ -2521,9 +2511,6 @@ AlterDatabaseOwner(const char *dbname, Oid newOwnerId)
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("permission denied to change owner of database")));
- memset(repl_null, false, sizeof(repl_null));
- memset(repl_repl, false, sizeof(repl_repl));
-
repl_repl[Anum_pg_database_datdba - 1] = true;
repl_val[Anum_pg_database_datdba - 1] = ObjectIdGetDatum(newOwnerId);
index f46f86474aabc46bfff580430f46deeeb3735f69..eef3e5d56e5e28e2a492720a85d42720df2e3dab 100644 (file)
{
SQLDropObject *obj;
int i = 0;
- Datum values[12];
- bool nulls[12];
+ Datum values[12] = {0};
+ bool nulls[12] = {0};
obj = slist_container(SQLDropObject, next, iter.cur);
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
/* classid */
values[i++] = ObjectIdGetDatum(obj->address.classId);
{
CollectedCommand *cmd = lfirst(lc);
Datum values[9];
- bool nulls[9];
+ bool nulls[9] = {0};
ObjectAddress addr;
int i = 0;
!OidIsValid(cmd->d.simple.address.objectId))
continue;
- MemSet(nulls, 0, sizeof(nulls));
-
switch (cmd->type)
{
case SCT_Simple:
index b016eecb2cd8b4d09337808d5ccfb9124dcf0dba..59e3af626faff66ff25ece9178fe6f390ea54a7a 100644 (file)
AclResult aclresult;
Form_pg_proc procstruct;
Datum values[Natts_pg_transform];
- bool nulls[Natts_pg_transform];
- bool replaces[Natts_pg_transform];
+ bool nulls[Natts_pg_transform] = {0};
+ bool replaces[Natts_pg_transform] = {0};
Oid transformid;
HeapTuple tuple;
HeapTuple newtuple;
values[Anum_pg_transform_trffromsql - 1] = ObjectIdGetDatum(fromsqlfuncid);
values[Anum_pg_transform_trftosql - 1] = ObjectIdGetDatum(tosqlfuncid);
- MemSet(nulls, false, sizeof(nulls));
-
relation = table_open(TransformRelationId, RowExclusiveLock);
tuple = SearchSysCache2(TRFTYPELANG,
format_type_be(typeid),
stmt->lang)));
- MemSet(replaces, false, sizeof(replaces));
replaces[Anum_pg_transform_trffromsql - 1] = true;
replaces[Anum_pg_transform_trftosql - 1] = true;
index 2333aae4673eeef4178704fffada9f8cffccfd88..579825c1593c44f9cd89a9007f8c8d99f2a85895 100644 (file)
{
TupleDesc result_desc;
Datum values[8];
- bool nulls[8];
+ bool nulls[8] = {0};
result_desc = prep_stmt->plansource->resultDesc;
- MemSet(nulls, 0, sizeof(nulls));
-
values[0] = CStringGetTextDatum(prep_stmt->stmt_name);
values[1] = CStringGetTextDatum(prep_stmt->plansource->query_string);
values[2] = TimestampTzGetDatum(prep_stmt->prepare_time);
index f2947ea9b4947f5edad025cc463dd3dba12fc4bf..a2f577024a1a2705e4d64b4b4221c577ebf7b996 100644 (file)
@@ -8988,15 +8988,15 @@ ATAddForeignKeyConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel,
bool recurse, bool recursing, LOCKMODE lockmode)
{
Relation pkrel;
- int16 pkattnum[INDEX_MAX_KEYS];
- int16 fkattnum[INDEX_MAX_KEYS];
- Oid pktypoid[INDEX_MAX_KEYS];
- Oid fktypoid[INDEX_MAX_KEYS];
- Oid opclasses[INDEX_MAX_KEYS];
- Oid pfeqoperators[INDEX_MAX_KEYS];
- Oid ppeqoperators[INDEX_MAX_KEYS];
- Oid ffeqoperators[INDEX_MAX_KEYS];
- int16 fkdelsetcols[INDEX_MAX_KEYS];
+ int16 pkattnum[INDEX_MAX_KEYS] = {0};
+ int16 fkattnum[INDEX_MAX_KEYS] = {0};
+ Oid pktypoid[INDEX_MAX_KEYS] = {0};
+ Oid fktypoid[INDEX_MAX_KEYS] = {0};
+ Oid opclasses[INDEX_MAX_KEYS] = {0};
+ Oid pfeqoperators[INDEX_MAX_KEYS] = {0};
+ Oid ppeqoperators[INDEX_MAX_KEYS] = {0};
+ Oid ffeqoperators[INDEX_MAX_KEYS] = {0};
+ int16 fkdelsetcols[INDEX_MAX_KEYS] = {0};
int i;
int numfks,
numpks,
@@ -9088,16 +9088,6 @@ ATAddForeignKeyConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel,
* Look up the referencing attributes to make sure they exist, and record
* their attnums and type OIDs.
*/
- MemSet(pkattnum, 0, sizeof(pkattnum));
- MemSet(fkattnum, 0, sizeof(fkattnum));
- MemSet(pktypoid, 0, sizeof(pktypoid));
- MemSet(fktypoid, 0, sizeof(fktypoid));
- MemSet(opclasses, 0, sizeof(opclasses));
- MemSet(pfeqoperators, 0, sizeof(pfeqoperators));
- MemSet(ppeqoperators, 0, sizeof(ppeqoperators));
- MemSet(ffeqoperators, 0, sizeof(ffeqoperators));
- MemSet(fkdelsetcols, 0, sizeof(fkdelsetcols));
-
numfks = transformColumnNameList(RelationGetRelid(rel),
fkconstraint->fk_attrs,
fkattnum, fktypoid);
{
TupleTableSlot *slot;
TableScanDesc scan;
- Trigger trig;
+ Trigger trig = {0};
Snapshot snapshot;
MemoryContext oldcxt;
MemoryContext perTupCxt;
/*
* Build a trigger call structure; we'll need it either way.
*/
- MemSet(&trig, 0, sizeof(trig));
trig.tgoid = InvalidOid;
trig.tgname = conname;
trig.tgenabled = TRIGGER_FIRES_ON_ORIGIN;
int one = 1;
bool isNull;
- Datum valuesAtt[Natts_pg_attribute];
- bool nullsAtt[Natts_pg_attribute];
- bool replacesAtt[Natts_pg_attribute];
+ Datum valuesAtt[Natts_pg_attribute] = {0};
+ bool nullsAtt[Natts_pg_attribute] = {0};
+ bool replacesAtt[Natts_pg_attribute] = {0};
HeapTuple newTup;
- MemSet(valuesAtt, 0, sizeof(valuesAtt));
- MemSet(nullsAtt, false, sizeof(nullsAtt));
- MemSet(replacesAtt, false, sizeof(replacesAtt));
-
missingval = array_get_element(missingval,
1,
&one,
HeapTuple tuple;
Form_pg_constraint constrForm;
Relation rel;
- Trigger trig;
+ Trigger trig = {0};
tuple = SearchSysCache1(CONSTROID, ObjectIdGetDatum(constrOid));
if (!HeapTupleIsValid(tuple))
/* prevent data changes into the referencing table until commit */
rel = table_open(constrForm->conrelid, ShareLock);
- MemSet(&trig, 0, sizeof(trig));
trig.tgoid = InvalidOid;
trig.tgname = NameStr(constrForm->conname);
trig.tgenabled = TRIGGER_FIRES_ON_ORIGIN;
index c8bdd9992acc22c0937e2fb5888d5cfa7efb2cd6..cb7d46089a38c97d804e2e9be47c0756e5d114ca 100644 (file)
@@ -238,7 +238,7 @@ CreateTableSpace(CreateTableSpaceStmt *stmt)
#ifdef HAVE_SYMLINK
Relation rel;
Datum values[Natts_pg_tablespace];
- bool nulls[Natts_pg_tablespace];
+ bool nulls[Natts_pg_tablespace] = {0};
HeapTuple tuple;
Oid tablespaceoid;
char *location;
@@ -340,8 +340,6 @@ CreateTableSpace(CreateTableSpaceStmt *stmt)
*/
rel = table_open(TableSpaceRelationId, RowExclusiveLock);
- MemSet(nulls, false, sizeof(nulls));
-
if (IsBinaryUpgrade)
{
/* Use binary-upgrade override for tablespace oid */
index a8757a90bf8300c43b6966cfe0b69ee6ea7f6c2d..d0d87a1184a76b5624ebe06190c31334a8daba37 100644 (file)
@@ -2570,9 +2570,9 @@ AlterDomainDefault(List *names, Node *defaultRaw)
Relation rel;
char *defaultValue;
Node *defaultExpr = NULL; /* NULL if no default specified */
- Datum new_record[Natts_pg_type];
- bool new_record_nulls[Natts_pg_type];
- bool new_record_repl[Natts_pg_type];
+ Datum new_record[Natts_pg_type] = {0};
+ bool new_record_nulls[Natts_pg_type] = {0};
+ bool new_record_repl[Natts_pg_type] = {0};
HeapTuple newtuple;
Form_pg_type typTup;
ObjectAddress address;
@@ -2593,9 +2593,6 @@ AlterDomainDefault(List *names, Node *defaultRaw)
checkDomainOwner(tup);
/* Setup new tuple */
- MemSet(new_record, (Datum) 0, sizeof(new_record));
- MemSet(new_record_nulls, false, sizeof(new_record_nulls));
- MemSet(new_record_repl, false, sizeof(new_record_repl));
/* Store the new default into the tuple */
if (defaultRaw)
index 984305ba31cf1798b4b64e448a02904ffed9ad9f..5b24b6dcad8099602c5b103e96c9ed25d045d988 100644 (file)
@@ -74,8 +74,8 @@ CreateRole(ParseState *pstate, CreateRoleStmt *stmt)
Relation pg_authid_rel;
TupleDesc pg_authid_dsc;
HeapTuple tuple;
- Datum new_record[Natts_pg_authid];
- bool new_record_nulls[Natts_pg_authid];
+ Datum new_record[Natts_pg_authid] = {0};
+ bool new_record_nulls[Natts_pg_authid] = {0};
Oid roleid;
ListCell *item;
ListCell *option;
@@ -338,12 +338,8 @@ CreateRole(ParseState *pstate, CreateRoleStmt *stmt)
/*
* Build a tuple to insert
*/
- MemSet(new_record, 0, sizeof(new_record));
- MemSet(new_record_nulls, false, sizeof(new_record_nulls));
-
new_record[Anum_pg_authid_rolname - 1] =
DirectFunctionCall1(namein, CStringGetDatum(stmt->role));
-
new_record[Anum_pg_authid_rolsuper - 1] = BoolGetDatum(issuper);
new_record[Anum_pg_authid_rolinherit - 1] = BoolGetDatum(inherit);
new_record[Anum_pg_authid_rolcreaterole - 1] = BoolGetDatum(createrole);
@@ -492,9 +488,9 @@ CreateRole(ParseState *pstate, CreateRoleStmt *stmt)
Oid
AlterRole(ParseState *pstate, AlterRoleStmt *stmt)
{
- Datum new_record[Natts_pg_authid];
- bool new_record_nulls[Natts_pg_authid];
- bool new_record_repl[Natts_pg_authid];
+ Datum new_record[Natts_pg_authid] = {0};
+ bool new_record_nulls[Natts_pg_authid] = {0};
+ bool new_record_repl[Natts_pg_authid] = {0};
Relation pg_authid_rel;
TupleDesc pg_authid_dsc;
HeapTuple tuple,
@@ -691,9 +687,6 @@ AlterRole(ParseState *pstate, AlterRoleStmt *stmt)
/*
* Build an updated tuple, perusing the information just obtained
*/
- MemSet(new_record, 0, sizeof(new_record));
- MemSet(new_record_nulls, false, sizeof(new_record_nulls));
- MemSet(new_record_repl, false, sizeof(new_record_repl));
/*
* issuper/createrole/etc
Oid memberid = lfirst_oid(iditem);
HeapTuple authmem_tuple;
HeapTuple tuple;
- Datum new_record[Natts_pg_auth_members];
- bool new_record_nulls[Natts_pg_auth_members];
- bool new_record_repl[Natts_pg_auth_members];
+ Datum new_record[Natts_pg_auth_members] = {0};
+ bool new_record_nulls[Natts_pg_auth_members] = {0};
+ bool new_record_repl[Natts_pg_auth_members] = {0};
/*
* pg_database_owner is never a role member. Lifting this restriction
}
/* Build a tuple to insert or update */
- MemSet(new_record, 0, sizeof(new_record));
- MemSet(new_record_nulls, false, sizeof(new_record_nulls));
- MemSet(new_record_repl, false, sizeof(new_record_repl));
-
new_record[Anum_pg_auth_members_roleid - 1] = ObjectIdGetDatum(roleid);
new_record[Anum_pg_auth_members_member - 1] = ObjectIdGetDatum(memberid);
new_record[Anum_pg_auth_members_grantor - 1] = ObjectIdGetDatum(grantorId);
{
/* Just turn off the admin option */
HeapTuple tuple;
- Datum new_record[Natts_pg_auth_members];
- bool new_record_nulls[Natts_pg_auth_members];
- bool new_record_repl[Natts_pg_auth_members];
+ Datum new_record[Natts_pg_auth_members] = {0};
+ bool new_record_nulls[Natts_pg_auth_members] = {0};
+ bool new_record_repl[Natts_pg_auth_members] = {0};
/* Build a tuple to update with */
- MemSet(new_record, 0, sizeof(new_record));
- MemSet(new_record_nulls, false, sizeof(new_record_nulls));
- MemSet(new_record_repl, false, sizeof(new_record_repl));
-
new_record[Anum_pg_auth_members_admin_option - 1] = BoolGetDatum(false);
new_record_repl[Anum_pg_auth_members_admin_option - 1] = true;
index 5e5732f6e1207e96489777d19b4d08d36e557961..190302b9bde8ccdaa642e869fe4abf30e0e89865 100644 (file)
double output_tuples;
Cost startup_cost;
Cost total_cost;
- AggClauseCosts dummy_aggcosts;
+ const AggClauseCosts dummy_aggcosts = {0};
/* Use all-zero per-aggregate costs if NULL is passed */
if (aggcosts == NULL)
{
Assert(aggstrategy == AGG_HASHED);
- MemSet(&dummy_aggcosts, 0, sizeof(AggClauseCosts));
aggcosts = &dummy_aggcosts;
}
index 2a1d44b813b01b661dde438050d781a3cd6c9575..16a0fe59e21dd503d297102df742e4b2ce592545 100644 (file)
@@ -1594,9 +1594,8 @@ expandRecordVariable(ParseState *pstate, Var *var, int levelsup)
* to. We have to build an additional level of ParseState
* to keep in step with varlevelsup in the subselect.
*/
- ParseState mypstate;
+ ParseState mypstate = {0};
- MemSet(&mypstate, 0, sizeof(mypstate));
mypstate.parentParseState = pstate;
mypstate.p_rtable = rte->subquery->rtable;
/* don't bother filling the rest of the fake pstate */
index 2bdab53e19b032a3fdfae76e77f7ae115978894e..3bbd5227241dc9a441f2639540601f339e5218cb 100644 (file)
@@ -938,8 +938,8 @@ pg_stat_get_subscription(PG_FUNCTION_ARGS)
for (i = 0; i < max_logical_replication_workers; i++)
{
/* for each row */
- Datum values[PG_STAT_GET_SUBSCRIPTION_COLS];
- bool nulls[PG_STAT_GET_SUBSCRIPTION_COLS];
+ Datum values[PG_STAT_GET_SUBSCRIPTION_COLS] = {0};
+ bool nulls[PG_STAT_GET_SUBSCRIPTION_COLS] = {0};
int worker_pid;
LogicalRepWorker worker;
@@ -953,9 +953,6 @@ pg_stat_get_subscription(PG_FUNCTION_ARGS)
worker_pid = worker.proc->pid;
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
values[0] = ObjectIdGetDatum(worker.subid);
if (OidIsValid(worker.relid))
values[1] = ObjectIdGetDatum(worker.relid);
index 3c407ab964752f453cf81c929ebb082732ca6563..3a86786cc3a4c037e364823359e51310152eb81d 100644 (file)
TupOutputState *tstate;
TupleDesc tupdesc;
Datum values[4];
- bool nulls[4];
+ bool nulls[4] = {0};
TimeLineID currTLI;
/*
}
dest = CreateDestReceiver(DestRemoteSimple);
- MemSet(nulls, false, sizeof(nulls));
/* need a tuple descriptor representing four columns */
tupdesc = CreateTemplateTupleDesc(4);
@@ -483,7 +482,7 @@ ReadReplicationSlot(ReadReplicationSlotCmd *cmd)
DestReceiver *dest;
TupOutputState *tstate;
TupleDesc tupdesc;
- Datum values[READ_REPLICATION_SLOT_COLS];
+ Datum values[READ_REPLICATION_SLOT_COLS] = {0};
bool nulls[READ_REPLICATION_SLOT_COLS];
tupdesc = CreateTemplateTupleDesc(READ_REPLICATION_SLOT_COLS);
@@ -495,8 +494,7 @@ ReadReplicationSlot(ReadReplicationSlotCmd *cmd)
TupleDescInitBuiltinEntry(tupdesc, (AttrNumber) 3, "restart_tli",
INT8OID, -1, 0);
- MemSet(values, 0, READ_REPLICATION_SLOT_COLS * sizeof(Datum));
- MemSet(nulls, true, READ_REPLICATION_SLOT_COLS * sizeof(bool));
+ memset(nulls, true, READ_REPLICATION_SLOT_COLS * sizeof(bool));
LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
slot = SearchNamedReplicationSlot(cmd->slotname, false);
TupOutputState *tstate;
TupleDesc tupdesc;
Datum values[2];
- bool nulls[2];
+ bool nulls[2] = {0};
snprintf(startpos_str, sizeof(startpos_str), "%X/%X",
LSN_FORMAT_ARGS(sendTimeLineValidUpto));
dest = CreateDestReceiver(DestRemoteSimple);
- MemSet(nulls, false, sizeof(nulls));
/*
* Need a tuple descriptor representing two columns. int8 may seem
@@ -1043,7 +1040,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
TupOutputState *tstate;
TupleDesc tupdesc;
Datum values[4];
- bool nulls[4];
+ bool nulls[4] = {0};
Assert(!MyReplicationSlot);
@@ -1178,7 +1175,6 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
LSN_FORMAT_ARGS(MyReplicationSlot->data.confirmed_flush));
dest = CreateDestReceiver(DestRemoteSimple);
- MemSet(nulls, false, sizeof(nulls));
/*----------
* Need a tuple descriptor representing four columns:
TimestampTz replyTime;
bool is_sync_standby;
Datum values[PG_STAT_GET_WAL_SENDERS_COLS];
- bool nulls[PG_STAT_GET_WAL_SENDERS_COLS];
+ bool nulls[PG_STAT_GET_WAL_SENDERS_COLS] = {0};
int j;
/* Collect data from shared memory */
}
}
- memset(nulls, 0, sizeof(nulls));
values[0] = Int32GetDatum(pid);
if (!has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_STATS))
index 185bf5fbff787829c3581d4bfdaba67854396e9b..a5a1fb887f22afb2910721f1141fa1385098579c 100644 (file)
char *evqual = nodeToString(event_qual);
char *actiontree = nodeToString((Node *) action);
Datum values[Natts_pg_rewrite];
- bool nulls[Natts_pg_rewrite];
- bool replaces[Natts_pg_rewrite];
+ bool nulls[Natts_pg_rewrite] = {0};
NameData rname;
Relation pg_rewrite_desc;
HeapTuple tup,
/*
* Set up *nulls and *values arrays
*/
- MemSet(nulls, false, sizeof(nulls));
-
namestrcpy(&rname, rulname);
values[Anum_pg_rewrite_rulename - 1] = NameGetDatum(&rname);
values[Anum_pg_rewrite_ev_class - 1] = ObjectIdGetDatum(eventrel_oid);
if (HeapTupleIsValid(oldtup))
{
+ bool replaces[Natts_pg_rewrite] = {0};
+
if (!replace)
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
/*
* When replacing, we don't need to replace every attribute
*/
- MemSet(replaces, false, sizeof(replaces));
replaces[Anum_pg_rewrite_ev_type - 1] = true;
replaces[Anum_pg_rewrite_is_instead - 1] = true;
replaces[Anum_pg_rewrite_ev_qual - 1] = true;
index b7fd3bcf057c69d3c6a58707dfbc6564c48d9bb6..6fa58dd8eb07db258fae180b4ca072d7638573b2 100644 (file)
{
Datum result;
Datum values[4];
- bool nulls[4];
+ bool nulls[4] = {0};
HeapTuple tuple;
values[0] = ObjectIdGetDatum(aidata->ai_grantor);
values[2] = CStringGetTextDatum(convert_aclright_to_string(priv_bit));
values[3] = BoolGetDatum((ACLITEM_GET_GOPTIONS(*aidata) & priv_bit) != 0);
- MemSet(nulls, 0, sizeof(nulls));
-
tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
index b0c37ede87d2fb0159f3cf331837656d2af09b0d..fb167f226a094933cf11da61ca1f75078afde231 100644 (file)
bool eoArray = false;
bool hasnull;
int32 totbytes;
- int indx[MAXDIM],
+ int indx[MAXDIM] = {0},
prod[MAXDIM];
mda_get_prod(ndim, dim, prod);
- MemSet(indx, 0, sizeof(indx));
/* Initialize is-null markers to true */
memset(nulls, true, nitems * sizeof(bool));
index 4c12c4d66302d21a1a143ef28822402792f47612..43fff50d490fb7814e57e88166a287817d721d4d 100644 (file)
Datum result;
HeapTuple tuple;
Datum values[3];
- bool nulls[3];
+ bool nulls[3] = {0};
const datetkn *tp;
char buffer[TOKMAXLEN + 1];
int gmtoffset;
break;
}
- MemSet(nulls, 0, sizeof(nulls));
-
/*
* Convert name to text, using upcasing conversion that is the inverse of
* what ParseDateTime() uses.
pg_tzenum *tzenum;
pg_tz *tz;
Datum values[4];
- bool nulls[4];
+ bool nulls[4] = {0};
int tzoff;
struct pg_tm tm;
fsec_t fsec;
if (tzn && strlen(tzn) > 31)
continue;
- MemSet(nulls, 0, sizeof(nulls));
-
values[0] = CStringGetTextDatum(pg_get_timezone_name(tz));
values[1] = CStringGetTextDatum(tzn ? tzn : "");
index dedee7af5cb767e2c9e5e383fd9ae62298dab464..f9b324efec7c2faf41b74969adb067322cfd77dc 100644 (file)
LOCKMODE mode = 0;
const char *locktypename;
char tnbuf[32];
- Datum values[NUM_LOCK_STATUS_COLUMNS];
- bool nulls[NUM_LOCK_STATUS_COLUMNS];
+ Datum values[NUM_LOCK_STATUS_COLUMNS] = {0};
+ bool nulls[NUM_LOCK_STATUS_COLUMNS] = {0};
HeapTuple tuple;
Datum result;
LockInstanceData *instance;
/*
* Form tuple with appropriate data.
*/
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
if (instance->locktag.locktag_type <= LOCKTAG_LAST_TYPE)
locktypename = LockTagTypeNames[instance->locktag.locktag_type];
PREDICATELOCKTARGETTAG *predTag = &(predLockData->locktags[mystatus->predLockIdx]);
SERIALIZABLEXACT *xact = &(predLockData->xacts[mystatus->predLockIdx]);
- Datum values[NUM_LOCK_STATUS_COLUMNS];
- bool nulls[NUM_LOCK_STATUS_COLUMNS];
+ Datum values[NUM_LOCK_STATUS_COLUMNS] = {0};
+ bool nulls[NUM_LOCK_STATUS_COLUMNS] = {0};
HeapTuple tuple;
Datum result;
/*
* Form tuple with appropriate data.
*/
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, false, sizeof(nulls));
/* lock type */
lockType = GET_PREDICATELOCKTARGETTAG_TYPE(*predTag);
index 0243bc061f643c2645a1acc8fbb6f2074ea9febd..109dc8023e1464376242cc0263d4eb23b9da936f 100644 (file)
if (funcctx->call_cntr < list_length(partitions))
{
Datum result;
- Datum values[PG_PARTITION_TREE_COLS];
- bool nulls[PG_PARTITION_TREE_COLS];
+ Datum values[PG_PARTITION_TREE_COLS] = {0};
+ bool nulls[PG_PARTITION_TREE_COLS] = {0};
HeapTuple tuple;
Oid parentid = InvalidOid;
Oid relid = list_nth_oid(partitions, funcctx->call_cntr);
/*
* Form tuple with appropriate data.
*/
- MemSet(nulls, 0, sizeof(nulls));
- MemSet(values, 0, sizeof(values));
/* relid */
values[0] = ObjectIdGetDatum(relid);
index 893690dad52049db1fde02ddeaf634793bcc8981..d9e2a79382964c210ecb0f6dae46b70971e2e52e 100644 (file)
{
LocalPgBackendStatus *local_beentry;
PgBackendStatus *beentry;
- Datum values[PG_STAT_GET_PROGRESS_COLS];
- bool nulls[PG_STAT_GET_PROGRESS_COLS];
+ Datum values[PG_STAT_GET_PROGRESS_COLS] = {0};
+ bool nulls[PG_STAT_GET_PROGRESS_COLS] = {0};
int i;
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
local_beentry = pgstat_fetch_stat_local_beentry(curr_backend);
if (!local_beentry)
for (curr_backend = 1; curr_backend <= num_backends; curr_backend++)
{
/* for each row */
- Datum values[PG_STAT_GET_ACTIVITY_COLS];
- bool nulls[PG_STAT_GET_ACTIVITY_COLS];
+ Datum values[PG_STAT_GET_ACTIVITY_COLS] = {0};
+ bool nulls[PG_STAT_GET_ACTIVITY_COLS] = {0};
LocalPgBackendStatus *local_beentry;
PgBackendStatus *beentry;
PGPROC *proc;
const char *wait_event_type = NULL;
const char *wait_event = NULL;
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
/* Get the next one in the list */
local_beentry = pgstat_fetch_stat_local_beentry(curr_backend);
if (!local_beentry)
{
#define PG_STAT_GET_WAL_COLS 9
TupleDesc tupdesc;
- Datum values[PG_STAT_GET_WAL_COLS];
- bool nulls[PG_STAT_GET_WAL_COLS];
+ Datum values[PG_STAT_GET_WAL_COLS] = {0};
+ bool nulls[PG_STAT_GET_WAL_COLS] = {0};
char buf[256];
PgStat_WalStats *wal_stats;
- /* Initialise values and NULL flags arrays */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
/* Initialise attributes information in the tuple descriptor */
tupdesc = CreateTemplateTupleDesc(PG_STAT_GET_WAL_COLS);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "wal_records",
for (i = 0;; i++)
{
/* for each row */
- Datum values[PG_STAT_GET_SLRU_COLS];
- bool nulls[PG_STAT_GET_SLRU_COLS];
+ Datum values[PG_STAT_GET_SLRU_COLS] = {0};
+ bool nulls[PG_STAT_GET_SLRU_COLS] = {0};
PgStat_SLRUStats stat;
const char *name;
break;
stat = stats[i];
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
values[0] = PointerGetDatum(cstring_to_text(name));
values[1] = Int64GetDatum(stat.blocks_zeroed);
pg_stat_get_archiver(PG_FUNCTION_ARGS)
{
TupleDesc tupdesc;
- Datum values[7];
- bool nulls[7];
+ Datum values[7] = {0};
+ bool nulls[7] = {0};
PgStat_ArchiverStats *archiver_stats;
- /* Initialise values and NULL flags arrays */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
/* Initialise attributes information in the tuple descriptor */
tupdesc = CreateTemplateTupleDesc(7);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "archived_count",
text *slotname_text = PG_GETARG_TEXT_P(0);
NameData slotname;
TupleDesc tupdesc;
- Datum values[PG_STAT_GET_REPLICATION_SLOT_COLS];
- bool nulls[PG_STAT_GET_REPLICATION_SLOT_COLS];
+ Datum values[PG_STAT_GET_REPLICATION_SLOT_COLS] = {0};
+ bool nulls[PG_STAT_GET_REPLICATION_SLOT_COLS] = {0};
PgStat_StatReplSlotEntry *slotent;
PgStat_StatReplSlotEntry allzero;
- /* Initialise values and NULL flags arrays */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
/* Initialise attributes information in the tuple descriptor */
tupdesc = CreateTemplateTupleDesc(PG_STAT_GET_REPLICATION_SLOT_COLS);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "slot_name",
@@ -2348,8 +2328,8 @@ pg_stat_get_subscription_stats(PG_FUNCTION_ARGS)
#define PG_STAT_GET_SUBSCRIPTION_STATS_COLS 4
Oid subid = PG_GETARG_OID(0);
TupleDesc tupdesc;
- Datum values[PG_STAT_GET_SUBSCRIPTION_STATS_COLS];
- bool nulls[PG_STAT_GET_SUBSCRIPTION_STATS_COLS];
+ Datum values[PG_STAT_GET_SUBSCRIPTION_STATS_COLS] = {0};
+ bool nulls[PG_STAT_GET_SUBSCRIPTION_STATS_COLS] = {0};
PgStat_StatSubEntry *subentry;
PgStat_StatSubEntry allzero;
TIMESTAMPTZOID, -1, 0);
BlessTupleDesc(tupdesc);
- /* Initialise values and NULL flags arrays */
- MemSet(values, 0, sizeof(values));
- MemSet(nulls, 0, sizeof(nulls));
-
if (!subentry)
{
/* If the subscription is not found, initialise its stats */
index fa1f589fad873a24bf8f901d42c24f1e9ab2362f..6f99b5b2437340080a60827f378da02f0f4f2588 100644 (file)
@@ -6642,10 +6642,10 @@ btcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
double *indexPages)
{
IndexOptInfo *index = path->indexinfo;
- GenericCosts costs;
+ GenericCosts costs = {0};
Oid relid;
AttrNumber colnum;
- VariableStatData vardata;
+ VariableStatData vardata = {0};
double numIndexTuples;
Cost descentCost;
List *indexBoundQuals;
@@ -6797,7 +6797,6 @@ btcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
/*
* Now do generic index cost estimation.
*/
- MemSet(&costs, 0, sizeof(costs));
costs.numIndexTuples = numIndexTuples;
genericcostestimate(root, path, loop_count, &costs);
@@ -6842,8 +6841,6 @@ btcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
* ordering, but don't negate it entirely. Before 8.0 we divided the
* correlation by the number of columns, but that seems too strong.)
*/
- MemSet(&vardata, 0, sizeof(vardata));
-
if (index->indexkeys[0] != 0)
{
/* Simple variable --- look to stats for the underlying table */
@@ -6947,9 +6944,7 @@ hashcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
Selectivity *indexSelectivity, double *indexCorrelation,
double *indexPages)
{
- GenericCosts costs;
-
- MemSet(&costs, 0, sizeof(costs));
+ GenericCosts costs = {0};
genericcostestimate(root, path, loop_count, &costs);
@@ -6992,11 +6987,9 @@ gistcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
double *indexPages)
{
IndexOptInfo *index = path->indexinfo;
- GenericCosts costs;
+ GenericCosts costs = {0};
Cost descentCost;
- MemSet(&costs, 0, sizeof(costs));
-
genericcostestimate(root, path, loop_count, &costs);
/*
@@ -7049,11 +7042,9 @@ spgcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
double *indexPages)
{
IndexOptInfo *index = path->indexinfo;
- GenericCosts costs;
+ GenericCosts costs = {0};
Cost descentCost;
- MemSet(&costs, 0, sizeof(costs));
-
genericcostestimate(root, path, loop_count, &costs);
/*
index f70f829d830f783420bd1ea8096f08d13bbbcf41..49cdb290ac289cf648bc8746aee426610209659c 100644 (file)
}
static int
-interval_cmp_internal(Interval *interval1, Interval *interval2)
+interval_cmp_internal(const Interval *interval1, const Interval *interval2)
{
INT128 span1 = interval_cmp_value(interval1);
INT128 span2 = interval_cmp_value(interval2);
Timestamp finish = PG_GETARG_TIMESTAMP(1);
Interval *step = PG_GETARG_INTERVAL_P(2);
MemoryContext oldcontext;
- Interval interval_zero;
+ const Interval interval_zero = {0};
/* create a function context for cross-call persistence */
funcctx = SRF_FIRSTCALL_INIT();
fctx->step = *step;
/* Determine sign of the interval */
- MemSet(&interval_zero, 0, sizeof(Interval));
fctx->step_sign = interval_cmp_internal(&fctx->step, &interval_zero);
if (fctx->step_sign == 0)
TimestampTz finish = PG_GETARG_TIMESTAMPTZ(1);
Interval *step = PG_GETARG_INTERVAL_P(2);
MemoryContext oldcontext;
- Interval interval_zero;
+ const Interval interval_zero = {0};
/* create a function context for cross-call persistence */
funcctx = SRF_FIRSTCALL_INIT();
fctx->step = *step;
/* Determine sign of the interval */
- MemSet(&interval_zero, 0, sizeof(Interval));
fctx->step_sign = interval_cmp_internal(&fctx->step, &interval_zero);
if (fctx->step_sign == 0)
index d549f66d4afd1466d1b5114723846480d5c62dfd..3a161bdb88d17c933a844650154e79bb2896ddf7 100644 (file)
{
Portal portal = hentry->portal;
Datum values[6];
- bool nulls[6];
+ bool nulls[6] = {0};
/* report only "visible" entries */
if (!portal->visible)
continue;
- MemSet(nulls, 0, sizeof(nulls));
-
values[0] = CStringGetTextDatum(portal->name);
values[1] = CStringGetTextDatum(portal->sourceText);
values[2] = BoolGetDatum(portal->cursorOptions & CURSOR_OPT_HOLD);
index 4445a86aee2018c5d087e5accae2ac1c72608e8a..1a877ba54e444a867ee27f4b4d0540e06c7fa676 100644 (file)
@@ -447,7 +447,7 @@ reached_end_position(XLogRecPtr segendpos, uint32 timeline,
{
#ifndef WIN32
fd_set fds;
- struct timeval tv;
+ struct timeval tv = {0};
int r;
/*
@@ -457,16 +457,13 @@ reached_end_position(XLogRecPtr segendpos, uint32 timeline,
FD_ZERO(&fds);
FD_SET(bgpipe[0], &fds);
- MemSet(&tv, 0, sizeof(tv));
-
r = select(bgpipe[0] + 1, &fds, NULL, NULL, &tv);
if (r == 1)
{
- char xlogend[64];
+ char xlogend[64] = {0};
uint32 hi,
lo;
- MemSet(xlogend, 0, sizeof(xlogend));
r = read(bgpipe[0], xlogend, sizeof(xlogend) - 1);
if (r < 0)
pg_fatal("could not read from ready pipe: %m");
static int
LogStreamerMain(logstreamer_param *param)
{
- StreamCtl stream;
+ StreamCtl stream = {0};
in_log_streamer = true;
- MemSet(&stream, 0, sizeof(stream));
stream.startpos = param->startptr;
stream.timeline = param->timeline;
stream.sysidentifier = param->sysidentifier;
@@ -1758,7 +1754,7 @@ BaseBackup(char *compression_algorithm, char *compression_detail,
char *basebkp;
int i;
char xlogstart[64];
- char xlogend[64];
+ char xlogend[64] = {0};
int minServerMajor,
maxServerMajor;
int serverVersion,
@@ -1952,7 +1948,6 @@ BaseBackup(char *compression_algorithm, char *compression_detail,
else
starttli = latesttli;
PQclear(res);
- MemSet(xlogend, 0, sizeof(xlogend));
if (verbose && includewal != NO_WAL)
pg_log_info("write-ahead log start point: %s on timeline %u",
index ea3902c9711a1689340626df97d1e447f68d9cb4..f064cff4aba04df1199878ab16ccc536edcc22e0 100644 (file)
{
XLogRecPtr serverpos;
TimeLineID servertli;
- StreamCtl stream;
+ StreamCtl stream = {0};
char *sysidentifier;
- MemSet(&stream, 0, sizeof(stream));
-
/*
* Connect in replication mode to the server
*/
index ef4c11277ac8d2387391ec2f08cbb5edd86b4122..e90aa0ba377d33e24dd43919c6cc30ecd9527529 100644 (file)
padding = tarPaddingBytesRequired(filesize);
if (padding)
{
- char zerobuf[TAR_BLOCK_SIZE];
+ char zerobuf[TAR_BLOCK_SIZE] = {0};
- MemSet(zerobuf, 0, padding);
if (tar_write(f, zerobuf, padding) != padding)
return -1;
}
static bool
tar_finish(void)
{
- char zerobuf[1024];
+ char zerobuf[1024] = {0};
tar_clear_error();
}
/* A tarfile always ends with two empty blocks */
- MemSet(zerobuf, 0, sizeof(zerobuf));
if (tar_data->compression_algorithm == PG_COMPRESSION_NONE)
{
errno = 0;
index cd73d49679dd291dc63d8c3ff54bab58848531d7..267103efb9975135e7cb7f79dd5fcebb2af8c88a 100644 (file)
getaddrinfo_unix(const char *path, const struct addrinfo *hintsp,
struct addrinfo **result)
{
- struct addrinfo hints;
+ struct addrinfo hints = {0};
struct addrinfo *aip;
struct sockaddr_un *unp;
*result = NULL;
- MemSet(&hints, 0, sizeof(hints));
-
if (strlen(path) >= sizeof(unp->sun_path))
return EAI_FAIL;
index abb1c597707746fe26efcf63fa1ed8308fdc1fb8..e037cf0a88e76986e9971cd1820d732b81d82fd2 100644 (file)
@@ -756,12 +756,8 @@ find_arguments(const char *format, va_list args,
int longflag;
int fmtpos;
int i;
- int last_dollar;
- PrintfArgType argtypes[PG_NL_ARGMAX + 1];
-
- /* Initialize to "no dollar arguments known" */
- last_dollar = 0;
- MemSet(argtypes, 0, sizeof(argtypes));
+ int last_dollar = 0; /* Init to "no dollar arguments known" */
+ PrintfArgType argtypes[PG_NL_ARGMAX + 1] = {0};
/*
* This loop must accept the same format strings as the one in dopr().
index 3b19e0eadc00a68563f566c8f953c8435c9723bb..2ce88cb6245207398b7e9bc44f848b37c8812560 100644 (file)
strong_refuted_by,
weak_refuted_by;
Datum values[8];
- bool nulls[8];
+ bool nulls[8] = {0};
int i;
/* We use SPI to parse, plan, and execute the test query */
"w_r_holds", BOOLOID, -1, 0);
tupdesc = BlessTupleDesc(tupdesc);
- MemSet(nulls, 0, sizeof(nulls));
values[0] = BoolGetDatum(strong_implied_by);
values[1] = BoolGetDatum(weak_implied_by);
values[2] = BoolGetDatum(strong_refuted_by);
index ba3532a51e852b99d1ad8e6c520283474c3cbd71..b88d70b6fcc18959bd2970fa9e3abd730a35d45a 100644 (file)
int convertedbytes;
int dstlen;
Datum values[2];
- bool nulls[2];
+ bool nulls[2] = {0};
HeapTuple tuple;
if (src_encoding < 0)
pfree(dst);
}
- MemSet(nulls, 0, sizeof(nulls));
values[0] = Int32GetDatum(convertedbytes);
values[1] = PointerGetDatum(retval);
tuple = heap_form_tuple(tupdesc, values, nulls);