diff options
| author | Bruce Momjian | 2011-06-09 18:32:50 +0000 |
|---|---|---|
| committer | Bruce Momjian | 2011-06-09 18:32:50 +0000 |
| commit | 6560407c7db2c7e32926a46f5fb52175ac10d9e5 (patch) | |
| tree | 9641e538893819410634624a8e0cb86a13d857a6 /src/backend | |
| parent | adf43b2b36ca3d7f988933990051c74a4bd0d6f8 (diff) | |
Pgindent run before 9.1 beta2.
Diffstat (limited to 'src/backend')
56 files changed, 413 insertions, 407 deletions
diff --git a/src/backend/access/gin/ginget.c b/src/backend/access/gin/ginget.c index 5b35b50034a..866785837f5 100644 --- a/src/backend/access/gin/ginget.c +++ b/src/backend/access/gin/ginget.c @@ -56,15 +56,15 @@ callConsistentFn(GinState *ginstate, GinScanKey key) key->recheckCurItem = true; return DatumGetBool(FunctionCall8Coll(&ginstate->consistentFn[key->attnum - 1], - ginstate->supportCollation[key->attnum - 1], + ginstate->supportCollation[key->attnum - 1], PointerGetDatum(key->entryRes), UInt16GetDatum(key->strategy), key->query, UInt32GetDatum(key->nuserentries), PointerGetDatum(key->extra_data), - PointerGetDatum(&key->recheckCurItem), + PointerGetDatum(&key->recheckCurItem), PointerGetDatum(key->queryValues), - PointerGetDatum(key->queryCategories))); + PointerGetDatum(key->queryCategories))); } /* @@ -252,7 +252,7 @@ collectMatchBitmap(GinBtreeData *btree, GinBtreeStack *stack, *---------- */ cmp = DatumGetInt32(FunctionCall4Coll(&btree->ginstate->comparePartialFn[attnum - 1], - btree->ginstate->supportCollation[attnum - 1], + btree->ginstate->supportCollation[attnum - 1], scanEntry->queryKey, idatum, UInt16GetDatum(scanEntry->strategy), @@ -1178,10 +1178,10 @@ matchPartialInPendingList(GinState *ginstate, Page page, *---------- */ cmp = DatumGetInt32(FunctionCall4Coll(&ginstate->comparePartialFn[entry->attnum - 1], - ginstate->supportCollation[entry->attnum - 1], + ginstate->supportCollation[entry->attnum - 1], entry->queryKey, datum[off - 1], - UInt16GetDatum(entry->strategy), + UInt16GetDatum(entry->strategy), PointerGetDatum(entry->extra_data))); if (cmp == 0) return true; diff --git a/src/backend/access/gin/ginscan.c b/src/backend/access/gin/ginscan.c index d9f5b8c012e..f8d54b1b462 100644 --- a/src/backend/access/gin/ginscan.c +++ b/src/backend/access/gin/ginscan.c @@ -306,11 +306,11 @@ ginNewScanKey(IndexScanDesc scan) /* OK to call the extractQueryFn */ queryValues = (Datum *) DatumGetPointer(FunctionCall7Coll(&so->ginstate.extractQueryFn[skey->sk_attno - 1], - so->ginstate.supportCollation[skey->sk_attno - 1], + so->ginstate.supportCollation[skey->sk_attno - 1], skey->sk_argument, PointerGetDatum(&nQueryValues), - UInt16GetDatum(skey->sk_strategy), - PointerGetDatum(&partial_matches), + UInt16GetDatum(skey->sk_strategy), + PointerGetDatum(&partial_matches), PointerGetDatum(&extra_data), PointerGetDatum(&nullFlags), PointerGetDatum(&searchMode))); diff --git a/src/backend/access/gin/ginutil.c b/src/backend/access/gin/ginutil.c index 1ae51b10602..ba142bc874d 100644 --- a/src/backend/access/gin/ginutil.c +++ b/src/backend/access/gin/ginutil.c @@ -94,8 +94,8 @@ initGinState(GinState *state, Relation index) * type for a noncollatable indexed data type (for instance, hstore * uses text index entries). If there's no index collation then * specify default collation in case the support functions need - * collation. This is harmless if the support functions don't - * care about collation, so we just do it unconditionally. (We could + * collation. This is harmless if the support functions don't care + * about collation, so we just do it unconditionally. (We could * alternatively call get_typcollation, but that seems like expensive * overkill --- there aren't going to be any cases where a GIN storage * type has a nondefault collation.) @@ -293,7 +293,7 @@ ginCompareEntries(GinState *ginstate, OffsetNumber attnum, /* both not null, so safe to call the compareFn */ return DatumGetInt32(FunctionCall2Coll(&ginstate->compareFn[attnum - 1], - ginstate->supportCollation[attnum - 1], + ginstate->supportCollation[attnum - 1], a, b)); } @@ -400,7 +400,7 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum, nullFlags = NULL; /* in case extractValue doesn't set it */ entries = (Datum *) DatumGetPointer(FunctionCall3Coll(&ginstate->extractValueFn[attnum - 1], - ginstate->supportCollation[attnum - 1], + ginstate->supportCollation[attnum - 1], value, PointerGetDatum(nentries), PointerGetDatum(&nullFlags))); diff --git a/src/backend/access/gist/gist.c b/src/backend/access/gist/gist.c index 0e779e09d71..8227bfdb88b 100644 --- a/src/backend/access/gist/gist.c +++ b/src/backend/access/gist/gist.c @@ -1399,7 +1399,7 @@ initGISTstate(GISTSTATE *giststate, Relation index) /* * If the index column has a specified collation, we should honor that * while doing comparisons. However, we may have a collatable storage - * type for a noncollatable indexed data type. If there's no index + * type for a noncollatable indexed data type. If there's no index * collation then specify default collation in case the support * functions need collation. This is harmless if the support * functions don't care about collation, so we just do it diff --git a/src/backend/access/gist/gistutil.c b/src/backend/access/gist/gistutil.c index 1aabcc527ac..1754a103699 100644 --- a/src/backend/access/gist/gistutil.c +++ b/src/backend/access/gist/gistutil.c @@ -448,7 +448,7 @@ gistdentryinit(GISTSTATE *giststate, int nkey, GISTENTRY *e, gistentryinit(*e, k, r, pg, o, l); dep = (GISTENTRY *) DatumGetPointer(FunctionCall1Coll(&giststate->decompressFn[nkey], - giststate->supportCollation[nkey], + giststate->supportCollation[nkey], PointerGetDatum(e))); /* decompressFn may just return the given pointer */ if (dep != e) @@ -475,7 +475,7 @@ gistcentryinit(GISTSTATE *giststate, int nkey, gistentryinit(*e, k, r, pg, o, l); cep = (GISTENTRY *) DatumGetPointer(FunctionCall1Coll(&giststate->compressFn[nkey], - giststate->supportCollation[nkey], + giststate->supportCollation[nkey], PointerGetDatum(e))); /* compressFn may just return the given pointer */ if (cep != e) diff --git a/src/backend/access/index/indexam.c b/src/backend/access/index/indexam.c index 27c37d6173f..02087659647 100644 --- a/src/backend/access/index/indexam.c +++ b/src/backend/access/index/indexam.c @@ -80,7 +80,7 @@ * * Note: the ReindexIsProcessingIndex() check in RELATION_CHECKS is there * to check that we don't try to scan or do retail insertions into an index - * that is currently being rebuilt or pending rebuild. This helps to catch + * that is currently being rebuilt or pending rebuild. This helps to catch * things that don't work when reindexing system catalogs. The assertion * doesn't prevent the actual rebuild because we don't use RELATION_CHECKS * when calling the index AM's ambuild routine, and there is no reason for diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c index 55136e9cc4c..93a928c66b2 100644 --- a/src/backend/access/nbtree/nbtsort.c +++ b/src/backend/access/nbtree/nbtsort.c @@ -738,7 +738,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2) { compare = DatumGetInt32(FunctionCall2Coll(&entry->sk_func, - entry->sk_collation, + entry->sk_collation, attrDatum1, attrDatum2)); diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c index 71bcb42c190..2e896a258f7 100644 --- a/src/backend/access/nbtree/nbtutils.c +++ b/src/backend/access/nbtree/nbtutils.c @@ -635,7 +635,7 @@ _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op, *result = DatumGetBool(OidFunctionCall2Coll(cmp_proc, op->sk_collation, leftarg->sk_argument, - rightarg->sk_argument)); + rightarg->sk_argument)); return true; } } diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index e71090f71b5..5c3ca479fb3 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -6656,15 +6656,15 @@ StartupXLOG(void) ereport(FATAL, (errmsg("requested recovery stop point is before consistent recovery point"))); } + /* - * Ran off end of WAL before reaching end-of-backup WAL record, - * or minRecoveryPoint. That's usually a bad sign, indicating that - * you tried to recover from an online backup but never called + * Ran off end of WAL before reaching end-of-backup WAL record, or + * minRecoveryPoint. That's usually a bad sign, indicating that you + * tried to recover from an online backup but never called * pg_stop_backup(), or you didn't archive all the WAL up to that - * point. However, this also happens in crash recovery, if the - * system crashes while an online backup is in progress. We - * must not treat that as an error, or the database will refuse - * to start up. + * point. However, this also happens in crash recovery, if the system + * crashes while an online backup is in progress. We must not treat + * that as an error, or the database will refuse to start up. */ if (InArchiveRecovery) { @@ -6674,7 +6674,7 @@ StartupXLOG(void) errhint("Online backup started with pg_start_backup() must be ended with pg_stop_backup(), and all WAL up to that point must be available at recovery."))); else ereport(FATAL, - (errmsg("WAL ends before consistent recovery point"))); + (errmsg("WAL ends before consistent recovery point"))); } } diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c index 0898cf363e9..39ba4869af6 100644 --- a/src/backend/catalog/index.c +++ b/src/backend/catalog/index.c @@ -1773,8 +1773,8 @@ index_build(Relation heapRelation, * However, when reindexing an existing index, we should do nothing here. * Any HOT chains that are broken with respect to the index must predate * the index's original creation, so there is no need to change the - * index's usability horizon. Moreover, we *must not* try to change - * the index's pg_index entry while reindexing pg_index itself, and this + * index's usability horizon. Moreover, we *must not* try to change the + * index's pg_index entry while reindexing pg_index itself, and this * optimization nicely prevents that. */ if (indexInfo->ii_BrokenHotChain && !isreindex) @@ -1824,7 +1824,7 @@ index_build(Relation heapRelation, /* * If it's for an exclusion constraint, make a second pass over the heap - * to verify that the constraint is satisfied. We must not do this until + * to verify that the constraint is satisfied. We must not do this until * the index is fully valid. (Broken HOT chains shouldn't matter, though; * see comments for IndexCheckExclusion.) */ @@ -2136,8 +2136,8 @@ IndexBuildHeapScan(Relation heapRelation, /* * It's a HOT-updated tuple deleted by our own xact. * We can assume the deletion will commit (else the - * index contents don't matter), so treat the same - * as RECENTLY_DEAD HOT-updated tuples. + * index contents don't matter), so treat the same as + * RECENTLY_DEAD HOT-updated tuples. */ indexIt = false; /* mark the index as unsafe for old snapshots */ @@ -2146,9 +2146,9 @@ IndexBuildHeapScan(Relation heapRelation, else { /* - * It's a regular tuple deleted by our own xact. - * Index it but don't check for uniqueness, the same - * as a RECENTLY_DEAD tuple. + * It's a regular tuple deleted by our own xact. Index + * it but don't check for uniqueness, the same as a + * RECENTLY_DEAD tuple. */ indexIt = true; } @@ -2281,9 +2281,8 @@ IndexCheckExclusion(Relation heapRelation, /* * If we are reindexing the target index, mark it as no longer being - * reindexed, to forestall an Assert in index_beginscan when we try to - * use the index for probes. This is OK because the index is now - * fully valid. + * reindexed, to forestall an Assert in index_beginscan when we try to use + * the index for probes. This is OK because the index is now fully valid. */ if (ReindexIsCurrentlyProcessingIndex(RelationGetRelid(indexRelation))) ResetReindexProcessing(); @@ -2855,9 +2854,9 @@ reindex_index(Oid indexId, bool skip_constraint_checks) * * We can also reset indcheckxmin, because we have now done a * non-concurrent index build, *except* in the case where index_build - * found some still-broken HOT chains. If it did, we normally leave + * found some still-broken HOT chains. If it did, we normally leave * indcheckxmin alone (note that index_build won't have changed it, - * because this is a reindex). But if the index was invalid or not ready + * because this is a reindex). But if the index was invalid or not ready * and there were broken HOT chains, it seems best to force indcheckxmin * true, because the normal argument that the HOT chains couldn't conflict * with the index is suspect for an invalid index. @@ -2929,7 +2928,7 @@ reindex_index(Oid indexId, bool skip_constraint_checks) * the data in a manner that risks a change in constraint validity. * * Returns true if any indexes were rebuilt (including toast table's index - * when relevant). Note that a CommandCounterIncrement will occur after each + * when relevant). Note that a CommandCounterIncrement will occur after each * index rebuild. */ bool diff --git a/src/backend/catalog/namespace.c b/src/backend/catalog/namespace.c index d803d28a067..41e92992dee 100644 --- a/src/backend/catalog/namespace.c +++ b/src/backend/catalog/namespace.c @@ -362,7 +362,7 @@ RangeVarGetCreationNamespace(const RangeVar *newRelation) /* * RangeVarGetAndCheckCreationNamespace - * As RangeVarGetCreationNamespace, but with a permissions check. + * As RangeVarGetCreationNamespace, but with a permissions check. */ Oid RangeVarGetAndCheckCreationNamespace(const RangeVar *newRelation) diff --git a/src/backend/catalog/toasting.c b/src/backend/catalog/toasting.c index a8cf0dbe2f2..b059f9d784b 100644 --- a/src/backend/catalog/toasting.c +++ b/src/backend/catalog/toasting.c @@ -60,8 +60,8 @@ AlterTableCreateToastTable(Oid relOid, Datum reloptions) /* * Grab a DDL-exclusive lock on the target table, since we'll update the - * pg_class tuple. This is redundant for all present users. Tuple toasting - * behaves safely in the face of a concurrent TOAST table add. + * pg_class tuple. This is redundant for all present users. Tuple + * toasting behaves safely in the face of a concurrent TOAST table add. */ rel = heap_open(relOid, ShareUpdateExclusiveLock); @@ -274,13 +274,13 @@ create_toast_table(Relation rel, Oid toastOid, Oid toastIndexOid, Datum reloptio coloptions[1] = 0; index_create(toast_rel, toast_idxname, toastIndexOid, - indexInfo, - list_make2("chunk_id", "chunk_seq"), - BTREE_AM_OID, - rel->rd_rel->reltablespace, - collationObjectId, classObjectId, coloptions, (Datum) 0, - true, false, false, false, - true, false, false); + indexInfo, + list_make2("chunk_id", "chunk_seq"), + BTREE_AM_OID, + rel->rd_rel->reltablespace, + collationObjectId, classObjectId, coloptions, (Datum) 0, + true, false, false, false, + true, false, false); heap_close(toast_rel, NoLock); diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c index fa84989fc6f..57188bc25a7 100644 --- a/src/backend/commands/analyze.c +++ b/src/backend/commands/analyze.c @@ -566,7 +566,7 @@ do_analyze_rel(Relation onerel, VacuumStmt *vacstmt, bool inh) } /* - * Report ANALYZE to the stats collector, too. However, if doing + * Report ANALYZE to the stats collector, too. However, if doing * inherited stats we shouldn't report, because the stats collector only * tracks per-table stats. */ @@ -1231,7 +1231,7 @@ acquire_sample_rows(Relation onerel, HeapTuple *rows, int targrows, qsort((void *) rows, numrows, sizeof(HeapTuple), compare_rows); /* - * Estimate total numbers of rows in relation. For live rows, use + * Estimate total numbers of rows in relation. For live rows, use * vac_estimate_reltuples; for dead rows, we have no source of old * information, so we have to assume the density is the same in unseen * pages as in the pages we scanned. diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c index 0ab3a8bcfae..c020dc2e4ec 100644 --- a/src/backend/commands/cluster.c +++ b/src/backend/commands/cluster.c @@ -762,12 +762,12 @@ copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex, /* * If the OldHeap has a toast table, get lock on the toast table to keep - * it from being vacuumed. This is needed because autovacuum processes + * it from being vacuumed. This is needed because autovacuum processes * toast tables independently of their main tables, with no lock on the - * latter. If an autovacuum were to start on the toast table after we + * latter. If an autovacuum were to start on the toast table after we * compute our OldestXmin below, it would use a later OldestXmin, and then * possibly remove as DEAD toast tuples belonging to main tuples we think - * are only RECENTLY_DEAD. Then we'd fail while trying to copy those + * are only RECENTLY_DEAD. Then we'd fail while trying to copy those * tuples. * * We don't need to open the toast relation here, just lock it. The lock diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c index 479db2c3f11..b7c021d943a 100644 --- a/src/backend/commands/indexcmds.c +++ b/src/backend/commands/indexcmds.c @@ -185,14 +185,15 @@ DefineIndex(RangeVar *heapRelation, rel->rd_rel->relkind != RELKIND_UNCATALOGED) { if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE) + /* - * Custom error message for FOREIGN TABLE since the term is - * close to a regular table and can confuse the user. + * Custom error message for FOREIGN TABLE since the term is close + * to a regular table and can confuse the user. */ ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("cannot create index on foreign table \"%s\"", - heapRelation->relname))); + heapRelation->relname))); else ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c index 383690270b8..be04177a2ee 100644 --- a/src/backend/commands/sequence.c +++ b/src/backend/commands/sequence.c @@ -1077,12 +1077,12 @@ read_info(SeqTable elm, Relation rel, Buffer *buf) tuple.t_data = (HeapTupleHeader) PageGetItem(page, lp); /* - * Previous releases of Postgres neglected to prevent SELECT FOR UPDATE - * on a sequence, which would leave a non-frozen XID in the sequence - * tuple's xmax, which eventually leads to clog access failures or worse. - * If we see this has happened, clean up after it. We treat this like a - * hint bit update, ie, don't bother to WAL-log it, since we can certainly - * do this again if the update gets lost. + * Previous releases of Postgres neglected to prevent SELECT FOR UPDATE on + * a sequence, which would leave a non-frozen XID in the sequence tuple's + * xmax, which eventually leads to clog access failures or worse. If we + * see this has happened, clean up after it. We treat this like a hint + * bit update, ie, don't bother to WAL-log it, since we can certainly do + * this again if the update gets lost. */ if (HeapTupleHeaderGetXmax(tuple.t_data) != InvalidTransactionId) { diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index 6279f2bf9a5..2c9f855f531 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -2679,7 +2679,8 @@ AlterTableGetLockLevel(List *cmds) * These subcommands affect implicit row type conversion. They * have affects similar to CREATE/DROP CAST on queries. We * don't provide for invalidating parse trees as a result of - * such changes. Do avoid concurrent pg_class updates, though. + * such changes. Do avoid concurrent pg_class updates, + * though. */ case AT_AddOf: case AT_DropOf: @@ -2946,7 +2947,7 @@ ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd, case AT_DisableRule: case AT_DropInherit: /* NO INHERIT */ case AT_AddOf: /* OF */ - case AT_DropOf: /* NOT OF */ + case AT_DropOf: /* NOT OF */ ATSimplePermissions(rel, ATT_TABLE); /* These commands never recurse */ /* No command-specific prep needed */ @@ -4067,7 +4068,7 @@ find_typed_table_dependencies(Oid typeOid, const char *typeName, DropBehavior be * * Check whether a type is suitable for CREATE TABLE OF/ALTER TABLE OF. If it * isn't suitable, throw an error. Currently, we require that the type - * originated with CREATE TYPE AS. We could support any row type, but doing so + * originated with CREATE TYPE AS. We could support any row type, but doing so * would require handling a number of extra corner cases in the DDL commands. */ void @@ -4083,6 +4084,7 @@ check_of_type(HeapTuple typetuple) Assert(OidIsValid(typ->typrelid)); typeRelation = relation_open(typ->typrelid, AccessShareLock); typeOk = (typeRelation->rd_rel->relkind == RELKIND_COMPOSITE_TYPE); + /* * Close the parent rel, but keep our AccessShareLock on it until xact * commit. That will prevent someone else from deleting or ALTERing @@ -7406,8 +7408,8 @@ ATExecChangeOwner(Oid relationOid, Oid newOwnerId, bool recursing, LOCKMODE lock default: ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("\"%s\" is not a table, view, sequence, or foreign table", - NameStr(tuple_class->relname)))); + errmsg("\"%s\" is not a table, view, sequence, or foreign table", + NameStr(tuple_class->relname)))); } /* @@ -8603,7 +8605,7 @@ ATExecDropInherit(Relation rel, RangeVar *parent, LOCKMODE lockmode) * Drop the dependency created by StoreCatalogInheritance1 (CREATE TABLE * INHERITS/ALTER TABLE INHERIT -- refclassid will be RelationRelationId) or * heap_create_with_catalog (CREATE TABLE OF/ALTER TABLE OF -- refclassid will - * be TypeRelationId). There's no convenient way to do this, so go trawling + * be TypeRelationId). There's no convenient way to do this, so go trawling * through pg_depend. */ static void @@ -8730,8 +8732,8 @@ ATExecAddOf(Relation rel, const TypeName *ofTypename, LOCKMODE lockmode) if (strncmp(table_attname, type_attname, NAMEDATALEN) != 0) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), - errmsg("table has column \"%s\" where type requires \"%s\"", - table_attname, type_attname))); + errmsg("table has column \"%s\" where type requires \"%s\"", + table_attname, type_attname))); /* Compare type. */ if (table_attr->atttypid != type_attr->atttypid || @@ -8739,8 +8741,8 @@ ATExecAddOf(Relation rel, const TypeName *ofTypename, LOCKMODE lockmode) table_attr->attcollation != type_attr->attcollation) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), - errmsg("table \"%s\" has different type for column \"%s\"", - RelationGetRelationName(rel), type_attname))); + errmsg("table \"%s\" has different type for column \"%s\"", + RelationGetRelationName(rel), type_attname))); } DecrTupleDescRefCount(typeTupleDesc); @@ -8748,6 +8750,7 @@ ATExecAddOf(Relation rel, const TypeName *ofTypename, LOCKMODE lockmode) for (; table_attno <= tableTupleDesc->natts; table_attno++) { Form_pg_attribute table_attr = tableTupleDesc->attrs[table_attno - 1]; + if (!table_attr->attisdropped) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), @@ -8785,7 +8788,7 @@ ATExecAddOf(Relation rel, const TypeName *ofTypename, LOCKMODE lockmode) /* * ALTER TABLE NOT OF * - * Detach a typed table from its originating type. Just clear reloftype and + * Detach a typed table from its originating type. Just clear reloftype and * remove the dependency. */ static void @@ -8802,8 +8805,8 @@ ATExecDropOf(Relation rel, LOCKMODE lockmode) RelationGetRelationName(rel)))); /* - * We don't bother to check ownership of the type --- ownership of the table - * is presumed enough rights. No lock required on the type, either. + * We don't bother to check ownership of the type --- ownership of the + * table is presumed enough rights. No lock required on the type, either. */ drop_parent_dependency(relid, TypeRelationId, rel->rd_rel->reloftype); diff --git a/src/backend/commands/tsearchcmds.c b/src/backend/commands/tsearchcmds.c index d08c9bbbc5c..3355eaafda2 100644 --- a/src/backend/commands/tsearchcmds.c +++ b/src/backend/commands/tsearchcmds.c @@ -96,6 +96,7 @@ get_ts_parser_func(DefElem *defel, int attnum) break; case Anum_pg_ts_parser_prslextype: nargs = 1; + /* * Note: because the lextype method returns type internal, it must * have an internal-type argument for security reasons. The diff --git a/src/backend/commands/typecmds.c b/src/backend/commands/typecmds.c index f8eb5bc4a65..66c11de6723 100644 --- a/src/backend/commands/typecmds.c +++ b/src/backend/commands/typecmds.c @@ -1069,7 +1069,7 @@ DefineDomain(CreateDomainStmt *stmt) basetypeMod, /* typeMod value */ typNDims, /* Array dimensions for base type */ typNotNull, /* Type NOT NULL */ - domaincoll); /* type's collation */ + domaincoll); /* type's collation */ /* * Process constraints which refer to the domain ID returned by TypeCreate diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c index 224c34f6e78..5cbf3a04f80 100644 --- a/src/backend/commands/vacuum.c +++ b/src/backend/commands/vacuum.c @@ -459,7 +459,7 @@ vacuum_set_xid_limits(int freeze_min_age, * If we scanned the whole relation then we should just use the count of * live tuples seen; but if we did not, we should not trust the count * unreservedly, especially not in VACUUM, which may have scanned a quite - * nonrandom subset of the table. When we have only partial information, + * nonrandom subset of the table. When we have only partial information, * we take the old value of pg_class.reltuples as a measurement of the * tuple density in the unscanned pages. * @@ -471,7 +471,7 @@ vac_estimate_reltuples(Relation relation, bool is_analyze, BlockNumber scanned_pages, double scanned_tuples) { - BlockNumber old_rel_pages = relation->rd_rel->relpages; + BlockNumber old_rel_pages = relation->rd_rel->relpages; double old_rel_tuples = relation->rd_rel->reltuples; double old_density; double new_density; @@ -483,8 +483,8 @@ vac_estimate_reltuples(Relation relation, bool is_analyze, return scanned_tuples; /* - * If scanned_pages is zero but total_pages isn't, keep the existing - * value of reltuples. + * If scanned_pages is zero but total_pages isn't, keep the existing value + * of reltuples. */ if (scanned_pages == 0) return old_rel_tuples; @@ -498,23 +498,23 @@ vac_estimate_reltuples(Relation relation, bool is_analyze, /* * Okay, we've covered the corner cases. The normal calculation is to - * convert the old measurement to a density (tuples per page), then - * update the density using an exponential-moving-average approach, - * and finally compute reltuples as updated_density * total_pages. + * convert the old measurement to a density (tuples per page), then update + * the density using an exponential-moving-average approach, and finally + * compute reltuples as updated_density * total_pages. * - * For ANALYZE, the moving average multiplier is just the fraction of - * the table's pages we scanned. This is equivalent to assuming - * that the tuple density in the unscanned pages didn't change. Of - * course, it probably did, if the new density measurement is different. - * But over repeated cycles, the value of reltuples will converge towards - * the correct value, if repeated measurements show the same new density. + * For ANALYZE, the moving average multiplier is just the fraction of the + * table's pages we scanned. This is equivalent to assuming that the + * tuple density in the unscanned pages didn't change. Of course, it + * probably did, if the new density measurement is different. But over + * repeated cycles, the value of reltuples will converge towards the + * correct value, if repeated measurements show the same new density. * * For VACUUM, the situation is a bit different: we have looked at a * nonrandom sample of pages, but we know for certain that the pages we * didn't look at are precisely the ones that haven't changed lately. * Thus, there is a reasonable argument for doing exactly the same thing - * as for the ANALYZE case, that is use the old density measurement as - * the value for the unscanned pages. + * as for the ANALYZE case, that is use the old density measurement as the + * value for the unscanned pages. * * This logic could probably use further refinement. */ diff --git a/src/backend/commands/vacuumlazy.c b/src/backend/commands/vacuumlazy.c index ce5fa180662..ccc586f12ef 100644 --- a/src/backend/commands/vacuumlazy.c +++ b/src/backend/commands/vacuumlazy.c @@ -86,7 +86,7 @@ typedef struct LVRelStats /* Overall statistics about rel */ BlockNumber rel_pages; /* total number of pages */ BlockNumber scanned_pages; /* number of pages we examined */ - double scanned_tuples; /* counts only tuples on scanned pages */ + double scanned_tuples; /* counts only tuples on scanned pages */ double old_rel_tuples; /* previous value of pg_class.reltuples */ double new_rel_tuples; /* new estimated total # of tuples */ BlockNumber pages_removed; @@ -211,7 +211,7 @@ lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt, vac_update_relstats(onerel, vacrelstats->rel_pages, vacrelstats->new_rel_tuples, vacrelstats->hasindex, - (vacrelstats->scanned_pages < vacrelstats->rel_pages) ? + (vacrelstats->scanned_pages < vacrelstats->rel_pages) ? InvalidTransactionId : FreezeLimit); @@ -341,9 +341,9 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats, * of pages. * * Before entering the main loop, establish the invariant that - * next_not_all_visible_block is the next block number >= blkno that's - * not all-visible according to the visibility map, or nblocks if there's - * no such block. Also, we set up the skipping_all_visible_blocks flag, + * next_not_all_visible_block is the next block number >= blkno that's not + * all-visible according to the visibility map, or nblocks if there's no + * such block. Also, we set up the skipping_all_visible_blocks flag, * which is needed because we need hysteresis in the decision: once we've * started skipping blocks, we may as well skip everything up to the next * not-all-visible block. @@ -804,7 +804,7 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats, /* now we can compute the new value for pg_class.reltuples */ vacrelstats->new_rel_tuples = vac_estimate_reltuples(onerel, false, nblocks, - vacrelstats->scanned_pages, + vacrelstats->scanned_pages, num_tuples); /* If any tuples need to be deleted, perform final vacuum cycle */ @@ -1082,11 +1082,11 @@ lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats) if (new_rel_pages != old_rel_pages) { /* - * Note: we intentionally don't update vacrelstats->rel_pages with - * the new rel size here. If we did, it would amount to assuming that - * the new pages are empty, which is unlikely. Leaving the numbers - * alone amounts to assuming that the new pages have the same tuple - * density as existing ones, which is less unlikely. + * Note: we intentionally don't update vacrelstats->rel_pages with the + * new rel size here. If we did, it would amount to assuming that the + * new pages are empty, which is unlikely. Leaving the numbers alone + * amounts to assuming that the new pages have the same tuple density + * as existing ones, which is less unlikely. */ UnlockRelation(onerel, AccessExclusiveLock); return; diff --git a/src/backend/commands/variable.c b/src/backend/commands/variable.c index 9efd20f2bcf..8550869db3d 100644 --- a/src/backend/commands/variable.c +++ b/src/backend/commands/variable.c @@ -807,9 +807,9 @@ check_client_encoding(char **newval, void **extra, GucSource source) * * XXX Although canonicalizing seems like a good idea in the abstract, it * breaks pre-9.1 JDBC drivers, which expect that if they send "UNICODE" - * as the client_encoding setting then it will read back the same way. - * As a workaround, don't replace the string if it's "UNICODE". Remove - * that hack when pre-9.1 JDBC drivers are no longer in use. + * as the client_encoding setting then it will read back the same way. As + * a workaround, don't replace the string if it's "UNICODE". Remove that + * hack when pre-9.1 JDBC drivers are no longer in use. */ if (strcmp(*newval, canonical_name) != 0 && strcmp(*newval, "UNICODE") != 0) diff --git a/src/backend/executor/nodeHashjoin.c b/src/backend/executor/nodeHashjoin.c index 0e7ca625cee..3a6698105f2 100644 --- a/src/backend/executor/nodeHashjoin.c +++ b/src/backend/executor/nodeHashjoin.c @@ -265,8 +265,8 @@ ExecHashJoin(HashJoinState *node) /* * We check for interrupts here because this corresponds to - * where we'd fetch a row from a child plan node in other - * join types. + * where we'd fetch a row from a child plan node in other join + * types. */ CHECK_FOR_INTERRUPTS(); diff --git a/src/backend/libpq/auth.c b/src/backend/libpq/auth.c index f4099ac2345..778849e4347 100644 --- a/src/backend/libpq/auth.c +++ b/src/backend/libpq/auth.c @@ -929,7 +929,7 @@ pg_GSS_error(int severity, char *errmsg, OM_uint32 maj_stat, OM_uint32 min_stat) /* Fetch major status message */ msg_ctx = 0; gss_display_status(&lmin_s, maj_stat, GSS_C_GSS_CODE, - GSS_C_NO_OID, &msg_ctx, &gmsg); + GSS_C_NO_OID, &msg_ctx, &gmsg); strlcpy(msg_major, gmsg.value, sizeof(msg_major)); gss_release_buffer(&lmin_s, &gmsg); @@ -945,7 +945,7 @@ pg_GSS_error(int severity, char *errmsg, OM_uint32 maj_stat, OM_uint32 min_stat) /* Fetch mechanism minor status message */ msg_ctx = 0; gss_display_status(&lmin_s, min_stat, GSS_C_MECH_CODE, - GSS_C_NO_OID, &msg_ctx, &gmsg); + GSS_C_NO_OID, &msg_ctx, &gmsg); strlcpy(msg_minor, gmsg.value, sizeof(msg_minor)); gss_release_buffer(&lmin_s, &gmsg); @@ -1761,7 +1761,7 @@ auth_peer(hbaPort *port) if (errno == ENOSYS) ereport(LOG, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("peer authentication is not supported on this platform"))); + errmsg("peer authentication is not supported on this platform"))); else ereport(LOG, (errcode_for_socket_access(), diff --git a/src/backend/libpq/hba.c b/src/backend/libpq/hba.c index f3a3b6e2cc1..fe86dc62193 100644 --- a/src/backend/libpq/hba.c +++ b/src/backend/libpq/hba.c @@ -494,8 +494,8 @@ check_role(const char *role, Oid roleid, char *param_str) return true; } else if (strcmp(tok, role) == 0 || - (strcmp(tok, "replication\n") == 0 && - strcmp(role,"replication") ==0) || + (strcmp(tok, "replication\n") == 0 && + strcmp(role, "replication") == 0) || strcmp(tok, "all\n") == 0) return true; } diff --git a/src/backend/main/main.c b/src/backend/main/main.c index 51959371ce6..8d9cb9428df 100644 --- a/src/backend/main/main.c +++ b/src/backend/main/main.c @@ -392,7 +392,7 @@ get_current_username(const char *progname) /* Allocate new memory because later getpwuid() calls can overwrite it. */ return strdup(pw->pw_name); #else - unsigned long namesize = 256 /* UNLEN */ + 1; + unsigned long namesize = 256 /* UNLEN */ + 1; char *name; name = malloc(namesize); diff --git a/src/backend/optimizer/geqo/geqo_main.c b/src/backend/optimizer/geqo/geqo_main.c index e2a8bbcc1ac..e521bf7e3cb 100644 --- a/src/backend/optimizer/geqo/geqo_main.c +++ b/src/backend/optimizer/geqo/geqo_main.c @@ -74,6 +74,7 @@ geqo(PlannerInfo *root, int number_of_rels, List *initial_rels) Pool *pool; int pool_size, number_generations; + #ifdef GEQO_DEBUG int status_interval; #endif diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c index c4404b1bd17..bb38768bd43 100644 --- a/src/backend/optimizer/path/costsize.c +++ b/src/backend/optimizer/path/costsize.c @@ -2687,7 +2687,7 @@ cost_qual_eval_walker(Node *node, cost_qual_eval_context *context) * evaluation of AND/OR? Probably *not*, because that would make the * results depend on the clause ordering, and we are not in any position * to expect that the current ordering of the clauses is the one that's - * going to end up being used. The above per-RestrictInfo caching would + * going to end up being used. The above per-RestrictInfo caching would * not mix well with trying to re-order clauses anyway. */ if (IsA(node, FuncExpr)) diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c index 42427d3aca4..24e4e59ea6a 100644 --- a/src/backend/optimizer/path/joinrels.c +++ b/src/backend/optimizer/path/joinrels.c @@ -953,7 +953,7 @@ is_dummy_rel(RelOptInfo *rel) * dummy. * * Also, when called during GEQO join planning, we are in a short-lived - * memory context. We must make sure that the dummy path attached to a + * memory context. We must make sure that the dummy path attached to a * baserel survives the GEQO cycle, else the baserel is trashed for future * GEQO cycles. On the other hand, when we are marking a joinrel during GEQO, * we don't want the dummy path to clutter the main planning context. Upshot diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c index ac805114785..e4ccf5ce791 100644 --- a/src/backend/optimizer/plan/createplan.c +++ b/src/backend/optimizer/plan/createplan.c @@ -3383,9 +3383,9 @@ add_sort_column(AttrNumber colIdx, Oid sortOp, Oid coll, bool nulls_first, * opposite nulls direction is redundant. * * We could probably consider sort keys with the same sortop and - * different collations to be redundant too, but for the moment - * treat them as not redundant. This will be needed if we ever - * support collations with different notions of equality. + * different collations to be redundant too, but for the moment treat + * them as not redundant. This will be needed if we ever support + * collations with different notions of equality. */ if (sortColIdx[i] == colIdx && sortOperators[numCols] == sortOp && @@ -3419,7 +3419,7 @@ add_sort_column(AttrNumber colIdx, Oid sortOp, Oid coll, bool nulls_first, * * We must convert the pathkey information into arrays of sort key column * numbers, sort operator OIDs, collation OIDs, and nulls-first flags, - * which is the representation the executor wants. These are returned into + * which is the representation the executor wants. These are returned into * the output parameters *p_numsortkeys etc. * * If the pathkeys include expressions that aren't simple Vars, we will diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index 7b2b40f6298..9aafc8adcc6 100644 --- a/src/backend/optimizer/plan/planner.c +++ b/src/backend/optimizer/plan/planner.c @@ -1034,8 +1034,8 @@ grouping_planner(PlannerInfo *root, double tuple_fraction) if (parse->hasAggs) { /* - * Collect statistics about aggregates for estimating costs. - * Note: we do not attempt to detect duplicate aggregates here; a + * Collect statistics about aggregates for estimating costs. Note: + * we do not attempt to detect duplicate aggregates here; a * somewhat-overestimated cost is okay for our present purposes. */ count_agg_clauses(root, (Node *) tlist, &agg_costs); diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c index fcff015cdff..f82ab27b9aa 100644 --- a/src/backend/optimizer/prep/prepunion.c +++ b/src/backend/optimizer/prep/prepunion.c @@ -933,10 +933,10 @@ generate_setop_tlist(List *colTypes, List *colCollations, } /* - * Ensure the tlist entry's exposed collation matches the set-op. - * This is necessary because plan_set_operations() reports the result + * Ensure the tlist entry's exposed collation matches the set-op. This + * is necessary because plan_set_operations() reports the result * ordering as a list of SortGroupClauses, which don't carry collation - * themselves but just refer to tlist entries. If we don't show the + * themselves but just refer to tlist entries. If we don't show the * right collation then planner.c might do the wrong thing in * higher-level queries. * diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c index 8b0d8623db6..2914c398186 100644 --- a/src/backend/optimizer/util/clauses.c +++ b/src/backend/optimizer/util/clauses.c @@ -86,7 +86,7 @@ typedef struct static bool contain_agg_clause_walker(Node *node, void *context); static bool pull_agg_clause_walker(Node *node, List **context); static bool count_agg_clauses_walker(Node *node, - count_agg_clauses_context *context); + count_agg_clauses_context *context); static bool find_window_functions_walker(Node *node, WindowFuncLists *lists); static bool expression_returns_set_rows_walker(Node *node, double *count); static bool contain_subplans_walker(Node *node, void *context); @@ -2884,9 +2884,9 @@ eval_const_expressions_mutator(Node *node, /* * We can remove null constants from the list. For a non-null * constant, if it has not been preceded by any other - * non-null-constant expressions then it is the result. - * Otherwise, it's the next argument, but we can drop following - * arguments since they will never be reached. + * non-null-constant expressions then it is the result. Otherwise, + * it's the next argument, but we can drop following arguments + * since they will never be reached. */ if (IsA(e, Const)) { diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c index 4867685c7f9..e4a4e3a5e48 100644 --- a/src/backend/parser/analyze.c +++ b/src/backend/parser/analyze.c @@ -575,7 +575,7 @@ transformInsertStmt(ParseState *pstate, InsertStmt *stmt) * We must assign collations now because assign_query_collations * doesn't process rangetable entries. We just assign all the * collations independently in each row, and don't worry about - * whether they are consistent vertically. The outer INSERT query + * whether they are consistent vertically. The outer INSERT query * isn't going to care about the collations of the VALUES columns, * so it's not worth the effort to identify a common collation for * each one here. (But note this does have one user-visible @@ -1100,16 +1100,16 @@ transformValuesClause(ParseState *pstate, SelectStmt *stmt) * doesn't process rangetable entries, and (2) we need to label the VALUES * RTE with column collations for use in the outer query. We don't * consider conflict of implicit collations to be an error here; instead - * the column will just show InvalidOid as its collation, and you'll get - * a failure later if that results in failure to resolve a collation. + * the column will just show InvalidOid as its collation, and you'll get a + * failure later if that results in failure to resolve a collation. * * Note we modify the per-column expression lists in-place. */ collations = NIL; for (i = 0; i < sublist_length; i++) { - Oid coltype; - Oid colcoll; + Oid coltype; + Oid colcoll; coltype = select_common_type(pstate, colexprs[i], "VALUES", NULL); @@ -1210,7 +1210,7 @@ transformValuesClause(ParseState *pstate, SelectStmt *stmt) (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("VALUES must not contain table references"), parser_errposition(pstate, - locate_var_of_level((Node *) exprsLists, 0)))); + locate_var_of_level((Node *) exprsLists, 0)))); /* * Another thing we can't currently support is NEW/OLD references in rules @@ -1225,7 +1225,7 @@ transformValuesClause(ParseState *pstate, SelectStmt *stmt) errmsg("VALUES must not contain OLD or NEW references"), errhint("Use SELECT ... UNION ALL ... instead."), parser_errposition(pstate, - locate_var_of_level((Node *) exprsLists, 0)))); + locate_var_of_level((Node *) exprsLists, 0)))); qry->rtable = pstate->p_rtable; qry->jointree = makeFromExpr(pstate->p_joinlist, NULL); @@ -1237,13 +1237,13 @@ transformValuesClause(ParseState *pstate, SelectStmt *stmt) (errcode(ERRCODE_GROUPING_ERROR), errmsg("cannot use aggregate function in VALUES"), parser_errposition(pstate, - locate_agg_of_level((Node *) exprsLists, 0)))); + locate_agg_of_level((Node *) exprsLists, 0)))); if (pstate->p_hasWindowFuncs) ereport(ERROR, (errcode(ERRCODE_WINDOWING_ERROR), errmsg("cannot use window function in VALUES"), parser_errposition(pstate, - locate_windowfunc((Node *) exprsLists)))); + locate_windowfunc((Node *) exprsLists)))); assign_query_collations(pstate, qry); diff --git a/src/backend/parser/parse_coerce.c b/src/backend/parser/parse_coerce.c index 3c5be6bc888..f26c69abddd 100644 --- a/src/backend/parser/parse_coerce.c +++ b/src/backend/parser/parse_coerce.c @@ -167,7 +167,7 @@ coerce_type(ParseState *pstate, Node *node, * * These cases are unlike the ones above because the exposed type of * the argument must be an actual array or enum type. In particular - * the argument must *not* be an UNKNOWN constant. If it is, we just + * the argument must *not* be an UNKNOWN constant. If it is, we just * fall through; below, we'll call anyarray_in or anyenum_in, which * will produce an error. Also, if what we have is a domain over * array or enum, we have to relabel it to its base type. @@ -1290,7 +1290,7 @@ coerce_to_common_type(ParseState *pstate, Node *node, * * Domains over arrays match ANYARRAY, and are immediately flattened to their * base type. (Thus, for example, we will consider it a match if one ANYARRAY - * argument is a domain over int4[] while another one is just int4[].) Also + * argument is a domain over int4[] while another one is just int4[].) Also * notice that such a domain does *not* match ANYNONARRAY. * * If we have UNKNOWN input (ie, an untyped literal) for any polymorphic @@ -1444,7 +1444,7 @@ check_generic_type_consistency(Oid *actual_arg_types, * is an extra restriction if not.) * * Domains over arrays match ANYARRAY arguments, and are immediately flattened - * to their base type. (In particular, if the return type is also ANYARRAY, + * to their base type. (In particular, if the return type is also ANYARRAY, * we'll set it to the base type not the domain type.) * * When allow_poly is false, we are not expecting any of the actual_arg_types diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c index 5588cfac0bd..efb8fddbc39 100644 --- a/src/backend/parser/parse_utilcmd.c +++ b/src/backend/parser/parse_utilcmd.c @@ -157,7 +157,7 @@ transformCreateStmt(CreateStmt *stmt, const char *queryString) stmt = (CreateStmt *) copyObject(stmt); /* - * Look up the creation namespace. This also checks permissions on the + * Look up the creation namespace. This also checks permissions on the * target namespace, so that we throw any permissions error as early as * possible. */ @@ -169,7 +169,7 @@ transformCreateStmt(CreateStmt *stmt, const char *queryString) */ if (stmt->if_not_exists) { - Oid existing_relid; + Oid existing_relid; existing_relid = get_relname_relid(stmt->relation->relname, namespaceid); @@ -178,7 +178,7 @@ transformCreateStmt(CreateStmt *stmt, const char *queryString) ereport(NOTICE, (errcode(ERRCODE_DUPLICATE_TABLE), errmsg("relation \"%s\" already exists, skipping", - stmt->relation->relname))); + stmt->relation->relname))); return NIL; } } @@ -2544,8 +2544,8 @@ transformColumnType(CreateStmtContext *cxt, ColumnDef *column) Form_pg_type typtup = (Form_pg_type) GETSTRUCT(ctype); LookupCollation(cxt->pstate, - column->collClause->collname, - column->collClause->location); + column->collClause->collname, + column->collClause->location); /* Complain if COLLATE is applied to an uncollatable type */ if (!OidIsValid(typtup->typcollation)) ereport(ERROR, diff --git a/src/backend/port/sysv_sema.c b/src/backend/port/sysv_sema.c index c64f5114c27..2bc4b496116 100644 --- a/src/backend/port/sysv_sema.c +++ b/src/backend/port/sysv_sema.c @@ -121,7 +121,7 @@ InternalIpcSemaphoreCreate(IpcSemaphoreKey semKey, int numSems) "semaphore sets (SEMMNI), or the system wide maximum number of " "semaphores (SEMMNS), would be exceeded. You need to raise the " "respective kernel parameter. Alternatively, reduce PostgreSQL's " - "consumption of semaphores by reducing its max_connections parameter.\n" + "consumption of semaphores by reducing its max_connections parameter.\n" "The PostgreSQL documentation contains more information about " "configuring your system for PostgreSQL.") : 0)); } diff --git a/src/backend/port/win32/crashdump.c b/src/backend/port/win32/crashdump.c index 89509990c52..119dd076cae 100644 --- a/src/backend/port/win32/crashdump.c +++ b/src/backend/port/win32/crashdump.c @@ -135,7 +135,7 @@ crashDumpHandler(struct _EXCEPTION_POINTERS * pExceptionInfo) systemTicks = GetTickCount(); snprintf(dumpPath, _MAX_PATH, - "crashdumps\\postgres-pid%0i-%0i.mdmp", + "crashdumps\\postgres-pid%0i-%0i.mdmp", (int) selfPid, (int) systemTicks); dumpPath[_MAX_PATH - 1] = '\0'; diff --git a/src/backend/port/win32/socket.c b/src/backend/port/win32/socket.c index e2ae0f8e4f5..c918da981b2 100644 --- a/src/backend/port/win32/socket.c +++ b/src/backend/port/win32/socket.c @@ -373,7 +373,7 @@ pgwin32_recv(SOCKET s, char *buf, int len, int f) * The second argument to send() is defined by SUS to be a "const void *" * and so we use the same signature here to keep compilers happy when * handling callers. - * + * * But the buf member of a WSABUF struct is defined as "char *", so we cast * the second argument to that here when assigning it, also to keep compilers * happy. diff --git a/src/backend/port/win32_latch.c b/src/backend/port/win32_latch.c index 3509302aaae..4bcf7b7a8f3 100644 --- a/src/backend/port/win32_latch.c +++ b/src/backend/port/win32_latch.c @@ -94,7 +94,7 @@ WaitLatchOrSocket(volatile Latch *latch, SOCKET sock, bool forRead, DWORD rc; HANDLE events[3]; HANDLE latchevent; - HANDLE sockevent = WSA_INVALID_EVENT; /* silence compiler */ + HANDLE sockevent = WSA_INVALID_EVENT; /* silence compiler */ int numevents; int result = 0; diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index 1e2aa9f0925..1f0d4e63fb0 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -1486,10 +1486,10 @@ ServerLoop(void) WalWriterPID = StartWalWriter(); /* - * If we have lost the autovacuum launcher, try to start a new one. - * We don't want autovacuum to run in binary upgrade mode because - * autovacuum might update relfrozenxid for empty tables before - * the physical files are put in place. + * If we have lost the autovacuum launcher, try to start a new one. We + * don't want autovacuum to run in binary upgrade mode because + * autovacuum might update relfrozenxid for empty tables before the + * physical files are put in place. */ if (!IsBinaryUpgrade && AutoVacPID == 0 && (AutoVacuumingActive() || start_autovac_launcher) && diff --git a/src/backend/regex/regc_pg_locale.c b/src/backend/regex/regc_pg_locale.c index 27d1193d706..bc5ad3157a9 100644 --- a/src/backend/regex/regc_pg_locale.c +++ b/src/backend/regex/regc_pg_locale.c @@ -23,7 +23,7 @@ * several implementation strategies depending on the situation: * * 1. In C/POSIX collations, we use hard-wired code. We can't depend on - * the <ctype.h> functions since those will obey LC_CTYPE. Note that these + * the <ctype.h> functions since those will obey LC_CTYPE. Note that these * collations don't give a fig about multibyte characters. * * 2. In the "default" collation (which is supposed to obey LC_CTYPE): @@ -35,10 +35,10 @@ * * 2b. In all other encodings, or on machines that lack <wctype.h>, we use * the <ctype.h> functions for pg_wchar values up to 255, and punt for values - * above that. This is only 100% correct in single-byte encodings such as - * LATINn. However, non-Unicode multibyte encodings are mostly Far Eastern + * above that. This is only 100% correct in single-byte encodings such as + * LATINn. However, non-Unicode multibyte encodings are mostly Far Eastern * character sets for which the properties being tested here aren't very - * relevant for higher code values anyway. The difficulty with using the + * relevant for higher code values anyway. The difficulty with using the * <wctype.h> functions with non-Unicode multibyte encodings is that we can * have no certainty that the platform's wchar_t representation matches * what we do in pg_wchar conversions. @@ -87,134 +87,134 @@ static pg_locale_t pg_regex_locale; #define PG_ISSPACE 0x80 static const unsigned char pg_char_properties[128] = { - /* NUL */ 0, - /* ^A */ 0, - /* ^B */ 0, - /* ^C */ 0, - /* ^D */ 0, - /* ^E */ 0, - /* ^F */ 0, - /* ^G */ 0, - /* ^H */ 0, - /* ^I */ PG_ISSPACE, - /* ^J */ PG_ISSPACE, - /* ^K */ PG_ISSPACE, - /* ^L */ PG_ISSPACE, - /* ^M */ PG_ISSPACE, - /* ^N */ 0, - /* ^O */ 0, - /* ^P */ 0, - /* ^Q */ 0, - /* ^R */ 0, - /* ^S */ 0, - /* ^T */ 0, - /* ^U */ 0, - /* ^V */ 0, - /* ^W */ 0, - /* ^X */ 0, - /* ^Y */ 0, - /* ^Z */ 0, - /* ^[ */ 0, - /* ^\ */ 0, - /* ^] */ 0, - /* ^^ */ 0, - /* ^_ */ 0, - /* */ PG_ISPRINT | PG_ISSPACE, - /* ! */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* " */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* # */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* $ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* % */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* & */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* ' */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* ( */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* ) */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* * */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* + */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* , */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* - */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* . */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* / */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* 0 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, - /* 1 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, - /* 2 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, - /* 3 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, - /* 4 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, - /* 5 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, - /* 6 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, - /* 7 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, - /* 8 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, - /* 9 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, - /* : */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* ; */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* < */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* = */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* > */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* ? */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* @ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* A */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* B */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* C */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* D */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* E */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* F */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* G */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* H */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* I */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* J */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* K */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* L */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* M */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* N */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* O */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* P */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* Q */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* R */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* S */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* T */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* U */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* V */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* W */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* X */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* Y */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* Z */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, - /* [ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* \ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* ] */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* ^ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* _ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* ` */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* a */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* b */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* c */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* d */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* e */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* f */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* g */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* h */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* i */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* j */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* k */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* l */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* m */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* n */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* o */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* p */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* q */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* r */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* s */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* t */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* u */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* v */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* w */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* x */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* y */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* z */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, - /* { */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* | */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* } */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* ~ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, - /* DEL */ 0 + /* NUL */ 0, + /* ^A */ 0, + /* ^B */ 0, + /* ^C */ 0, + /* ^D */ 0, + /* ^E */ 0, + /* ^F */ 0, + /* ^G */ 0, + /* ^H */ 0, + /* ^I */ PG_ISSPACE, + /* ^J */ PG_ISSPACE, + /* ^K */ PG_ISSPACE, + /* ^L */ PG_ISSPACE, + /* ^M */ PG_ISSPACE, + /* ^N */ 0, + /* ^O */ 0, + /* ^P */ 0, + /* ^Q */ 0, + /* ^R */ 0, + /* ^S */ 0, + /* ^T */ 0, + /* ^U */ 0, + /* ^V */ 0, + /* ^W */ 0, + /* ^X */ 0, + /* ^Y */ 0, + /* ^Z */ 0, + /* ^[ */ 0, + /* ^\ */ 0, + /* ^] */ 0, + /* ^^ */ 0, + /* ^_ */ 0, + /* */ PG_ISPRINT | PG_ISSPACE, + /* ! */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* " */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* # */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* $ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* % */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* & */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* ' */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* ( */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* ) */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* * */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* + */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* , */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* - */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* . */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* / */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* 0 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, + /* 1 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, + /* 2 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, + /* 3 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, + /* 4 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, + /* 5 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, + /* 6 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, + /* 7 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, + /* 8 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, + /* 9 */ PG_ISDIGIT | PG_ISGRAPH | PG_ISPRINT, + /* : */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* ; */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* < */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* = */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* > */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* ? */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* @ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* A */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* B */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* C */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* D */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* E */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* F */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* G */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* H */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* I */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* J */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* K */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* L */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* M */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* N */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* O */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* P */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* Q */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* R */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* S */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* T */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* U */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* V */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* W */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* X */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* Y */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* Z */ PG_ISALPHA | PG_ISUPPER | PG_ISGRAPH | PG_ISPRINT, + /* [ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* \ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* ] */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* ^ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* _ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* ` */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* a */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* b */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* c */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* d */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* e */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* f */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* g */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* h */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* i */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* j */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* k */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* l */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* m */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* n */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* o */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* p */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* q */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* r */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* s */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* t */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* u */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* v */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* w */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* x */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* y */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* z */ PG_ISALPHA | PG_ISLOWER | PG_ISGRAPH | PG_ISPRINT, + /* { */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* | */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* } */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* ~ */ PG_ISGRAPH | PG_ISPRINT | PG_ISPUNCT, + /* DEL */ 0 }; @@ -242,8 +242,8 @@ pg_set_regex_collation(Oid collation) { /* * NB: pg_newlocale_from_collation will fail if not HAVE_LOCALE_T; - * the case of pg_regex_locale != 0 but not HAVE_LOCALE_T does - * not have to be considered below. + * the case of pg_regex_locale != 0 but not HAVE_LOCALE_T does not + * have to be considered below. */ pg_regex_locale = pg_newlocale_from_collation(collation); } diff --git a/src/backend/replication/syncrep.c b/src/backend/replication/syncrep.c index 1d4df8a4488..08a40866f07 100644 --- a/src/backend/replication/syncrep.c +++ b/src/backend/replication/syncrep.c @@ -236,8 +236,8 @@ SyncRepWaitForLSN(XLogRecPtr XactCommitLSN) /* * If the postmaster dies, we'll probably never get an - * acknowledgement, because all the wal sender processes will exit. - * So just bail out. + * acknowledgement, because all the wal sender processes will exit. So + * just bail out. */ if (!PostmasterIsAlive(true)) { diff --git a/src/backend/rewrite/rewriteDefine.c b/src/backend/rewrite/rewriteDefine.c index 7b303d9355e..52c55def155 100644 --- a/src/backend/rewrite/rewriteDefine.c +++ b/src/backend/rewrite/rewriteDefine.c @@ -488,13 +488,13 @@ DefineQueryRewrite(char *rulename, if (action != NIL || is_instead) { InsertRule(rulename, - event_type, - event_relid, - event_attno, - is_instead, - event_qual, - action, - replace); + event_type, + event_relid, + event_attno, + is_instead, + event_qual, + action, + replace); /* * Set pg_class 'relhasrules' field TRUE for event relation. If diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c index be9e7a45989..6ef20a5bb53 100644 --- a/src/backend/rewrite/rewriteHandler.c +++ b/src/backend/rewrite/rewriteHandler.c @@ -455,17 +455,17 @@ rewriteRuleAction(Query *parsetree, } /* - * If the original query has any CTEs, copy them into the rule action. - * But we don't need them for a utility action. + * If the original query has any CTEs, copy them into the rule action. But + * we don't need them for a utility action. */ if (parsetree->cteList != NIL && sub_action->commandType != CMD_UTILITY) { ListCell *lc; /* - * Annoying implementation restriction: because CTEs are identified - * by name within a cteList, we can't merge a CTE from the original - * query if it has the same name as any CTE in the rule action. + * Annoying implementation restriction: because CTEs are identified by + * name within a cteList, we can't merge a CTE from the original query + * if it has the same name as any CTE in the rule action. * * This could possibly be fixed by using some sort of internally * generated ID, instead of names, to link CTE RTEs to their CTEs. @@ -2116,15 +2116,15 @@ RewriteQuery(Query *parsetree, List *rewrite_events) /* * If the original query has a CTE list, and we generated more than one - * non-utility result query, we have to fail because we'll have copied - * the CTE list into each result query. That would break the expectation - * of single evaluation of CTEs. This could possibly be fixed by + * non-utility result query, we have to fail because we'll have copied the + * CTE list into each result query. That would break the expectation of + * single evaluation of CTEs. This could possibly be fixed by * restructuring so that a CTE list can be shared across multiple Query * and PlannableStatement nodes. */ if (parsetree->cteList != NIL) { - int qcount = 0; + int qcount = 0; foreach(lc1, rewritten) { diff --git a/src/backend/tsearch/ts_locale.c b/src/backend/tsearch/ts_locale.c index dcaf18b00c2..93b550a1a50 100644 --- a/src/backend/tsearch/ts_locale.c +++ b/src/backend/tsearch/ts_locale.c @@ -29,7 +29,7 @@ t_isdigit(const char *ptr) int clen = pg_mblen(ptr); wchar_t character[2]; Oid collation = DEFAULT_COLLATION_OID; /* TODO */ - pg_locale_t mylocale = 0; /* TODO */ + pg_locale_t mylocale = 0; /* TODO */ if (clen == 1 || lc_ctype_is_c(collation)) return isdigit(TOUCHAR(ptr)); @@ -45,7 +45,7 @@ t_isspace(const char *ptr) int clen = pg_mblen(ptr); wchar_t character[2]; Oid collation = DEFAULT_COLLATION_OID; /* TODO */ - pg_locale_t mylocale = 0; /* TODO */ + pg_locale_t mylocale = 0; /* TODO */ if (clen == 1 || lc_ctype_is_c(collation)) return isspace(TOUCHAR(ptr)); @@ -61,7 +61,7 @@ t_isalpha(const char *ptr) int clen = pg_mblen(ptr); wchar_t character[2]; Oid collation = DEFAULT_COLLATION_OID; /* TODO */ - pg_locale_t mylocale = 0; /* TODO */ + pg_locale_t mylocale = 0; /* TODO */ if (clen == 1 || lc_ctype_is_c(collation)) return isalpha(TOUCHAR(ptr)); @@ -77,7 +77,7 @@ t_isprint(const char *ptr) int clen = pg_mblen(ptr); wchar_t character[2]; Oid collation = DEFAULT_COLLATION_OID; /* TODO */ - pg_locale_t mylocale = 0; /* TODO */ + pg_locale_t mylocale = 0; /* TODO */ if (clen == 1 || lc_ctype_is_c(collation)) return isprint(TOUCHAR(ptr)); @@ -250,7 +250,7 @@ lowerstr_with_len(const char *str, int len) #ifdef USE_WIDE_UPPER_LOWER Oid collation = DEFAULT_COLLATION_OID; /* TODO */ - pg_locale_t mylocale = 0; /* TODO */ + pg_locale_t mylocale = 0; /* TODO */ #endif if (len == 0) diff --git a/src/backend/tsearch/wparser_def.c b/src/backend/tsearch/wparser_def.c index 3176ddc696b..7ba33145889 100644 --- a/src/backend/tsearch/wparser_def.c +++ b/src/backend/tsearch/wparser_def.c @@ -300,7 +300,7 @@ TParserInit(char *str, int len) if (prs->charmaxlen > 1) { Oid collation = DEFAULT_COLLATION_OID; /* TODO */ - pg_locale_t mylocale = 0; /* TODO */ + pg_locale_t mylocale = 0; /* TODO */ prs->usewide = true; if (lc_ctype_is_c(collation)) diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c index 0289dbdf02f..3d320ccdd58 100644 --- a/src/backend/utils/adt/datetime.c +++ b/src/backend/utils/adt/datetime.c @@ -4049,10 +4049,11 @@ EncodeInterval(struct pg_tm * tm, fsec_t fsec, int style, char *str) /* Compatible with postgresql < 8.4 when DateStyle = 'iso' */ case INTSTYLE_POSTGRES: cp = AddPostgresIntPart(cp, year, "year", &is_zero, &is_before); + /* - * Ideally we should spell out "month" like we do for "year" - * and "day". However, for backward compatibility, we can't - * easily fix this. bjm 2011-05-24 + * Ideally we should spell out "month" like we do for "year" and + * "day". However, for backward compatibility, we can't easily + * fix this. bjm 2011-05-24 */ cp = AddPostgresIntPart(cp, mon, "mon", &is_zero, &is_before); cp = AddPostgresIntPart(cp, mday, "day", &is_zero, &is_before); diff --git a/src/backend/utils/adt/pg_locale.c b/src/backend/utils/adt/pg_locale.c index 7c941dd991f..cf663466c35 100644 --- a/src/backend/utils/adt/pg_locale.c +++ b/src/backend/utils/adt/pg_locale.c @@ -564,9 +564,9 @@ strftime_win32(char *dst, size_t dstlen, const wchar_t *format, const struct tm dst[len] = '\0'; if (encoding != PG_UTF8) { - char *convstr = - (char *) pg_do_encoding_conversion((unsigned char *) dst, - len, PG_UTF8, encoding); + char *convstr = + (char *) pg_do_encoding_conversion((unsigned char *) dst, + len, PG_UTF8, encoding); if (dst != convstr) { @@ -1099,19 +1099,19 @@ wchar2char(char *to, const wchar_t *from, size_t tolen, pg_locale_t locale) #ifdef HAVE_WCSTOMBS_L /* Use wcstombs_l for nondefault locales */ result = wcstombs_l(to, from, tolen, locale); -#else /* !HAVE_WCSTOMBS_L */ +#else /* !HAVE_WCSTOMBS_L */ /* We have to temporarily set the locale as current ... ugh */ locale_t save_locale = uselocale(locale); result = wcstombs(to, from, tolen); uselocale(save_locale); -#endif /* HAVE_WCSTOMBS_L */ -#else /* !HAVE_LOCALE_T */ +#endif /* HAVE_WCSTOMBS_L */ +#else /* !HAVE_LOCALE_T */ /* Can't have locale != 0 without HAVE_LOCALE_T */ elog(ERROR, "wcstombs_l is not available"); result = 0; /* keep compiler quiet */ -#endif /* HAVE_LOCALE_T */ +#endif /* HAVE_LOCALE_T */ } return result; @@ -1174,19 +1174,19 @@ char2wchar(wchar_t *to, size_t tolen, const char *from, size_t fromlen, #ifdef HAVE_WCSTOMBS_L /* Use mbstowcs_l for nondefault locales */ result = mbstowcs_l(to, str, tolen, locale); -#else /* !HAVE_WCSTOMBS_L */ +#else /* !HAVE_WCSTOMBS_L */ /* We have to temporarily set the locale as current ... ugh */ locale_t save_locale = uselocale(locale); result = mbstowcs(to, str, tolen); uselocale(save_locale); -#endif /* HAVE_WCSTOMBS_L */ -#else /* !HAVE_LOCALE_T */ +#endif /* HAVE_WCSTOMBS_L */ +#else /* !HAVE_LOCALE_T */ /* Can't have locale != 0 without HAVE_LOCALE_T */ elog(ERROR, "mbstowcs_l is not available"); - result = 0; /* keep compiler quiet */ -#endif /* HAVE_LOCALE_T */ + result = 0; /* keep compiler quiet */ +#endif /* HAVE_LOCALE_T */ } pfree(str); @@ -1213,4 +1213,4 @@ char2wchar(wchar_t *to, size_t tolen, const char *from, size_t fromlen, return result; } -#endif /* USE_WIDE_UPPER_LOWER */ +#endif /* USE_WIDE_UPPER_LOWER */ diff --git a/src/backend/utils/adt/ri_triggers.c b/src/backend/utils/adt/ri_triggers.c index fde01a0f571..fa7b8e6e81a 100644 --- a/src/backend/utils/adt/ri_triggers.c +++ b/src/backend/utils/adt/ri_triggers.c @@ -83,7 +83,7 @@ #define RIAttName(rel, attnum) NameStr(*attnumAttName(rel, attnum)) #define RIAttType(rel, attnum) attnumTypeId(rel, attnum) -#define RIAttCollation(rel, attnum) attnumCollationId(rel, attnum) +#define RIAttCollation(rel, attnum) attnumCollationId(rel, attnum) #define RI_TRIGTYPE_INSERT 1 #define RI_TRIGTYPE_UPDATE 2 @@ -3024,8 +3024,8 @@ ri_GenerateQualCollation(StringInfo buf, Oid collation) collname = NameStr(colltup->collname); /* - * We qualify the name always, for simplicity and to ensure the query - * is not search-path-dependent. + * We qualify the name always, for simplicity and to ensure the query is + * not search-path-dependent. */ quoteOneName(onename, get_namespace_name(colltup->collnamespace)); appendStringInfo(buf, " COLLATE %s", onename); @@ -3964,8 +3964,8 @@ ri_AttributesEqual(Oid eq_opr, Oid typeid, } /* - * Apply the comparison operator. We assume it doesn't - * care about collations. + * Apply the comparison operator. We assume it doesn't care about + * collations. */ return DatumGetBool(FunctionCall2(&entry->eq_opr_finfo, oldvalue, newvalue)); diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c index a67f7986a14..06cf6fa4f79 100644 --- a/src/backend/utils/adt/ruleutils.c +++ b/src/backend/utils/adt/ruleutils.c @@ -5193,8 +5193,8 @@ get_rule_expr(Node *node, deparse_context *context, if (caseexpr->arg) { /* - * The parser should have produced WHEN clauses of - * the form "CaseTestExpr = RHS", possibly with an + * The parser should have produced WHEN clauses of the + * form "CaseTestExpr = RHS", possibly with an * implicit coercion inserted above the CaseTestExpr. * For accurate decompilation of rules it's essential * that we show just the RHS. However in an diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c index fa8cecafcbe..00ba19ec6c9 100644 --- a/src/backend/utils/adt/selfuncs.c +++ b/src/backend/utils/adt/selfuncs.c @@ -291,12 +291,12 @@ var_eq_const(VariableStatData *vardata, Oid operator, /* be careful to apply operator right way 'round */ if (varonleft) match = DatumGetBool(FunctionCall2Coll(&eqproc, - DEFAULT_COLLATION_OID, + DEFAULT_COLLATION_OID, values[i], constval)); else match = DatumGetBool(FunctionCall2Coll(&eqproc, - DEFAULT_COLLATION_OID, + DEFAULT_COLLATION_OID, constval, values[i])); if (match) @@ -1185,7 +1185,7 @@ patternsel(PG_FUNCTION_ARGS, Pattern_Type ptype, bool negate) } /* - * Divide pattern into fixed prefix and remainder. XXX we have to assume + * Divide pattern into fixed prefix and remainder. XXX we have to assume * default collation here, because we don't have access to the actual * input collation for the operator. FIXME ... */ @@ -2403,9 +2403,9 @@ eqjoinsel_semi(Oid operator, * before doing the division. * * Crude as the above is, it's completely useless if we don't have - * reliable ndistinct values for both sides. Hence, if either nd1 - * or nd2 is default, punt and assume half of the uncertain rows - * have join partners. + * reliable ndistinct values for both sides. Hence, if either nd1 or + * nd2 is default, punt and assume half of the uncertain rows have + * join partners. */ if (nd1 != DEFAULT_NUM_DISTINCT && nd2 != DEFAULT_NUM_DISTINCT) { @@ -4779,7 +4779,7 @@ get_actual_variable_range(PlannerInfo *root, VariableStatData *vardata, * Check whether char is a letter (and, hence, subject to case-folding) * * In multibyte character sets, we can't use isalpha, and it does not seem - * worth trying to convert to wchar_t to use iswalpha. Instead, just assume + * worth trying to convert to wchar_t to use iswalpha. Instead, just assume * any multibyte char is potentially case-varying. */ static int @@ -4823,7 +4823,7 @@ like_fixed_prefix(Const *patt_const, bool case_insensitive, Oid collation, int pos, match_pos; bool is_multibyte = (pg_database_encoding_max_length() > 1); - pg_locale_t locale = 0; + pg_locale_t locale = 0; bool locale_is_c = false; /* the right-hand const is type text or bytea */ @@ -4834,7 +4834,7 @@ like_fixed_prefix(Const *patt_const, bool case_insensitive, Oid collation, if (typeid == BYTEAOID) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("case insensitive matching not supported on type bytea"))); + errmsg("case insensitive matching not supported on type bytea"))); /* If case-insensitive, we need locale info */ if (lc_ctype_is_c(collation)) @@ -4891,7 +4891,7 @@ like_fixed_prefix(Const *patt_const, bool case_insensitive, Oid collation, /* Stop if case-varying character (it's sort of a wildcard) */ if (case_insensitive && - pattern_char_isalpha(patt[pos], is_multibyte, locale, locale_is_c)) + pattern_char_isalpha(patt[pos], is_multibyte, locale, locale_is_c)) break; match[match_pos++] = patt[pos]; @@ -4938,7 +4938,7 @@ regex_fixed_prefix(Const *patt_const, bool case_insensitive, Oid collation, char *rest; Oid typeid = patt_const->consttype; bool is_multibyte = (pg_database_encoding_max_length() > 1); - pg_locale_t locale = 0; + pg_locale_t locale = 0; bool locale_is_c = false; /* @@ -5050,7 +5050,7 @@ regex_fixed_prefix(Const *patt_const, bool case_insensitive, Oid collation, /* Stop if case-varying character (it's sort of a wildcard) */ if (case_insensitive && - pattern_char_isalpha(patt[pos], is_multibyte, locale, locale_is_c)) + pattern_char_isalpha(patt[pos], is_multibyte, locale, locale_is_c)) break; /* diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c index 6005d685764..9acbc2d4e51 100644 --- a/src/backend/utils/adt/varlena.c +++ b/src/backend/utils/adt/varlena.c @@ -3829,7 +3829,7 @@ text_format(PG_FUNCTION_ARGS) if (*cp < '0' || *cp > '9') { ++arg; - if (arg <= 0) /* overflow? */ + if (arg <= 0) /* overflow? */ { /* * Should not happen, as you can't pass billions of arguments @@ -3848,9 +3848,9 @@ text_format(PG_FUNCTION_ARGS) arg = 0; do { - int newarg = arg * 10 + (*cp - '0'); + int newarg = arg * 10 + (*cp - '0'); - if (newarg / 10 != arg) /* overflow? */ + if (newarg / 10 != arg) /* overflow? */ ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("argument number is out of range"))); diff --git a/src/backend/utils/cache/typcache.c b/src/backend/utils/cache/typcache.c index 14d9cf7a445..b16ed6a2089 100644 --- a/src/backend/utils/cache/typcache.c +++ b/src/backend/utils/cache/typcache.c @@ -11,7 +11,7 @@ * * Several seemingly-odd choices have been made to support use of the type * cache by generic array and record handling routines, such as array_eq(), - * record_cmp(), and hash_array(). Because those routines are used as index + * record_cmp(), and hash_array(). Because those routines are used as index * support operations, they cannot leak memory. To allow them to execute * efficiently, all information that they would like to re-use across calls * is kept in the type cache. @@ -276,7 +276,7 @@ lookup_type_cache(Oid type_id, int flags) if ((flags & (TYPECACHE_EQ_OPR | TYPECACHE_EQ_OPR_FINFO)) && typentry->eq_opr == InvalidOid) { - Oid eq_opr = InvalidOid; + Oid eq_opr = InvalidOid; if (typentry->btree_opf != InvalidOid) eq_opr = get_opfamily_member(typentry->btree_opf, @@ -291,10 +291,10 @@ lookup_type_cache(Oid type_id, int flags) HTEqualStrategyNumber); /* - * If the proposed equality operator is array_eq or record_eq, - * check to see if the element type or column types support equality. - * If not, array_eq or record_eq would fail at runtime, so we don't - * want to report that the type has equality. + * If the proposed equality operator is array_eq or record_eq, check + * to see if the element type or column types support equality. If + * not, array_eq or record_eq would fail at runtime, so we don't want + * to report that the type has equality. */ if (eq_opr == ARRAY_EQ_OP && !array_element_has_equality(typentry)) @@ -315,7 +315,7 @@ lookup_type_cache(Oid type_id, int flags) } if ((flags & TYPECACHE_LT_OPR) && typentry->lt_opr == InvalidOid) { - Oid lt_opr = InvalidOid; + Oid lt_opr = InvalidOid; if (typentry->btree_opf != InvalidOid) lt_opr = get_opfamily_member(typentry->btree_opf, @@ -335,7 +335,7 @@ lookup_type_cache(Oid type_id, int flags) } if ((flags & TYPECACHE_GT_OPR) && typentry->gt_opr == InvalidOid) { - Oid gt_opr = InvalidOid; + Oid gt_opr = InvalidOid; if (typentry->btree_opf != InvalidOid) gt_opr = get_opfamily_member(typentry->btree_opf, @@ -356,7 +356,7 @@ lookup_type_cache(Oid type_id, int flags) if ((flags & (TYPECACHE_CMP_PROC | TYPECACHE_CMP_PROC_FINFO)) && typentry->cmp_proc == InvalidOid) { - Oid cmp_proc = InvalidOid; + Oid cmp_proc = InvalidOid; if (typentry->btree_opf != InvalidOid) cmp_proc = get_opfamily_proc(typentry->btree_opf, @@ -377,7 +377,7 @@ lookup_type_cache(Oid type_id, int flags) if ((flags & (TYPECACHE_HASH_PROC | TYPECACHE_HASH_PROC_FINFO)) && typentry->hash_proc == InvalidOid) { - Oid hash_proc = InvalidOid; + Oid hash_proc = InvalidOid; /* * We insist that the eq_opr, if one has been determined, match the @@ -460,7 +460,7 @@ load_typcache_tupdesc(TypeCacheEntry *typentry) { Relation rel; - if (!OidIsValid(typentry->typrelid)) /* should not happen */ + if (!OidIsValid(typentry->typrelid)) /* should not happen */ elog(ERROR, "invalid typrelid for composite type %u", typentry->type_id); rel = relation_open(typentry->typrelid, AccessShareLock); @@ -468,9 +468,9 @@ load_typcache_tupdesc(TypeCacheEntry *typentry) /* * Link to the tupdesc and increment its refcount (we assert it's a - * refcounted descriptor). We don't use IncrTupleDescRefCount() for - * this, because the reference mustn't be entered in the current - * resource owner; it can outlive the current query. + * refcounted descriptor). We don't use IncrTupleDescRefCount() for this, + * because the reference mustn't be entered in the current resource owner; + * it can outlive the current query. */ typentry->tupDesc = RelationGetDescr(rel); @@ -520,7 +520,7 @@ array_element_has_hashing(TypeCacheEntry *typentry) static void cache_array_element_properties(TypeCacheEntry *typentry) { - Oid elem_type = get_base_element_type(typentry->type_id); + Oid elem_type = get_base_element_type(typentry->type_id); if (OidIsValid(elem_type)) { @@ -571,7 +571,7 @@ cache_record_field_properties(TypeCacheEntry *typentry) { TupleDesc tupdesc; int newflags; - int i; + int i; /* Fetch composite type's tupdesc if we don't have it already */ if (typentry->tupDesc == NULL) diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c index ffa19d5a2d2..21fb5ade7ac 100644 --- a/src/backend/utils/fmgr/fmgr.c +++ b/src/backend/utils/fmgr/fmgr.c @@ -1053,7 +1053,7 @@ DirectFunctionCall2Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2) Datum DirectFunctionCall3Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, - Datum arg3) + Datum arg3) { FunctionCallInfoData fcinfo; Datum result; @@ -1078,7 +1078,7 @@ DirectFunctionCall3Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, Datum DirectFunctionCall4Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4) + Datum arg3, Datum arg4) { FunctionCallInfoData fcinfo; Datum result; @@ -1105,7 +1105,7 @@ DirectFunctionCall4Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, Datum DirectFunctionCall5Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5) + Datum arg3, Datum arg4, Datum arg5) { FunctionCallInfoData fcinfo; Datum result; @@ -1134,8 +1134,8 @@ DirectFunctionCall5Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, Datum DirectFunctionCall6Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5, - Datum arg6) + Datum arg3, Datum arg4, Datum arg5, + Datum arg6) { FunctionCallInfoData fcinfo; Datum result; @@ -1166,8 +1166,8 @@ DirectFunctionCall6Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, Datum DirectFunctionCall7Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5, - Datum arg6, Datum arg7) + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7) { FunctionCallInfoData fcinfo; Datum result; @@ -1200,8 +1200,8 @@ DirectFunctionCall7Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, Datum DirectFunctionCall8Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5, - Datum arg6, Datum arg7, Datum arg8) + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8) { FunctionCallInfoData fcinfo; Datum result; @@ -1236,9 +1236,9 @@ DirectFunctionCall8Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, Datum DirectFunctionCall9Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5, - Datum arg6, Datum arg7, Datum arg8, - Datum arg9) + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8, + Datum arg9) { FunctionCallInfoData fcinfo; Datum result; @@ -1327,7 +1327,7 @@ FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2) Datum FunctionCall3Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, - Datum arg3) + Datum arg3) { FunctionCallInfoData fcinfo; Datum result; @@ -1352,7 +1352,7 @@ FunctionCall3Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum FunctionCall4Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4) + Datum arg3, Datum arg4) { FunctionCallInfoData fcinfo; Datum result; @@ -1379,7 +1379,7 @@ FunctionCall4Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum FunctionCall5Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5) + Datum arg3, Datum arg4, Datum arg5) { FunctionCallInfoData fcinfo; Datum result; @@ -1408,8 +1408,8 @@ FunctionCall5Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum FunctionCall6Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5, - Datum arg6) + Datum arg3, Datum arg4, Datum arg5, + Datum arg6) { FunctionCallInfoData fcinfo; Datum result; @@ -1440,8 +1440,8 @@ FunctionCall6Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum FunctionCall7Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5, - Datum arg6, Datum arg7) + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7) { FunctionCallInfoData fcinfo; Datum result; @@ -1474,8 +1474,8 @@ FunctionCall7Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum FunctionCall8Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5, - Datum arg6, Datum arg7, Datum arg8) + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8) { FunctionCallInfoData fcinfo; Datum result; @@ -1510,9 +1510,9 @@ FunctionCall8Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum FunctionCall9Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5, - Datum arg6, Datum arg7, Datum arg8, - Datum arg9) + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8, + Datum arg9) { FunctionCallInfoData fcinfo; Datum result; @@ -1625,7 +1625,7 @@ OidFunctionCall2Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2) Datum OidFunctionCall3Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, - Datum arg3) + Datum arg3) { FmgrInfo flinfo; FunctionCallInfoData fcinfo; @@ -1653,7 +1653,7 @@ OidFunctionCall3Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, Datum OidFunctionCall4Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4) + Datum arg3, Datum arg4) { FmgrInfo flinfo; FunctionCallInfoData fcinfo; @@ -1683,7 +1683,7 @@ OidFunctionCall4Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, Datum OidFunctionCall5Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5) + Datum arg3, Datum arg4, Datum arg5) { FmgrInfo flinfo; FunctionCallInfoData fcinfo; @@ -1715,8 +1715,8 @@ OidFunctionCall5Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, Datum OidFunctionCall6Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5, - Datum arg6) + Datum arg3, Datum arg4, Datum arg5, + Datum arg6) { FmgrInfo flinfo; FunctionCallInfoData fcinfo; @@ -1750,8 +1750,8 @@ OidFunctionCall6Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, Datum OidFunctionCall7Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5, - Datum arg6, Datum arg7) + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7) { FmgrInfo flinfo; FunctionCallInfoData fcinfo; @@ -1787,8 +1787,8 @@ OidFunctionCall7Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, Datum OidFunctionCall8Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5, - Datum arg6, Datum arg7, Datum arg8) + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8) { FmgrInfo flinfo; FunctionCallInfoData fcinfo; @@ -1826,9 +1826,9 @@ OidFunctionCall8Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, Datum OidFunctionCall9Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, - Datum arg3, Datum arg4, Datum arg5, - Datum arg6, Datum arg7, Datum arg8, - Datum arg9) + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8, + Datum arg9) { FmgrInfo flinfo; FunctionCallInfoData fcinfo; diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c index 3ac3254afb4..8347f52ca8d 100644 --- a/src/backend/utils/init/postinit.c +++ b/src/backend/utils/init/postinit.c @@ -630,9 +630,9 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username, */ if (IsBinaryUpgrade && !am_superuser) { - ereport(FATAL, - (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), - errmsg("must be superuser to connect in binary upgrade mode"))); + ereport(FATAL, + (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), + errmsg("must be superuser to connect in binary upgrade mode"))); } /* |