diff options
Diffstat (limited to 'src/backend')
229 files changed, 3304 insertions, 3203 deletions
diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c index 6d608fed895..175e6ea2f2e 100644 --- a/src/backend/access/common/heaptuple.c +++ b/src/backend/access/common/heaptuple.c @@ -350,7 +350,7 @@ nocachegetattr(HeapTuple tuple, * * check to see if any preceding bits are null... */ - int byte = attnum >> 3; + int byte = attnum >> 3; int finalbit = attnum & 0x07; /* check for nulls "before" final bit of last byte */ diff --git a/src/backend/access/common/indextuple.c b/src/backend/access/common/indextuple.c index 9ea87360f91..85c43199aa7 100644 --- a/src/backend/access/common/indextuple.c +++ b/src/backend/access/common/indextuple.c @@ -237,7 +237,7 @@ nocache_index_getattr(IndexTuple tup, * Now check to see if any preceding bits are null... */ { - int byte = attnum >> 3; + int byte = attnum >> 3; int finalbit = attnum & 0x07; /* check for nulls "before" final bit of last byte */ diff --git a/src/backend/access/gin/ginarrayproc.c b/src/backend/access/gin/ginarrayproc.c index ce9abae6aa4..2de58604eee 100644 --- a/src/backend/access/gin/ginarrayproc.c +++ b/src/backend/access/gin/ginarrayproc.c @@ -82,7 +82,8 @@ ginqueryarrayextract(PG_FUNCTION_ARGS) ArrayType *array = PG_GETARG_ARRAYTYPE_P_COPY(0); int32 *nkeys = (int32 *) PG_GETARG_POINTER(1); StrategyNumber strategy = PG_GETARG_UINT16(2); - /* bool **pmatch = (bool **) PG_GETARG_POINTER(3); */ + + /* bool **pmatch = (bool **) PG_GETARG_POINTER(3); */ /* Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4); */ bool **nullFlags = (bool **) PG_GETARG_POINTER(5); int32 *searchMode = (int32 *) PG_GETARG_POINTER(6); @@ -112,7 +113,7 @@ ginqueryarrayextract(PG_FUNCTION_ARGS) case GinContainsStrategy: if (nelems > 0) *searchMode = GIN_SEARCH_MODE_DEFAULT; - else /* everything contains the empty set */ + else /* everything contains the empty set */ *searchMode = GIN_SEARCH_MODE_ALL; break; case GinContainedStrategy: @@ -142,10 +143,13 @@ ginarrayconsistent(PG_FUNCTION_ARGS) { bool *check = (bool *) PG_GETARG_POINTER(0); StrategyNumber strategy = PG_GETARG_UINT16(1); + /* ArrayType *query = PG_GETARG_ARRAYTYPE_P(2); */ int32 nkeys = PG_GETARG_INT32(3); + /* Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4); */ bool *recheck = (bool *) PG_GETARG_POINTER(5); + /* Datum *queryKeys = (Datum *) PG_GETARG_POINTER(6); */ bool *nullFlags = (bool *) PG_GETARG_POINTER(7); bool res; @@ -190,10 +194,11 @@ ginarrayconsistent(PG_FUNCTION_ARGS) case GinEqualStrategy: /* we will need recheck */ *recheck = true; + /* * Must have all elements in check[] true; no discrimination - * against nulls here. This is because array_contain_compare - * and array_eq handle nulls differently ... + * against nulls here. This is because array_contain_compare and + * array_eq handle nulls differently ... */ res = true; for (i = 0; i < nkeys; i++) diff --git a/src/backend/access/gin/ginbulk.c b/src/backend/access/gin/ginbulk.c index f0c8c8e37f6..9e5bab194de 100644 --- a/src/backend/access/gin/ginbulk.c +++ b/src/backend/access/gin/ginbulk.c @@ -80,8 +80,8 @@ ginAllocEntryAccumulator(void *arg) GinEntryAccumulator *ea; /* - * Allocate memory by rather big chunks to decrease overhead. We have - * no need to reclaim RBNodes individually, so this costs nothing. + * Allocate memory by rather big chunks to decrease overhead. We have no + * need to reclaim RBNodes individually, so this costs nothing. */ if (accum->entryallocator == NULL || accum->eas_used >= DEF_NENTRY) { @@ -108,7 +108,7 @@ ginInitBA(BuildAccumulator *accum) cmpEntryAccumulator, ginCombineData, ginAllocEntryAccumulator, - NULL, /* no freefunc needed */ + NULL, /* no freefunc needed */ (void *) accum); } @@ -145,8 +145,8 @@ ginInsertBAEntry(BuildAccumulator *accum, bool isNew; /* - * For the moment, fill only the fields of eatmp that will be looked at - * by cmpEntryAccumulator or ginCombineData. + * For the moment, fill only the fields of eatmp that will be looked at by + * cmpEntryAccumulator or ginCombineData. */ eatmp.attnum = attnum; eatmp.key = key; diff --git a/src/backend/access/gin/gindatapage.c b/src/backend/access/gin/gindatapage.c index 4a1e7548008..41dbe9fd11e 100644 --- a/src/backend/access/gin/gindatapage.c +++ b/src/backend/access/gin/gindatapage.c @@ -21,13 +21,13 @@ int ginCompareItemPointers(ItemPointer a, ItemPointer b) { - BlockNumber ba = GinItemPointerGetBlockNumber(a); - BlockNumber bb = GinItemPointerGetBlockNumber(b); + BlockNumber ba = GinItemPointerGetBlockNumber(a); + BlockNumber bb = GinItemPointerGetBlockNumber(b); if (ba == bb) { - OffsetNumber oa = GinItemPointerGetOffsetNumber(a); - OffsetNumber ob = GinItemPointerGetOffsetNumber(b); + OffsetNumber oa = GinItemPointerGetOffsetNumber(a); + OffsetNumber ob = GinItemPointerGetOffsetNumber(b); if (oa == ob) return 0; @@ -383,6 +383,7 @@ dataPlaceToPage(GinBtree btree, Buffer buf, OffsetNumber off, XLogRecData **prda Page page = BufferGetPage(buf); int sizeofitem = GinSizeOfDataPageItem(page); int cnt = 0; + /* these must be static so they can be returned to caller */ static XLogRecData rdata[3]; static ginxlogInsert data; @@ -474,6 +475,7 @@ dataSplitPage(GinBtree btree, Buffer lbuf, Buffer rbuf, OffsetNumber off, XLogRe Size pageSize = PageGetPageSize(lpage); Size freeSpace; uint32 nCopied = 1; + /* these must be static so they can be returned to caller */ static ginxlogSplit data; static XLogRecData rdata[4]; diff --git a/src/backend/access/gin/ginentrypage.c b/src/backend/access/gin/ginentrypage.c index 9749a1be786..fa134f9fc3f 100644 --- a/src/backend/access/gin/ginentrypage.c +++ b/src/backend/access/gin/ginentrypage.c @@ -98,11 +98,11 @@ GinFormTuple(GinState *ginstate, if (errorTooBig) ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), - errmsg("index row size %lu exceeds maximum %lu for index \"%s\"", - (unsigned long) newsize, - (unsigned long) Min(INDEX_SIZE_MASK, - GinMaxItemSize), - RelationGetRelationName(ginstate->index)))); + errmsg("index row size %lu exceeds maximum %lu for index \"%s\"", + (unsigned long) newsize, + (unsigned long) Min(INDEX_SIZE_MASK, + GinMaxItemSize), + RelationGetRelationName(ginstate->index)))); pfree(itup); return NULL; } @@ -164,7 +164,7 @@ GinShortenTuple(IndexTuple itup, uint32 nipd) * Form a non-leaf entry tuple by copying the key data from the given tuple, * which can be either a leaf or non-leaf entry tuple. * - * Any posting list in the source tuple is not copied. The specified child + * Any posting list in the source tuple is not copied. The specified child * block number is inserted into t_tid. */ static IndexTuple @@ -225,7 +225,7 @@ entryIsMoveRight(GinBtree btree, Page page) key = gintuple_get_key(btree->ginstate, itup, &category); if (ginCompareAttEntries(btree->ginstate, - btree->entryAttnum, btree->entryKey, btree->entryCategory, + btree->entryAttnum, btree->entryKey, btree->entryCategory, attnum, key, category) > 0) return TRUE; @@ -488,6 +488,7 @@ entryPlaceToPage(GinBtree btree, Buffer buf, OffsetNumber off, XLogRecData **prd Page page = BufferGetPage(buf); OffsetNumber placed; int cnt = 0; + /* these must be static so they can be returned to caller */ static XLogRecData rdata[3]; static ginxlogInsert data; @@ -561,6 +562,7 @@ entrySplitPage(GinBtree btree, Buffer lbuf, Buffer rbuf, OffsetNumber off, XLogR Page lpage = PageGetTempPageCopy(BufferGetPage(lbuf)); Page rpage = BufferGetPage(rbuf); Size pageSize = PageGetPageSize(lpage); + /* these must be static so they can be returned to caller */ static XLogRecData rdata[2]; static ginxlogSplit data; diff --git a/src/backend/access/gin/ginfast.c b/src/backend/access/gin/ginfast.c index 9960c786c94..82419e37acb 100644 --- a/src/backend/access/gin/ginfast.c +++ b/src/backend/access/gin/ginfast.c @@ -88,9 +88,9 @@ writeListPage(Relation index, Buffer buffer, GinPageGetOpaque(page)->rightlink = rightlink; /* - * tail page may contain only whole row(s) or final part of row placed - * on previous pages (a "row" here meaning all the index tuples generated - * for one heap tuple) + * tail page may contain only whole row(s) or final part of row placed on + * previous pages (a "row" here meaning all the index tuples generated for + * one heap tuple) */ if (rightlink == InvalidBlockNumber) { @@ -437,7 +437,7 @@ ginHeapTupleFastInsert(GinState *ginstate, GinTupleCollector *collector) * Create temporary index tuples for a single indexable item (one index column * for the heap tuple specified by ht_ctid), and append them to the array * in *collector. They will subsequently be written out using - * ginHeapTupleFastInsert. Note that to guarantee consistent state, all + * ginHeapTupleFastInsert. Note that to guarantee consistent state, all * temp tuples for a given heap tuple must be written in one call to * ginHeapTupleFastInsert. */ @@ -475,8 +475,8 @@ ginHeapTupleFastCollect(GinState *ginstate, } /* - * Build an index tuple for each key value, and add to array. In - * pending tuples we just stick the heap TID into t_tid. + * Build an index tuple for each key value, and add to array. In pending + * tuples we just stick the heap TID into t_tid. */ for (i = 0; i < nentries; i++) { @@ -665,7 +665,7 @@ processPendingPage(BuildAccumulator *accum, KeyArray *ka, { IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, i)); OffsetNumber curattnum; - Datum curkey; + Datum curkey; GinNullCategory curcategory; /* Check for change of heap TID or attnum */ @@ -830,7 +830,7 @@ ginInsertCleanup(GinState *ginstate, */ ginBeginBAScan(&accum); while ((list = ginGetBAEntry(&accum, - &attnum, &key, &category, &nlist)) != NULL) + &attnum, &key, &category, &nlist)) != NULL) { ginEntryInsert(ginstate, attnum, key, category, list, nlist, NULL); @@ -867,7 +867,7 @@ ginInsertCleanup(GinState *ginstate, ginBeginBAScan(&accum); while ((list = ginGetBAEntry(&accum, - &attnum, &key, &category, &nlist)) != NULL) + &attnum, &key, &category, &nlist)) != NULL) ginEntryInsert(ginstate, attnum, key, category, list, nlist, NULL); } diff --git a/src/backend/access/gin/ginget.c b/src/backend/access/gin/ginget.c index e07dc0a6ce0..a4771654a6d 100644 --- a/src/backend/access/gin/ginget.c +++ b/src/backend/access/gin/ginget.c @@ -40,8 +40,8 @@ static bool callConsistentFn(GinState *ginstate, GinScanKey key) { /* - * If we're dealing with a dummy EVERYTHING key, we don't want to call - * the consistentFn; just claim it matches. + * If we're dealing with a dummy EVERYTHING key, we don't want to call the + * consistentFn; just claim it matches. */ if (key->searchMode == GIN_SEARCH_MODE_EVERYTHING) { @@ -174,14 +174,14 @@ scanPostingTree(Relation index, GinScanEntry scanEntry, /* * Collects TIDs into scanEntry->matchBitmap for all heap tuples that - * match the search entry. This supports three different match modes: + * match the search entry. This supports three different match modes: * * 1. Partial-match support: scan from current point until the - * comparePartialFn says we're done. + * comparePartialFn says we're done. * 2. SEARCH_MODE_ALL: scan from current point (which should be first - * key for the current attnum) until we hit null items or end of attnum + * key for the current attnum) until we hit null items or end of attnum * 3. SEARCH_MODE_EVERYTHING: scan from current point (which should be first - * key for the current attnum) until we hit end of attnum + * key for the current attnum) until we hit end of attnum * * Returns true if done, false if it's necessary to restart scan from scratch */ @@ -189,7 +189,7 @@ static bool collectMatchBitmap(GinBtreeData *btree, GinBtreeStack *stack, GinScanEntry scanEntry) { - OffsetNumber attnum; + OffsetNumber attnum; Form_pg_attribute attr; /* Initialize empty bitmap result */ @@ -253,8 +253,8 @@ collectMatchBitmap(GinBtreeData *btree, GinBtreeStack *stack, cmp = DatumGetInt32(FunctionCall4(&btree->ginstate->comparePartialFn[attnum - 1], scanEntry->queryKey, idatum, - UInt16GetDatum(scanEntry->strategy), - PointerGetDatum(scanEntry->extra_data))); + UInt16GetDatum(scanEntry->strategy), + PointerGetDatum(scanEntry->extra_data))); if (cmp > 0) return true; @@ -269,7 +269,7 @@ collectMatchBitmap(GinBtreeData *btree, GinBtreeStack *stack, /* * In ALL mode, we are not interested in null items, so we can * stop if we get to a null-item placeholder (which will be the - * last entry for a given attnum). We do want to include NULL_KEY + * last entry for a given attnum). We do want to include NULL_KEY * and EMPTY_ITEM entries, though. */ if (icategory == GIN_CAT_NULL_ITEM) @@ -287,8 +287,8 @@ collectMatchBitmap(GinBtreeData *btree, GinBtreeStack *stack, * We should unlock current page (but not unpin) during tree scan * to prevent deadlock with vacuum processes. * - * We save current entry value (idatum) to be able to re-find - * our tuple after re-locking + * We save current entry value (idatum) to be able to re-find our + * tuple after re-locking */ if (icategory == GIN_CAT_NORM_KEY) idatum = datumCopy(idatum, attr->attbyval, attr->attlen); @@ -442,11 +442,11 @@ restartScanEntry: Page page; /* - * We should unlock entry page before touching posting tree - * to prevent deadlocks with vacuum processes. Because entry is - * never deleted from page and posting tree is never reduced to - * the posting list, we can unlock page after getting BlockNumber - * of root of posting tree. + * We should unlock entry page before touching posting tree to + * prevent deadlocks with vacuum processes. Because entry is never + * deleted from page and posting tree is never reduced to the + * posting list, we can unlock page after getting BlockNumber of + * root of posting tree. */ LockBuffer(stackEntry->buffer, GIN_UNLOCK); needUnlock = FALSE; @@ -596,7 +596,7 @@ entryGetNextItem(GinState *ginstate, GinScanEntry entry) if (!ItemPointerIsValid(&entry->curItem) || ginCompareItemPointers(&entry->curItem, - entry->list + entry->offset - 1) == 0) + entry->list + entry->offset - 1) == 0) { /* * First pages are deleted or empty, or we found exact @@ -656,10 +656,10 @@ entryGetItem(GinState *ginstate, GinScanEntry entry) } /* - * Reset counter to the beginning of entry->matchResult. - * Note: entry->offset is still greater than - * matchResult->ntuples if matchResult is lossy. So, on next - * call we will get next result from TIDBitmap. + * Reset counter to the beginning of entry->matchResult. Note: + * entry->offset is still greater than matchResult->ntuples if + * matchResult is lossy. So, on next call we will get next + * result from TIDBitmap. */ entry->offset = 0; } @@ -745,10 +745,10 @@ keyGetItem(GinState *ginstate, MemoryContext tempCtx, GinScanKey key) /* * Find the minimum of the active entry curItems. * - * Note: a lossy-page entry is encoded by a ItemPointer with max value - * for offset (0xffff), so that it will sort after any exact entries - * for the same page. So we'll prefer to return exact pointers not - * lossy pointers, which is good. + * Note: a lossy-page entry is encoded by a ItemPointer with max value for + * offset (0xffff), so that it will sort after any exact entries for the + * same page. So we'll prefer to return exact pointers not lossy + * pointers, which is good. */ ItemPointerSetMax(&minItem); @@ -782,28 +782,27 @@ keyGetItem(GinState *ginstate, MemoryContext tempCtx, GinScanKey key) /* * Lossy-page entries pose a problem, since we don't know the correct - * entryRes state to pass to the consistentFn, and we also don't know - * what its combining logic will be (could be AND, OR, or even NOT). - * If the logic is OR then the consistentFn might succeed for all - * items in the lossy page even when none of the other entries match. + * entryRes state to pass to the consistentFn, and we also don't know what + * its combining logic will be (could be AND, OR, or even NOT). If the + * logic is OR then the consistentFn might succeed for all items in the + * lossy page even when none of the other entries match. * * If we have a single lossy-page entry then we check to see if the - * consistentFn will succeed with only that entry TRUE. If so, - * we return a lossy-page pointer to indicate that the whole heap - * page must be checked. (On subsequent calls, we'll do nothing until - * minItem is past the page altogether, thus ensuring that we never return - * both regular and lossy pointers for the same page.) + * consistentFn will succeed with only that entry TRUE. If so, we return + * a lossy-page pointer to indicate that the whole heap page must be + * checked. (On subsequent calls, we'll do nothing until minItem is past + * the page altogether, thus ensuring that we never return both regular + * and lossy pointers for the same page.) * - * This idea could be generalized to more than one lossy-page entry, - * but ideally lossy-page entries should be infrequent so it would - * seldom be the case that we have more than one at once. So it - * doesn't seem worth the extra complexity to optimize that case. - * If we do find more than one, we just punt and return a lossy-page - * pointer always. + * This idea could be generalized to more than one lossy-page entry, but + * ideally lossy-page entries should be infrequent so it would seldom be + * the case that we have more than one at once. So it doesn't seem worth + * the extra complexity to optimize that case. If we do find more than + * one, we just punt and return a lossy-page pointer always. * - * Note that only lossy-page entries pointing to the current item's - * page should trigger this processing; we might have future lossy - * pages in the entry array, but they aren't relevant yet. + * Note that only lossy-page entries pointing to the current item's page + * should trigger this processing; we might have future lossy pages in the + * entry array, but they aren't relevant yet. */ ItemPointerSetLossyPage(&curPageLossy, GinItemPointerGetBlockNumber(&key->curItem)); @@ -853,15 +852,14 @@ keyGetItem(GinState *ginstate, MemoryContext tempCtx, GinScanKey key) } /* - * At this point we know that we don't need to return a lossy - * whole-page pointer, but we might have matches for individual exact - * item pointers, possibly in combination with a lossy pointer. Our - * strategy if there's a lossy pointer is to try the consistentFn both - * ways and return a hit if it accepts either one (forcing the hit to - * be marked lossy so it will be rechecked). An exception is that - * we don't need to try it both ways if the lossy pointer is in a - * "hidden" entry, because the consistentFn's result can't depend on - * that. + * At this point we know that we don't need to return a lossy whole-page + * pointer, but we might have matches for individual exact item pointers, + * possibly in combination with a lossy pointer. Our strategy if there's + * a lossy pointer is to try the consistentFn both ways and return a hit + * if it accepts either one (forcing the hit to be marked lossy so it will + * be rechecked). An exception is that we don't need to try it both ways + * if the lossy pointer is in a "hidden" entry, because the consistentFn's + * result can't depend on that. * * Prepare entryRes array to be passed to consistentFn. */ @@ -960,7 +958,7 @@ scanGetItem(IndexScanDesc scan, ItemPointer advancePast, keyGetItem(&so->ginstate, so->tempCtx, key); if (key->isFinished) - return false; /* finished one of keys */ + return false; /* finished one of keys */ if (ginCompareItemPointers(&key->curItem, item) < 0) *item = key->curItem; @@ -975,7 +973,7 @@ scanGetItem(IndexScanDesc scan, ItemPointer advancePast, * that exact TID, or a lossy reference to the same page. * * This logic works only if a keyGetItem stream can never contain both - * exact and lossy pointers for the same page. Else we could have a + * exact and lossy pointers for the same page. Else we could have a * case like * * stream 1 stream 2 @@ -1011,8 +1009,8 @@ scanGetItem(IndexScanDesc scan, ItemPointer advancePast, break; /* - * No hit. Update myAdvancePast to this TID, so that on the next - * pass we'll move to the next possible entry. + * No hit. Update myAdvancePast to this TID, so that on the next pass + * we'll move to the next possible entry. */ myAdvancePast = *item; } @@ -1118,8 +1116,8 @@ scanGetCandidate(IndexScanDesc scan, pendingPosition *pos) /* * Now pos->firstOffset points to the first tuple of current heap - * row, pos->lastOffset points to the first tuple of next heap - * row (or to the end of page) + * row, pos->lastOffset points to the first tuple of next heap row + * (or to the end of page) */ break; } @@ -1181,7 +1179,7 @@ matchPartialInPendingList(GinState *ginstate, Page page, entry->queryKey, datum[off - 1], UInt16GetDatum(entry->strategy), - PointerGetDatum(entry->extra_data))); + PointerGetDatum(entry->extra_data))); if (cmp == 0) return true; else if (cmp > 0) @@ -1227,8 +1225,8 @@ collectMatchesForHeapRow(IndexScanDesc scan, pendingPosition *pos) memset(pos->hasMatchKey, FALSE, so->nkeys); /* - * Outer loop iterates over multiple pending-list pages when a single - * heap row has entries spanning those pages. + * Outer loop iterates over multiple pending-list pages when a single heap + * row has entries spanning those pages. */ for (;;) { @@ -1322,11 +1320,11 @@ collectMatchesForHeapRow(IndexScanDesc scan, pendingPosition *pos) if (res == 0) { /* - * Found exact match (there can be only one, except - * in EMPTY_QUERY mode). + * Found exact match (there can be only one, except in + * EMPTY_QUERY mode). * - * If doing partial match, scan forward from - * here to end of page to check for matches. + * If doing partial match, scan forward from here to + * end of page to check for matches. * * See comment above about tuple's ordering. */ @@ -1355,13 +1353,12 @@ collectMatchesForHeapRow(IndexScanDesc scan, pendingPosition *pos) if (StopLow >= StopHigh && entry->isPartialMatch) { /* - * No exact match on this page. If doing partial - * match, scan from the first tuple greater than - * target value to end of page. Note that since we - * don't remember whether the comparePartialFn told us - * to stop early on a previous page, we will uselessly - * apply comparePartialFn to the first tuple on each - * subsequent page. + * No exact match on this page. If doing partial match, + * scan from the first tuple greater than target value to + * end of page. Note that since we don't remember whether + * the comparePartialFn told us to stop early on a + * previous page, we will uselessly apply comparePartialFn + * to the first tuple on each subsequent page. */ key->entryRes[j] = matchPartialInPendingList(&so->ginstate, diff --git a/src/backend/access/gin/gininsert.c b/src/backend/access/gin/gininsert.c index af5068906fb..3e32af94a96 100644 --- a/src/backend/access/gin/gininsert.c +++ b/src/backend/access/gin/gininsert.c @@ -97,7 +97,7 @@ createPostingTree(Relation index, ItemPointerData *items, uint32 nitems) * Adds array of item pointers to tuple's posting list, or * creates posting tree and tuple pointing to tree in case * of not enough space. Max size of tuple is defined in - * GinFormTuple(). Returns a new, modified index tuple. + * GinFormTuple(). Returns a new, modified index tuple. * items[] must be in sorted order with no duplicates. */ static IndexTuple @@ -195,14 +195,14 @@ buildFreshLeafTuple(GinState *ginstate, BlockNumber postingRoot; /* - * Build posting-tree-only result tuple. We do this first so as - * to fail quickly if the key is too big. + * Build posting-tree-only result tuple. We do this first so as to + * fail quickly if the key is too big. */ res = GinFormTuple(ginstate, attnum, key, category, NULL, 0, true); /* - * Initialize posting tree with as many TIDs as will fit on the - * first page. + * Initialize posting tree with as many TIDs as will fit on the first + * page. */ postingRoot = createPostingTree(ginstate->index, items, @@ -361,7 +361,7 @@ ginBuildCallback(Relation index, HeapTuple htup, Datum *values, ginBeginBAScan(&buildstate->accum); while ((list = ginGetBAEntry(&buildstate->accum, - &attnum, &key, &category, &nlist)) != NULL) + &attnum, &key, &category, &nlist)) != NULL) { /* there could be many entries, so be willing to abort here */ CHECK_FOR_INTERRUPTS(); diff --git a/src/backend/access/gin/ginscan.c b/src/backend/access/gin/ginscan.c index 25f60e15a0d..37b08c0df62 100644 --- a/src/backend/access/gin/ginscan.c +++ b/src/backend/access/gin/ginscan.c @@ -199,7 +199,7 @@ ginFillScanKey(GinScanOpaque so, OffsetNumber attnum, break; default: elog(ERROR, "unexpected searchMode: %d", searchMode); - queryCategory = 0; /* keep compiler quiet */ + queryCategory = 0; /* keep compiler quiet */ break; } isPartialMatch = false; @@ -294,8 +294,8 @@ ginNewScanKey(IndexScanDesc scan) int32 searchMode = GIN_SEARCH_MODE_DEFAULT; /* - * We assume that GIN-indexable operators are strict, so a null - * query argument means an unsatisfiable query. + * We assume that GIN-indexable operators are strict, so a null query + * argument means an unsatisfiable query. */ if (skey->sk_flags & SK_ISNULL) { @@ -315,8 +315,8 @@ ginNewScanKey(IndexScanDesc scan) PointerGetDatum(&searchMode))); /* - * If bogus searchMode is returned, treat as GIN_SEARCH_MODE_ALL; - * note in particular we don't allow extractQueryFn to select + * If bogus searchMode is returned, treat as GIN_SEARCH_MODE_ALL; note + * in particular we don't allow extractQueryFn to select * GIN_SEARCH_MODE_EVERYTHING. */ if (searchMode < GIN_SEARCH_MODE_DEFAULT || @@ -344,20 +344,20 @@ ginNewScanKey(IndexScanDesc scan) * If the extractQueryFn didn't create a nullFlags array, create one, * assuming that everything's non-null. Otherwise, run through the * array and make sure each value is exactly 0 or 1; this ensures - * binary compatibility with the GinNullCategory representation. - * While at it, detect whether any null keys are present. + * binary compatibility with the GinNullCategory representation. While + * at it, detect whether any null keys are present. */ if (nullFlags == NULL) nullFlags = (bool *) palloc0(nQueryValues * sizeof(bool)); else { - int32 j; + int32 j; for (j = 0; j < nQueryValues; j++) { if (nullFlags[j]) { - nullFlags[j] = true; /* not any other nonzero value */ + nullFlags[j] = true; /* not any other nonzero value */ hasNullQuery = true; } } @@ -387,11 +387,11 @@ ginNewScanKey(IndexScanDesc scan) /* * If the index is version 0, it may be missing null and placeholder * entries, which would render searches for nulls and full-index scans - * unreliable. Throw an error if so. + * unreliable. Throw an error if so. */ if (hasNullQuery && !so->isVoidRes) { - GinStatsData ginStats; + GinStatsData ginStats; ginGetStats(scan->indexRelation, &ginStats); if (ginStats.ginVersion < 1) @@ -410,6 +410,7 @@ ginrescan(PG_FUNCTION_ARGS) { IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0); ScanKey scankey = (ScanKey) PG_GETARG_POINTER(1); + /* remaining arguments are ignored */ GinScanOpaque so = (GinScanOpaque) scan->opaque; diff --git a/src/backend/access/gin/ginutil.c b/src/backend/access/gin/ginutil.c index 392c12d47ab..716cf3a7348 100644 --- a/src/backend/access/gin/ginutil.c +++ b/src/backend/access/gin/ginutil.c @@ -70,7 +70,7 @@ initGinState(GinState *state, Relation index) * However, we may have a collatable storage 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 comparison function needs one. This is harmless if the + * case the comparison function needs one. This is harmless if the * comparison function doesn'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 @@ -359,9 +359,9 @@ cmpEntries(const void *a, const void *b, void *arg) aa->datum, bb->datum)); /* - * Detect if we have any duplicates. If there are equal keys, qsort - * must compare them at some point, else it wouldn't know whether one - * should go before or after the other. + * Detect if we have any duplicates. If there are equal keys, qsort must + * compare them at some point, else it wouldn't know whether one should go + * before or after the other. */ if (res == 0) data->haveDups = true; @@ -422,9 +422,9 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum, /* * If the extractValueFn didn't create a nullFlags array, create one, - * assuming that everything's non-null. Otherwise, run through the - * array and make sure each value is exactly 0 or 1; this ensures - * binary compatibility with the GinNullCategory representation. + * assuming that everything's non-null. Otherwise, run through the array + * and make sure each value is exactly 0 or 1; this ensures binary + * compatibility with the GinNullCategory representation. */ if (nullFlags == NULL) nullFlags = (bool *) palloc0(*nentries * sizeof(bool)); @@ -440,8 +440,8 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum, * If there's more than one key, sort and unique-ify. * * XXX Using qsort here is notationally painful, and the overhead is - * pretty bad too. For small numbers of keys it'd likely be better to - * use a simple insertion sort. + * pretty bad too. For small numbers of keys it'd likely be better to use + * a simple insertion sort. */ if (*nentries > 1) { @@ -470,7 +470,7 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum, j = 1; for (i = 1; i < *nentries; i++) { - if (cmpEntries(&keydata[i-1], &keydata[i], &arg) != 0) + if (cmpEntries(&keydata[i - 1], &keydata[i], &arg) != 0) { entries[j] = keydata[i].datum; nullFlags[j] = keydata[i].isnull; @@ -533,9 +533,9 @@ ginoptions(PG_FUNCTION_ARGS) void ginGetStats(Relation index, GinStatsData *stats) { - Buffer metabuffer; - Page metapage; - GinMetaPageData *metadata; + Buffer metabuffer; + Page metapage; + GinMetaPageData *metadata; metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO); LockBuffer(metabuffer, GIN_SHARE); @@ -560,9 +560,9 @@ ginGetStats(Relation index, GinStatsData *stats) void ginUpdateStats(Relation index, const GinStatsData *stats) { - Buffer metabuffer; - Page metapage; - GinMetaPageData *metadata; + Buffer metabuffer; + Page metapage; + GinMetaPageData *metadata; metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO); LockBuffer(metabuffer, GIN_EXCLUSIVE); @@ -580,9 +580,9 @@ ginUpdateStats(Relation index, const GinStatsData *stats) if (RelationNeedsWAL(index)) { - XLogRecPtr recptr; - ginxlogUpdateMeta data; - XLogRecData rdata; + XLogRecPtr recptr; + ginxlogUpdateMeta data; + XLogRecData rdata; data.node = index->rd_node; data.ntuples = 0; diff --git a/src/backend/access/gin/ginvacuum.c b/src/backend/access/gin/ginvacuum.c index 41ad382df0c..79c54f16b8d 100644 --- a/src/backend/access/gin/ginvacuum.c +++ b/src/backend/access/gin/ginvacuum.c @@ -783,7 +783,7 @@ ginvacuumcleanup(PG_FUNCTION_ARGS) { idxStat.nEntryPages++; - if ( GinPageIsLeaf(page) ) + if (GinPageIsLeaf(page)) idxStat.nEntries += PageGetMaxOffsetNumber(page); } diff --git a/src/backend/access/gin/ginxlog.c b/src/backend/access/gin/ginxlog.c index e410959b851..c954bcb12fc 100644 --- a/src/backend/access/gin/ginxlog.c +++ b/src/backend/access/gin/ginxlog.c @@ -388,7 +388,7 @@ ginRedoVacuumPage(XLogRecPtr lsn, XLogRecord *record) else { OffsetNumber i, - *tod; + *tod; IndexTuple itup = (IndexTuple) (XLogRecGetData(record) + sizeof(ginxlogVacuumPage)); tod = (OffsetNumber *) palloc(sizeof(OffsetNumber) * PageGetMaxOffsetNumber(page)); @@ -513,10 +513,10 @@ ginRedoUpdateMetapage(XLogRecPtr lsn, XLogRecord *record) if (!XLByteLE(lsn, PageGetLSN(page))) { OffsetNumber l, - off = (PageIsEmpty(page)) ? FirstOffsetNumber : - OffsetNumberNext(PageGetMaxOffsetNumber(page)); + off = (PageIsEmpty(page)) ? FirstOffsetNumber : + OffsetNumberNext(PageGetMaxOffsetNumber(page)); int i, - tupsize; + tupsize; IndexTuple tuples = (IndexTuple) (XLogRecGetData(record) + sizeof(ginxlogUpdateMeta)); for (i = 0; i < data->ntuples; i++) diff --git a/src/backend/access/gist/gist.c b/src/backend/access/gist/gist.c index 9529413e80e..fae3464600a 100644 --- a/src/backend/access/gist/gist.c +++ b/src/backend/access/gist/gist.c @@ -34,8 +34,8 @@ typedef struct /* A List of these is used represent a split-in-progress. */ typedef struct { - Buffer buf; /* the split page "half" */ - IndexTuple downlink; /* downlink for this half. */ + Buffer buf; /* the split page "half" */ + IndexTuple downlink; /* downlink for this half. */ } GISTPageSplitInfo; /* non-export function prototypes */ @@ -306,13 +306,13 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate, bool is_split; /* - * Refuse to modify a page that's incompletely split. This should - * not happen because we finish any incomplete splits while we walk - * down the tree. However, it's remotely possible that another - * concurrent inserter splits a parent page, and errors out before - * completing the split. We will just throw an error in that case, - * and leave any split we had in progress unfinished too. The next - * insert that comes along will clean up the mess. + * Refuse to modify a page that's incompletely split. This should not + * happen because we finish any incomplete splits while we walk down the + * tree. However, it's remotely possible that another concurrent inserter + * splits a parent page, and errors out before completing the split. We + * will just throw an error in that case, and leave any split we had in + * progress unfinished too. The next insert that comes along will clean up + * the mess. */ if (GistFollowRight(page)) elog(ERROR, "concurrent GiST page split was incomplete"); @@ -338,7 +338,7 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate, SplitedPageLayout *dist = NULL, *ptr; BlockNumber oldrlink = InvalidBlockNumber; - GistNSN oldnsn = { 0, 0 }; + GistNSN oldnsn = {0, 0}; SplitedPageLayout rootpg; BlockNumber blkno = BufferGetBlockNumber(buffer); bool is_rootsplit; @@ -364,8 +364,8 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate, /* * Set up pages to work with. Allocate new buffers for all but the - * leftmost page. The original page becomes the new leftmost page, - * and is just replaced with the new contents. + * leftmost page. The original page becomes the new leftmost page, and + * is just replaced with the new contents. * * For a root-split, allocate new buffers for all child pages, the * original page is overwritten with new root page containing @@ -414,8 +414,8 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate, if (is_rootsplit) { IndexTuple *downlinks; - int ndownlinks = 0; - int i; + int ndownlinks = 0; + int i; rootpg.buffer = buffer; rootpg.page = PageGetTempPageCopySpecial(BufferGetPage(rootpg.buffer)); @@ -443,6 +443,7 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate, for (ptr = dist; ptr; ptr = ptr->next) { GISTPageSplitInfo *si = palloc(sizeof(GISTPageSplitInfo)); + si->buf = ptr->buffer; si->downlink = ptr->itup; *splitinfo = lappend(*splitinfo, si); @@ -455,7 +456,8 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate, */ for (ptr = dist; ptr; ptr = ptr->next) { - char *data = (char *) (ptr->list); + char *data = (char *) (ptr->list); + for (i = 0; i < ptr->block.num; i++) { if (PageAddItem(ptr->page, (Item) data, IndexTupleSize((IndexTuple) data), i + FirstOffsetNumber, false, false) == InvalidOffsetNumber) @@ -495,8 +497,8 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate, MarkBufferDirty(leftchildbuf); /* - * The first page in the chain was a temporary working copy meant - * to replace the old page. Copy it over the old page. + * The first page in the chain was a temporary working copy meant to + * replace the old page. Copy it over the old page. */ PageRestoreTempPage(dist->page, BufferGetPage(dist->buffer)); dist->page = BufferGetPage(dist->buffer); @@ -518,8 +520,8 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate, * Return the new child buffers to the caller. * * If this was a root split, we've already inserted the downlink - * pointers, in the form of a new root page. Therefore we can - * release all the new buffers, and keep just the root page locked. + * pointers, in the form of a new root page. Therefore we can release + * all the new buffers, and keep just the root page locked. */ if (is_rootsplit) { @@ -572,20 +574,20 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate, /* * If we inserted the downlink for a child page, set NSN and clear - * F_FOLLOW_RIGHT flag on the left child, so that concurrent scans know - * to follow the rightlink if and only if they looked at the parent page + * F_FOLLOW_RIGHT flag on the left child, so that concurrent scans know to + * follow the rightlink if and only if they looked at the parent page * before we inserted the downlink. * * Note that we do this *after* writing the WAL record. That means that - * the possible full page image in the WAL record does not include - * these changes, and they must be replayed even if the page is restored - * from the full page image. There's a chicken-and-egg problem: if we - * updated the child pages first, we wouldn't know the recptr of the WAL - * record we're about to write. + * the possible full page image in the WAL record does not include these + * changes, and they must be replayed even if the page is restored from + * the full page image. There's a chicken-and-egg problem: if we updated + * the child pages first, we wouldn't know the recptr of the WAL record + * we're about to write. */ if (BufferIsValid(leftchildbuf)) { - Page leftpg = BufferGetPage(leftchildbuf); + Page leftpg = BufferGetPage(leftchildbuf); GistPageGetOpaque(leftpg)->nsn = recptr; GistClearFollowRight(leftpg); @@ -636,8 +638,8 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate) stack->buffer = ReadBuffer(state.r, stack->blkno); /* - * Be optimistic and grab shared lock first. Swap it for an - * exclusive lock later if we need to update the page. + * Be optimistic and grab shared lock first. Swap it for an exclusive + * lock later if we need to update the page. */ if (!xlocked) { @@ -650,9 +652,9 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate) Assert(!RelationNeedsWAL(state.r) || !XLogRecPtrIsInvalid(stack->lsn)); /* - * If this page was split but the downlink was never inserted to - * the parent because the inserting backend crashed before doing - * that, fix that now. + * If this page was split but the downlink was never inserted to the + * parent because the inserting backend crashed before doing that, fix + * that now. */ if (GistFollowRight(stack->page)) { @@ -680,8 +682,8 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate) /* * Concurrent split detected. There's no guarantee that the * downlink for this page is consistent with the tuple we're - * inserting anymore, so go back to parent and rechoose the - * best child. + * inserting anymore, so go back to parent and rechoose the best + * child. */ UnlockReleaseBuffer(stack->buffer); xlocked = false; @@ -696,7 +698,7 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate) * Find the child node that has the minimum insertion penalty. */ BlockNumber childblkno; - IndexTuple newtup; + IndexTuple newtup; GISTInsertStack *item; stack->childoffnum = gistchoose(state.r, stack->page, itup, giststate); @@ -722,8 +724,8 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate) if (newtup) { /* - * Swap shared lock for an exclusive one. Beware, the page - * may change while we unlock/lock the page... + * Swap shared lock for an exclusive one. Beware, the page may + * change while we unlock/lock the page... */ if (!xlocked) { @@ -738,6 +740,7 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate) continue; } } + /* * Update the tuple. * @@ -752,8 +755,8 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate) stack->childoffnum, InvalidBuffer)) { /* - * If this was a root split, the root page continues to - * be the parent and the updated tuple went to one of the + * If this was a root split, the root page continues to be + * the parent and the updated tuple went to one of the * child pages, so we just need to retry from the root * page. */ @@ -779,13 +782,13 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate) { /* * Leaf page. Insert the new key. We've already updated all the - * parents on the way down, but we might have to split the page - * if it doesn't fit. gistinserthere() will take care of that. + * parents on the way down, but we might have to split the page if + * it doesn't fit. gistinserthere() will take care of that. */ /* - * Swap shared lock for an exclusive one. Be careful, the page - * may change while we unlock/lock the page... + * Swap shared lock for an exclusive one. Be careful, the page may + * change while we unlock/lock the page... */ if (!xlocked) { @@ -798,8 +801,8 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate) if (stack->blkno == GIST_ROOT_BLKNO) { /* - * the only page that can become inner instead of leaf - * is the root page, so for root we should recheck it + * the only page that can become inner instead of leaf is + * the root page, so for root we should recheck it */ if (!GistPageIsLeaf(stack->page)) { @@ -1059,21 +1062,23 @@ static IndexTuple gistformdownlink(Relation rel, Buffer buf, GISTSTATE *giststate, GISTInsertStack *stack) { - Page page = BufferGetPage(buf); + Page page = BufferGetPage(buf); OffsetNumber maxoff; OffsetNumber offset; - IndexTuple downlink = NULL; + IndexTuple downlink = NULL; maxoff = PageGetMaxOffsetNumber(page); for (offset = FirstOffsetNumber; offset <= maxoff; offset = OffsetNumberNext(offset)) { IndexTuple ituple = (IndexTuple) - PageGetItem(page, PageGetItemId(page, offset)); + PageGetItem(page, PageGetItemId(page, offset)); + if (downlink == NULL) downlink = CopyIndexTuple(ituple); else { - IndexTuple newdownlink; + IndexTuple newdownlink; + newdownlink = gistgetadjusted(rel, downlink, ituple, giststate); if (newdownlink) @@ -1082,19 +1087,18 @@ gistformdownlink(Relation rel, Buffer buf, GISTSTATE *giststate, } /* - * If the page is completely empty, we can't form a meaningful - * downlink for it. But we have to insert a downlink for the page. - * Any key will do, as long as its consistent with the downlink of - * parent page, so that we can legally insert it to the parent. - * A minimal one that matches as few scans as possible would be best, - * to keep scans from doing useless work, but we don't know how to - * construct that. So we just use the downlink of the original page - * that was split - that's as far from optimal as it can get but will - * do.. + * If the page is completely empty, we can't form a meaningful downlink + * for it. But we have to insert a downlink for the page. Any key will do, + * as long as its consistent with the downlink of parent page, so that we + * can legally insert it to the parent. A minimal one that matches as few + * scans as possible would be best, to keep scans from doing useless work, + * but we don't know how to construct that. So we just use the downlink of + * the original page that was split - that's as far from optimal as it can + * get but will do.. */ if (!downlink) { - ItemId iid; + ItemId iid; LockBuffer(stack->parent->buffer, GIST_EXCLUSIVE); gistFindCorrectParent(rel, stack); @@ -1131,13 +1135,13 @@ gistfixsplit(GISTInsertState *state, GISTSTATE *giststate) buf = stack->buffer; /* - * Read the chain of split pages, following the rightlinks. Construct - * a downlink tuple for each page. + * Read the chain of split pages, following the rightlinks. Construct a + * downlink tuple for each page. */ for (;;) { GISTPageSplitInfo *si = palloc(sizeof(GISTPageSplitInfo)); - IndexTuple downlink; + IndexTuple downlink; page = BufferGetPage(buf); @@ -1182,8 +1186,8 @@ gistinserttuples(GISTInsertState *state, GISTInsertStack *stack, IndexTuple *tuples, int ntup, OffsetNumber oldoffnum, Buffer leftchild) { - List *splitinfo; - bool is_split; + List *splitinfo; + bool is_split; is_split = gistplacetopage(state, giststate, stack->buffer, tuples, ntup, oldoffnum, @@ -1204,21 +1208,21 @@ static void gistfinishsplit(GISTInsertState *state, GISTInsertStack *stack, GISTSTATE *giststate, List *splitinfo) { - ListCell *lc; - List *reversed; + ListCell *lc; + List *reversed; GISTPageSplitInfo *right; GISTPageSplitInfo *left; - IndexTuple tuples[2]; + IndexTuple tuples[2]; /* A split always contains at least two halves */ Assert(list_length(splitinfo) >= 2); /* - * We need to insert downlinks for each new page, and update the - * downlink for the original (leftmost) page in the split. Begin at - * the rightmost page, inserting one downlink at a time until there's - * only two pages left. Finally insert the downlink for the last new - * page and update the downlink for the original page as one operation. + * We need to insert downlinks for each new page, and update the downlink + * for the original (leftmost) page in the split. Begin at the rightmost + * page, inserting one downlink at a time until there's only two pages + * left. Finally insert the downlink for the last new page and update the + * downlink for the original page as one operation. */ /* for convenience, create a copy of the list in reverse order */ @@ -1231,7 +1235,7 @@ gistfinishsplit(GISTInsertState *state, GISTInsertStack *stack, LockBuffer(stack->parent->buffer, GIST_EXCLUSIVE); gistFindCorrectParent(state->r, stack); - while(list_length(reversed) > 2) + while (list_length(reversed) > 2) { right = (GISTPageSplitInfo *) linitial(reversed); left = (GISTPageSplitInfo *) lsecond(reversed); @@ -1386,7 +1390,7 @@ initGISTstate(GISTSTATE *giststate, Relation index) /* opclasses are not required to provide a Distance method */ if (OidIsValid(index_getprocid(index, i + 1, GIST_DISTANCE_PROC))) fmgr_info_copy(&(giststate->distanceFn[i]), - index_getprocinfo(index, i + 1, GIST_DISTANCE_PROC), + index_getprocinfo(index, i + 1, GIST_DISTANCE_PROC), CurrentMemoryContext); else giststate->distanceFn[i].fn_oid = InvalidOid; diff --git a/src/backend/access/gist/gistget.c b/src/backend/access/gist/gistget.c index 8355081553d..e4488a925de 100644 --- a/src/backend/access/gist/gistget.c +++ b/src/backend/access/gist/gistget.c @@ -32,7 +32,7 @@ * * On success return for a heap tuple, *recheck_p is set to indicate * whether recheck is needed. We recheck if any of the consistent() functions - * request it. recheck is not interesting when examining a non-leaf entry, + * request it. recheck is not interesting when examining a non-leaf entry, * since we must visit the lower index page if there's any doubt. * * If we are doing an ordered scan, so->distances[] is filled with distance @@ -62,15 +62,15 @@ gistindex_keytest(IndexScanDesc scan, *recheck_p = false; /* - * If it's a leftover invalid tuple from pre-9.1, treat it as a match - * with minimum possible distances. This means we'll always follow it - * to the referenced page. + * If it's a leftover invalid tuple from pre-9.1, treat it as a match with + * minimum possible distances. This means we'll always follow it to the + * referenced page. */ if (GistTupleIsInvalid(tuple)) { - int i; + int i; - if (GistPageIsLeaf(page)) /* shouldn't happen */ + if (GistPageIsLeaf(page)) /* shouldn't happen */ elog(ERROR, "invalid GIST tuple found on leaf page"); for (i = 0; i < scan->numberOfOrderBys; i++) so->distances[i] = -get_float8_infinity(); @@ -191,8 +191,8 @@ gistindex_keytest(IndexScanDesc scan, * always be zero, but might as well pass it for possible future * use.) * - * Note that Distance functions don't get a recheck argument. - * We can't tolerate lossy distance calculations on leaf tuples; + * Note that Distance functions don't get a recheck argument. We + * can't tolerate lossy distance calculations on leaf tuples; * there is no opportunity to re-sort the tuples afterwards. */ dist = FunctionCall4(&key->sk_func, @@ -223,7 +223,7 @@ gistindex_keytest(IndexScanDesc scan, * ntids: if not NULL, gistgetbitmap's output tuple counter * * If tbm/ntids aren't NULL, we are doing an amgetbitmap scan, and heap - * tuples should be reported directly into the bitmap. If they are NULL, + * tuples should be reported directly into the bitmap. If they are NULL, * we're doing a plain or ordered indexscan. For a plain indexscan, heap * tuple TIDs are returned into so->pageData[]. For an ordered indexscan, * heap tuple TIDs are pushed into individual search queue items. @@ -525,8 +525,8 @@ gistgettuple(PG_FUNCTION_ARGS) /* * While scanning a leaf page, ItemPointers of matching heap * tuples are stored in so->pageData. If there are any on - * this page, we fall out of the inner "do" and loop around - * to return them. + * this page, we fall out of the inner "do" and loop around to + * return them. */ gistScanPage(scan, item, so->curTreeItem->distances, NULL, NULL); diff --git a/src/backend/access/gist/gistproc.c b/src/backend/access/gist/gistproc.c index 86a5d90f955..43c4b1251b1 100644 --- a/src/backend/access/gist/gistproc.c +++ b/src/backend/access/gist/gistproc.c @@ -904,7 +904,7 @@ gist_point_compress(PG_FUNCTION_ARGS) PG_RETURN_POINTER(entry); } -#define point_point_distance(p1,p2) \ +#define point_point_distance(p1,p2) \ DatumGetFloat8(DirectFunctionCall2(point_distance, \ PointPGetDatum(p1), PointPGetDatum(p2))) @@ -949,8 +949,8 @@ computeDistance(bool isLeaf, BOX *box, Point *point) else { /* closest point will be a vertex */ - Point p; - double subresult; + Point p; + double subresult; result = point_point_distance(point, &box->low); diff --git a/src/backend/access/gist/gistscan.c b/src/backend/access/gist/gistscan.c index 0a125e772d0..67308ed37e5 100644 --- a/src/backend/access/gist/gistscan.c +++ b/src/backend/access/gist/gistscan.c @@ -57,9 +57,9 @@ GISTSearchTreeItemCombiner(RBNode *existing, const RBNode *newrb, void *arg) /* * If new item is heap tuple, it goes to front of chain; otherwise insert - * it before the first index-page item, so that index pages are visited - * in LIFO order, ensuring depth-first search of index pages. See - * comments in gist_private.h. + * it before the first index-page item, so that index pages are visited in + * LIFO order, ensuring depth-first search of index pages. See comments + * in gist_private.h. */ if (GISTSearchItemIsHeap(*newitem)) { @@ -136,6 +136,7 @@ gistrescan(PG_FUNCTION_ARGS) IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0); ScanKey key = (ScanKey) PG_GETARG_POINTER(1); ScanKey orderbys = (ScanKey) PG_GETARG_POINTER(3); + /* nkeys and norderbys arguments are ignored */ GISTScanOpaque so = (GISTScanOpaque) scan->opaque; int i; @@ -164,8 +165,8 @@ gistrescan(PG_FUNCTION_ARGS) scan->numberOfKeys * sizeof(ScanKeyData)); /* - * Modify the scan key so that the Consistent method is called for - * all comparisons. The original operator is passed to the Consistent + * Modify the scan key so that the Consistent method is called for all + * comparisons. The original operator is passed to the Consistent * function in the form of its strategy number, which is available * from the sk_strategy field, and its subtype from the sk_subtype * field. Also, preserve sk_func.fn_collation which is the input diff --git a/src/backend/access/gist/gistutil.c b/src/backend/access/gist/gistutil.c index 6736fd166c3..e8bbd564c71 100644 --- a/src/backend/access/gist/gistutil.c +++ b/src/backend/access/gist/gistutil.c @@ -503,11 +503,12 @@ gistFormTuple(GISTSTATE *giststate, Relation r, } res = index_form_tuple(giststate->tupdesc, compatt, isnull); + /* * The offset number on tuples on internal pages is unused. For historical * reasons, it is set 0xffff. */ - ItemPointerSetOffsetNumber( &(res->t_tid), 0xffff); + ItemPointerSetOffsetNumber(&(res->t_tid), 0xffff); return res; } diff --git a/src/backend/access/gist/gistxlog.c b/src/backend/access/gist/gistxlog.c index 0f406e16c4e..51354c1c185 100644 --- a/src/backend/access/gist/gistxlog.c +++ b/src/backend/access/gist/gistxlog.c @@ -41,12 +41,12 @@ static void gistRedoClearFollowRight(RelFileNode node, XLogRecPtr lsn, BlockNumber leftblkno) { - Buffer buffer; + Buffer buffer; buffer = XLogReadBuffer(node, leftblkno, false); if (BufferIsValid(buffer)) { - Page page = (Page) BufferGetPage(buffer); + Page page = (Page) BufferGetPage(buffer); /* * Note that we still update the page even if page LSN is equal to the @@ -103,6 +103,7 @@ gistRedoPageUpdateRecord(XLogRecPtr lsn, XLogRecord *record) { int i; OffsetNumber *todelete = (OffsetNumber *) data; + data += sizeof(OffsetNumber) * xldata->ntodelete; for (i = 0; i < xldata->ntodelete; i++) @@ -115,12 +116,14 @@ gistRedoPageUpdateRecord(XLogRecPtr lsn, XLogRecord *record) if (data - begin < record->xl_len) { OffsetNumber off = (PageIsEmpty(page)) ? FirstOffsetNumber : - OffsetNumberNext(PageGetMaxOffsetNumber(page)); + OffsetNumberNext(PageGetMaxOffsetNumber(page)); + while (data - begin < record->xl_len) { - IndexTuple itup = (IndexTuple) data; + IndexTuple itup = (IndexTuple) data; Size sz = IndexTupleSize(itup); OffsetNumber l; + data += sz; l = PageAddItem(page, (Item) itup, sz, off, false, false); @@ -418,7 +421,7 @@ gistXLogSplit(RelFileNode node, BlockNumber blkno, bool page_is_leaf, SplitedPageLayout *ptr; int npage = 0, cur; - XLogRecPtr recptr; + XLogRecPtr recptr; for (ptr = dist; ptr; ptr = ptr->next) npage++; @@ -540,8 +543,8 @@ gistXLogUpdate(RelFileNode node, Buffer buffer, } /* - * Include a full page image of the child buf. (only necessary if - * a checkpoint happened since the child page was split) + * Include a full page image of the child buf. (only necessary if a + * checkpoint happened since the child page was split) */ if (BufferIsValid(leftchildbuf)) { diff --git a/src/backend/access/hash/hash.c b/src/backend/access/hash/hash.c index f19e5627f83..4cb29b2bb45 100644 --- a/src/backend/access/hash/hash.c +++ b/src/backend/access/hash/hash.c @@ -413,6 +413,7 @@ hashrescan(PG_FUNCTION_ARGS) { IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0); ScanKey scankey = (ScanKey) PG_GETARG_POINTER(1); + /* remaining arguments are ignored */ HashScanOpaque so = (HashScanOpaque) scan->opaque; Relation rel = scan->indexRelation; diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c index 89697f6ff5e..1fbd8b39b4a 100644 --- a/src/backend/access/heap/heapam.c +++ b/src/backend/access/heap/heapam.c @@ -1070,7 +1070,7 @@ relation_close(Relation relation, LOCKMODE lockmode) * This is essentially relation_open plus check that the relation * is not an index nor a composite type. (The caller should also * check that it's not a view or foreign table before assuming it has - * storage.) + * storage.) * ---------------- */ Relation @@ -1922,8 +1922,8 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid, /* * We're about to do the actual insert -- check for conflict at the - * relation or buffer level first, to avoid possibly having to roll - * back work we've just done. + * relation or buffer level first, to avoid possibly having to roll back + * work we've just done. */ CheckForSerializableConflictIn(relation, NULL, buffer); @@ -2228,8 +2228,8 @@ l1: } /* - * We're about to do the actual delete -- check for conflict first, - * to avoid possibly having to roll back work we've just done. + * We're about to do the actual delete -- check for conflict first, to + * avoid possibly having to roll back work we've just done. */ CheckForSerializableConflictIn(relation, &tp, buffer); @@ -2587,8 +2587,8 @@ l2: } /* - * We're about to do the actual update -- check for conflict first, - * to avoid possibly having to roll back work we've just done. + * We're about to do the actual update -- check for conflict first, to + * avoid possibly having to roll back work we've just done. */ CheckForSerializableConflictIn(relation, &oldtup, buffer); @@ -2737,8 +2737,8 @@ l2: } /* - * We're about to create the new tuple -- check for conflict first, - * to avoid possibly having to roll back work we've just done. + * We're about to create the new tuple -- check for conflict first, to + * avoid possibly having to roll back work we've just done. * * NOTE: For a tuple insert, we only need to check for table locks, since * predicate locking at the index level will cover ranges for anything @@ -3860,12 +3860,12 @@ HeapTupleHeaderAdvanceLatestRemovedXid(HeapTupleHeader tuple, } /* - * Ignore tuples inserted by an aborted transaction or - * if the tuple was updated/deleted by the inserting transaction. + * Ignore tuples inserted by an aborted transaction or if the tuple was + * updated/deleted by the inserting transaction. * * Look for a committed hint bit, or if no xmin bit is set, check clog. - * This needs to work on both master and standby, where it is used - * to assess btree delete records. + * This needs to work on both master and standby, where it is used to + * assess btree delete records. */ if ((tuple->t_infomask & HEAP_XMIN_COMMITTED) || (!(tuple->t_infomask & HEAP_XMIN_COMMITTED) && @@ -3874,7 +3874,7 @@ HeapTupleHeaderAdvanceLatestRemovedXid(HeapTupleHeader tuple, { if (xmax != xmin && TransactionIdFollows(xmax, *latestRemovedXid)) - *latestRemovedXid = xmax; + *latestRemovedXid = xmax; } /* *latestRemovedXid may still be invalid at end */ @@ -4158,8 +4158,8 @@ log_newpage(RelFileNode *rnode, ForkNumber forkNum, BlockNumber blkno, recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_NEWPAGE, rdata); /* - * The page may be uninitialized. If so, we can't set the LSN - * and TLI because that would corrupt the page. + * The page may be uninitialized. If so, we can't set the LSN and TLI + * because that would corrupt the page. */ if (!PageIsNew(page)) { @@ -4352,8 +4352,8 @@ heap_xlog_newpage(XLogRecPtr lsn, XLogRecord *record) memcpy(page, (char *) xlrec + SizeOfHeapNewpage, BLCKSZ); /* - * The page may be uninitialized. If so, we can't set the LSN - * and TLI because that would corrupt the page. + * The page may be uninitialized. If so, we can't set the LSN and TLI + * because that would corrupt the page. */ if (!PageIsNew(page)) { diff --git a/src/backend/access/heap/hio.c b/src/backend/access/heap/hio.c index 28499925281..72a69e52b02 100644 --- a/src/backend/access/heap/hio.c +++ b/src/backend/access/heap/hio.c @@ -150,7 +150,7 @@ ReadBufferBI(Relation relation, BlockNumber targetBlock, Buffer RelationGetBufferForTuple(Relation relation, Size len, Buffer otherBuffer, int options, - struct BulkInsertStateData *bistate) + struct BulkInsertStateData * bistate) { bool use_fsm = !(options & HEAP_INSERT_SKIP_FSM); Buffer buffer = InvalidBuffer; diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c index c710f1d316e..e56140950af 100644 --- a/src/backend/access/heap/rewriteheap.c +++ b/src/backend/access/heap/rewriteheap.c @@ -131,7 +131,7 @@ typedef struct RewriteStateData * them */ HTAB *rs_unresolved_tups; /* unmatched A tuples */ HTAB *rs_old_new_tid_map; /* unmatched B tuples */ -} RewriteStateData; +} RewriteStateData; /* * The lookup keys for the hash tables are tuple TID and xmin (we must check @@ -277,7 +277,7 @@ end_heap_rewrite(RewriteState state) } /* - * If the rel is WAL-logged, must fsync before commit. We use heap_sync + * If the rel is WAL-logged, must fsync before commit. We use heap_sync * to ensure that the toast table gets fsync'd too. * * It's obvious that we must do this when not WAL-logging. It's less diff --git a/src/backend/access/index/indexam.c b/src/backend/access/index/indexam.c index 88f73e8241e..66af2c37c54 100644 --- a/src/backend/access/index/indexam.c +++ b/src/backend/access/index/indexam.c @@ -872,7 +872,7 @@ index_getprocinfo(Relation irel, procnum, attnum, RelationGetRelationName(irel)); fmgr_info_cxt(procId, locinfo, irel->rd_indexcxt); - fmgr_info_set_collation(irel->rd_indcollation[attnum-1], locinfo); + fmgr_info_set_collation(irel->rd_indcollation[attnum - 1], locinfo); } return locinfo; diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c index 0dd745f19a4..219f94fd0dd 100644 --- a/src/backend/access/nbtree/nbtinsert.c +++ b/src/backend/access/nbtree/nbtinsert.c @@ -179,8 +179,8 @@ top: * The only conflict predicate locking cares about for indexes is when * an index tuple insert conflicts with an existing lock. Since the * actual location of the insert is hard to predict because of the - * random search used to prevent O(N^2) performance when there are many - * duplicate entries, we can just use the "first valid" page. + * random search used to prevent O(N^2) performance when there are + * many duplicate entries, we can just use the "first valid" page. */ CheckForSerializableConflictIn(rel, NULL, buf); /* do the insertion */ @@ -915,13 +915,13 @@ _bt_split(Relation rel, Buffer buf, OffsetNumber firstright, /* * origpage is the original page to be split. leftpage is a temporary * buffer that receives the left-sibling data, which will be copied back - * into origpage on success. rightpage is the new page that receives - * the right-sibling data. If we fail before reaching the critical - * section, origpage hasn't been modified and leftpage is only workspace. - * In principle we shouldn't need to worry about rightpage either, - * because it hasn't been linked into the btree page structure; but to - * avoid leaving possibly-confusing junk behind, we are careful to rewrite - * rightpage as zeroes before throwing any error. + * into origpage on success. rightpage is the new page that receives the + * right-sibling data. If we fail before reaching the critical section, + * origpage hasn't been modified and leftpage is only workspace. In + * principle we shouldn't need to worry about rightpage either, because it + * hasn't been linked into the btree page structure; but to avoid leaving + * possibly-confusing junk behind, we are careful to rewrite rightpage as + * zeroes before throwing any error. */ origpage = BufferGetPage(buf); leftpage = PageGetTempPage(origpage); @@ -1118,7 +1118,7 @@ _bt_split(Relation rel, Buffer buf, OffsetNumber firstright, { memset(rightpage, 0, BufferGetPageSize(rbuf)); elog(ERROR, "right sibling's left-link doesn't match: " - "block %u links to %u instead of expected %u in index \"%s\"", + "block %u links to %u instead of expected %u in index \"%s\"", oopaque->btpo_next, sopaque->btpo_prev, origpagenumber, RelationGetRelationName(rel)); } diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c index 27964455f7c..2477736281b 100644 --- a/src/backend/access/nbtree/nbtpage.c +++ b/src/backend/access/nbtree/nbtpage.c @@ -1268,9 +1268,9 @@ _bt_pagedel(Relation rel, Buffer buf, BTStack stack) /* * Check that the parent-page index items we're about to delete/overwrite - * contain what we expect. This can fail if the index has become - * corrupt for some reason. We want to throw any error before entering - * the critical section --- otherwise it'd be a PANIC. + * contain what we expect. This can fail if the index has become corrupt + * for some reason. We want to throw any error before entering the + * critical section --- otherwise it'd be a PANIC. * * The test on the target item is just an Assert because _bt_getstackbuf * should have guaranteed it has the expected contents. The test on the diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c index 7a0e1a9c25e..6a7ddd7db4d 100644 --- a/src/backend/access/nbtree/nbtree.c +++ b/src/backend/access/nbtree/nbtree.c @@ -220,7 +220,7 @@ btbuildempty(PG_FUNCTION_ARGS) metapage = (Page) palloc(BLCKSZ); _bt_initmetapage(metapage, P_NONE, 0); - /* Write the page. If archiving/streaming, XLOG it. */ + /* Write the page. If archiving/streaming, XLOG it. */ smgrwrite(index->rd_smgr, INIT_FORKNUM, BTREE_METAPAGE, (char *) metapage, true); if (XLogIsNeeded()) @@ -403,6 +403,7 @@ btrescan(PG_FUNCTION_ARGS) { IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0); ScanKey scankey = (ScanKey) PG_GETARG_POINTER(1); + /* remaining arguments are ignored */ BTScanOpaque so = (BTScanOpaque) scan->opaque; diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c index cb78a1bae16..91f8cadea52 100644 --- a/src/backend/access/nbtree/nbtsearch.c +++ b/src/backend/access/nbtree/nbtsearch.c @@ -65,7 +65,7 @@ _bt_search(Relation rel, int keysz, ScanKey scankey, bool nextkey, /* If index is empty and access = BT_READ, no root page is created. */ if (!BufferIsValid(*bufP)) { - PredicateLockRelation(rel); /* Nothing finer to lock exists. */ + PredicateLockRelation(rel); /* Nothing finer to lock exists. */ return (BTStack) NULL; } @@ -1364,7 +1364,7 @@ _bt_get_endpoint(Relation rel, uint32 level, bool rightmost) if (!BufferIsValid(buf)) { /* empty index... */ - PredicateLockRelation(rel); /* Nothing finer to lock exists. */ + PredicateLockRelation(rel); /* Nothing finer to lock exists. */ return InvalidBuffer; } @@ -1444,7 +1444,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir) if (!BufferIsValid(buf)) { /* empty index... */ - PredicateLockRelation(rel); /* Nothing finer to lock exists. */ + PredicateLockRelation(rel); /* Nothing finer to lock exists. */ so->currPos.buf = InvalidBuffer; return false; } diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c index fd0e86a6aa3..256a7f9f98f 100644 --- a/src/backend/access/nbtree/nbtsort.c +++ b/src/backend/access/nbtree/nbtsort.c @@ -799,7 +799,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2) /* * If the index is WAL-logged, we must fsync it down to disk before it's - * safe to commit the transaction. (For a non-WAL-logged index we don't + * safe to commit the transaction. (For a non-WAL-logged index we don't * care since the index will be uninteresting after a crash anyway.) * * It's obvious that we must do this when not WAL-logging the build. It's diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c index add932d9428..d448ba6a502 100644 --- a/src/backend/access/nbtree/nbtutils.c +++ b/src/backend/access/nbtree/nbtutils.c @@ -70,8 +70,8 @@ _bt_mkscankey(Relation rel, IndexTuple itup) /* * We can use the cached (default) support procs since no cross-type - * comparison can be needed. The cached support proc entries have - * the right collation for the index, too. + * comparison can be needed. The cached support proc entries have the + * right collation for the index, too. */ procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC); arg = index_getattr(itup, i + 1, itupdesc, &null); @@ -120,8 +120,8 @@ _bt_mkscankey_nodata(Relation rel) /* * We can use the cached (default) support procs since no cross-type - * comparison can be needed. The cached support proc entries have - * the right collation for the index, too. + * comparison can be needed. The cached support proc entries have the + * right collation for the index, too. */ procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC); flags = SK_ISNULL | (indoption[i] << SK_BT_INDOPTION_SHIFT); diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c index 729c7b72e0f..281268120ef 100644 --- a/src/backend/access/transam/twophase.c +++ b/src/backend/access/transam/twophase.c @@ -120,7 +120,7 @@ typedef struct GlobalTransactionData TransactionId locking_xid; /* top-level XID of backend working on xact */ bool valid; /* TRUE if fully prepared */ char gid[GIDSIZE]; /* The GID assigned to the prepared xact */ -} GlobalTransactionData; +} GlobalTransactionData; /* * Two Phase Commit shared state. Access to this struct is protected @@ -1029,8 +1029,8 @@ EndPrepare(GlobalTransaction gxact) /* If we crash now, we have prepared: WAL replay will fix things */ /* - * Wake up all walsenders to send WAL up to the PREPARE record - * immediately if replication is enabled + * Wake up all walsenders to send WAL up to the PREPARE record immediately + * if replication is enabled */ if (max_wal_senders > 0) WalSndWakeup(); @@ -2043,8 +2043,8 @@ RecordTransactionCommitPrepared(TransactionId xid, /* * Wait for synchronous replication, if required. * - * Note that at this stage we have marked clog, but still show as - * running in the procarray and continue to hold locks. + * Note that at this stage we have marked clog, but still show as running + * in the procarray and continue to hold locks. */ SyncRepWaitForLSN(recptr); } @@ -2130,8 +2130,8 @@ RecordTransactionAbortPrepared(TransactionId xid, /* * Wait for synchronous replication, if required. * - * Note that at this stage we have marked clog, but still show as - * running in the procarray and continue to hold locks. + * Note that at this stage we have marked clog, but still show as running + * in the procarray and continue to hold locks. */ SyncRepWaitForLSN(recptr); } diff --git a/src/backend/access/transam/varsup.c b/src/backend/access/transam/varsup.c index a828b3de48f..500335bd6ff 100644 --- a/src/backend/access/transam/varsup.c +++ b/src/backend/access/transam/varsup.c @@ -355,9 +355,9 @@ SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid) char *oldest_datname; /* - * We can be called when not inside a transaction, for example - * during StartupXLOG(). In such a case we cannot do database - * access, so we must just report the oldest DB's OID. + * We can be called when not inside a transaction, for example during + * StartupXLOG(). In such a case we cannot do database access, so we + * must just report the oldest DB's OID. * * Note: it's also possible that get_database_name fails and returns * NULL, for example because the database just got dropped. We'll diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c index 55aee879101..8a4c4eccd73 100644 --- a/src/backend/access/transam/xact.c +++ b/src/backend/access/transam/xact.c @@ -420,11 +420,11 @@ AssignTransactionId(TransactionState s) */ if (isSubXact && !TransactionIdIsValid(s->parent->transactionId)) { - TransactionState p = s->parent; - TransactionState *parents; - size_t parentOffset = 0; + TransactionState p = s->parent; + TransactionState *parents; + size_t parentOffset = 0; - parents = palloc(sizeof(TransactionState) * s->nestingLevel); + parents = palloc(sizeof(TransactionState) * s->nestingLevel); while (p != NULL && !TransactionIdIsValid(p->transactionId)) { parents[parentOffset++] = p; @@ -432,8 +432,8 @@ AssignTransactionId(TransactionState s) } /* - * This is technically a recursive call, but the recursion will - * never be more than one layer deep. + * This is technically a recursive call, but the recursion will never + * be more than one layer deep. */ while (parentOffset != 0) AssignTransactionId(parents[--parentOffset]); @@ -1037,16 +1037,17 @@ RecordTransactionCommit(void) /* * Check if we want to commit asynchronously. We can allow the XLOG flush * to happen asynchronously if synchronous_commit=off, or if the current - * transaction has not performed any WAL-logged operation. The latter case - * can arise if the current transaction wrote only to temporary and/or - * unlogged tables. In case of a crash, the loss of such a transaction - * will be irrelevant since temp tables will be lost anyway, and unlogged - * tables will be truncated. (Given the foregoing, you might think that it - * would be unnecessary to emit the XLOG record at all in this case, but we - * don't currently try to do that. It would certainly cause problems at - * least in Hot Standby mode, where the KnownAssignedXids machinery - * requires tracking every XID assignment. It might be OK to skip it only - * when wal_level < hot_standby, but for now we don't.) + * transaction has not performed any WAL-logged operation. The latter + * case can arise if the current transaction wrote only to temporary + * and/or unlogged tables. In case of a crash, the loss of such a + * transaction will be irrelevant since temp tables will be lost anyway, + * and unlogged tables will be truncated. (Given the foregoing, you might + * think that it would be unnecessary to emit the XLOG record at all in + * this case, but we don't currently try to do that. It would certainly + * cause problems at least in Hot Standby mode, where the + * KnownAssignedXids machinery requires tracking every XID assignment. It + * might be OK to skip it only when wal_level < hot_standby, but for now + * we don't.) * * However, if we're doing cleanup of any non-temp rels or committing any * command that wanted to force sync commit, then we must flush XLOG @@ -1130,8 +1131,8 @@ RecordTransactionCommit(void) /* * Wait for synchronous replication, if required. * - * Note that at this stage we have marked clog, but still show as - * running in the procarray and continue to hold locks. + * Note that at this stage we have marked clog, but still show as running + * in the procarray and continue to hold locks. */ SyncRepWaitForLSN(XactLastRecEnd); @@ -1785,10 +1786,10 @@ CommitTransaction(void) } /* - * The remaining actions cannot call any user-defined code, so it's - * safe to start shutting down within-transaction services. But note - * that most of this stuff could still throw an error, which would - * switch us into the transaction-abort path. + * The remaining actions cannot call any user-defined code, so it's safe + * to start shutting down within-transaction services. But note that most + * of this stuff could still throw an error, which would switch us into + * the transaction-abort path. */ /* Shut down the deferred-trigger manager */ @@ -1805,8 +1806,8 @@ CommitTransaction(void) /* * Mark serializable transaction as complete for predicate locking - * purposes. This should be done as late as we can put it and still - * allow errors to be raised for failure patterns found at commit. + * purposes. This should be done as late as we can put it and still allow + * errors to be raised for failure patterns found at commit. */ PreCommit_CheckForSerializationFailure(); @@ -1988,10 +1989,10 @@ PrepareTransaction(void) } /* - * The remaining actions cannot call any user-defined code, so it's - * safe to start shutting down within-transaction services. But note - * that most of this stuff could still throw an error, which would - * switch us into the transaction-abort path. + * The remaining actions cannot call any user-defined code, so it's safe + * to start shutting down within-transaction services. But note that most + * of this stuff could still throw an error, which would switch us into + * the transaction-abort path. */ /* Shut down the deferred-trigger manager */ @@ -2008,8 +2009,8 @@ PrepareTransaction(void) /* * Mark serializable transaction as complete for predicate locking - * purposes. This should be done as late as we can put it and still - * allow errors to be raised for failure patterns found at commit. + * purposes. This should be done as late as we can put it and still allow + * errors to be raised for failure patterns found at commit. */ PreCommit_CheckForSerializationFailure(); diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index b31c79ebbdc..9c45759661c 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -64,7 +64,7 @@ /* File path names (all relative to $PGDATA) */ #define RECOVERY_COMMAND_FILE "recovery.conf" #define RECOVERY_COMMAND_DONE "recovery.done" -#define PROMOTE_SIGNAL_FILE "promote" +#define PROMOTE_SIGNAL_FILE "promote" /* User-settable parameters */ @@ -160,6 +160,7 @@ static XLogRecPtr LastRec; * known, need to check the shared state". */ static bool LocalRecoveryInProgress = true; + /* * Local copy of SharedHotStandbyActive variable. False actually means "not * known, need to check the shared state". @@ -355,10 +356,9 @@ typedef struct XLogCtlInsert /* * exclusiveBackup is true if a backup started with pg_start_backup() is * in progress, and nonExclusiveBackups is a counter indicating the number - * of streaming base backups currently in progress. forcePageWrites is - * set to true when either of these is non-zero. lastBackupStart is the - * latest checkpoint redo location used as a starting point for an online - * backup. + * of streaming base backups currently in progress. forcePageWrites is set + * to true when either of these is non-zero. lastBackupStart is the latest + * checkpoint redo location used as a starting point for an online backup. */ bool exclusiveBackup; int nonExclusiveBackups; @@ -388,7 +388,7 @@ typedef struct XLogCtlData XLogwrtResult LogwrtResult; uint32 ckptXidEpoch; /* nextXID & epoch of latest checkpoint */ TransactionId ckptXid; - XLogRecPtr asyncXactLSN; /* LSN of newest async commit/abort */ + XLogRecPtr asyncXactLSN; /* LSN of newest async commit/abort */ uint32 lastRemovedLog; /* latest removed/recycled XLOG segment */ uint32 lastRemovedSeg; @@ -425,9 +425,9 @@ typedef struct XLogCtlData bool SharedHotStandbyActive; /* - * recoveryWakeupLatch is used to wake up the startup process to - * continue WAL replay, if it is waiting for WAL to arrive or failover - * trigger file to appear. + * recoveryWakeupLatch is used to wake up the startup process to continue + * WAL replay, if it is waiting for WAL to arrive or failover trigger file + * to appear. */ Latch recoveryWakeupLatch; @@ -576,7 +576,7 @@ typedef struct xl_parameter_change /* logs restore point */ typedef struct xl_restore_point { - TimestampTz rp_time; + TimestampTz rp_time; char rp_name[MAXFNAMELEN]; } xl_restore_point; @@ -4272,27 +4272,29 @@ existsTimeLineHistory(TimeLineID probeTLI) static bool rescanLatestTimeLine(void) { - TimeLineID newtarget; + TimeLineID newtarget; + newtarget = findNewestTimeLine(recoveryTargetTLI); if (newtarget != recoveryTargetTLI) { /* * Determine the list of expected TLIs for the new TLI */ - List *newExpectedTLIs; + List *newExpectedTLIs; + newExpectedTLIs = readTimeLineHistory(newtarget); /* - * If the current timeline is not part of the history of the - * new timeline, we cannot proceed to it. + * If the current timeline is not part of the history of the new + * timeline, we cannot proceed to it. * * XXX This isn't foolproof: The new timeline might have forked from * the current one, but before the current recovery location. In that * case we will still switch to the new timeline and proceed replaying * from it even though the history doesn't match what we already * replayed. That's not good. We will likely notice at the next online - * checkpoint, as the TLI won't match what we expected, but it's - * not guaranteed. The admin needs to make sure that doesn't happen. + * checkpoint, as the TLI won't match what we expected, but it's not + * guaranteed. The admin needs to make sure that doesn't happen. */ if (!list_member_int(newExpectedTLIs, (int) recoveryTargetTLI)) @@ -4480,7 +4482,7 @@ writeTimeLineHistory(TimeLineID newTLI, TimeLineID parentTLI, timestamptz_to_str(recoveryStopTime)); else if (recoveryTarget == RECOVERY_TARGET_NAME) snprintf(buffer, sizeof(buffer), - "%s%u\t%s\tat restore point \"%s\"\n", + "%s%u\t%s\tat restore point \"%s\"\n", (srcfd < 0) ? "" : "\n", parentTLI, xlogfname, @@ -4921,7 +4923,7 @@ check_wal_buffers(int *newval, void **extra, GucSource source) { /* * If we haven't yet changed the boot_val default of -1, just let it - * be. We'll fix it when XLOGShmemSize is called. + * be. We'll fix it when XLOGShmemSize is called. */ if (XLOGbuffers == -1) return true; @@ -4954,8 +4956,8 @@ XLOGShmemSize(void) /* * If the value of wal_buffers is -1, use the preferred auto-tune value. * This isn't an amazingly clean place to do this, but we must wait till - * NBuffers has received its final value, and must do it before using - * the value of XLOGbuffers to do anything important. + * NBuffers has received its final value, and must do it before using the + * value of XLOGbuffers to do anything important. */ if (XLOGbuffers == -1) { @@ -5086,9 +5088,9 @@ BootStrapXLOG(void) /* * Set up information for the initial checkpoint record * - * The initial checkpoint record is written to the beginning of the - * WAL segment with logid=0 logseg=1. The very first WAL segment, 0/0, is - * not used, so that we can use 0/0 to mean "before any valid WAL segment". + * The initial checkpoint record is written to the beginning of the WAL + * segment with logid=0 logseg=1. The very first WAL segment, 0/0, is not + * used, so that we can use 0/0 to mean "before any valid WAL segment". */ checkPoint.redo.xlogid = 0; checkPoint.redo.xrecoff = XLogSegSize + SizeOfXLogLongPHD; @@ -5219,8 +5221,8 @@ readRecoveryCommandFile(void) TimeLineID rtli = 0; bool rtliGiven = false; ConfigVariable *item, - *head = NULL, - *tail = NULL; + *head = NULL, + *tail = NULL; fd = AllocateFile(RECOVERY_COMMAND_FILE, "r"); if (fd == NULL) @@ -5236,7 +5238,7 @@ readRecoveryCommandFile(void) /* * Since we're asking ParseConfigFp() to error out at FATAL, there's no * need to check the return value. - */ + */ ParseConfigFp(fd, RECOVERY_COMMAND_FILE, 0, FATAL, &head, &tail); for (item = head; item; item = item->next) @@ -5312,7 +5314,7 @@ readRecoveryCommandFile(void) * this overrides recovery_target_time */ if (recoveryTarget == RECOVERY_TARGET_XID || - recoveryTarget == RECOVERY_TARGET_NAME) + recoveryTarget == RECOVERY_TARGET_NAME) continue; recoveryTarget = RECOVERY_TARGET_TIME; @@ -5321,7 +5323,7 @@ readRecoveryCommandFile(void) */ recoveryTargetTime = DatumGetTimestampTz(DirectFunctionCall3(timestamptz_in, - CStringGetDatum(item->value), + CStringGetDatum(item->value), ObjectIdGetDatum(InvalidOid), Int32GetDatum(-1))); ereport(DEBUG2, @@ -5610,8 +5612,8 @@ recoveryStopsHere(XLogRecord *record, bool *includeThis) if (recoveryTarget == RECOVERY_TARGET_UNSET) { /* - * Save timestamp of latest transaction commit/abort if this is - * a transaction record + * Save timestamp of latest transaction commit/abort if this is a + * transaction record */ if (record->xl_rmid == RM_XACT_ID) SetLatestXTime(recordXtime); @@ -5636,8 +5638,8 @@ recoveryStopsHere(XLogRecord *record, bool *includeThis) else if (recoveryTarget == RECOVERY_TARGET_NAME) { /* - * There can be many restore points that share the same name, so we stop - * at the first one + * There can be many restore points that share the same name, so we + * stop at the first one */ stopsHere = (strcmp(recordRPName, recoveryTargetName) == 0); @@ -5699,14 +5701,14 @@ recoveryStopsHere(XLogRecord *record, bool *includeThis) strncpy(recoveryStopName, recordRPName, MAXFNAMELEN); ereport(LOG, - (errmsg("recovery stopping at restore point \"%s\", time %s", - recoveryStopName, - timestamptz_to_str(recoveryStopTime)))); + (errmsg("recovery stopping at restore point \"%s\", time %s", + recoveryStopName, + timestamptz_to_str(recoveryStopTime)))); } /* - * Note that if we use a RECOVERY_TARGET_TIME then we can stop - * at a restore point since they are timestamped, though the latest + * Note that if we use a RECOVERY_TARGET_TIME then we can stop at a + * restore point since they are timestamped, though the latest * transaction time is not updated. */ if (record->xl_rmid == RM_XACT_ID && recoveryStopAfter) @@ -5732,7 +5734,7 @@ recoveryPausesHere(void) while (RecoveryIsPaused()) { - pg_usleep(1000000L); /* 1000 ms */ + pg_usleep(1000000L); /* 1000 ms */ HandleStartupProcInterrupts(); } } @@ -5742,7 +5744,7 @@ RecoveryIsPaused(void) { /* use volatile pointer to prevent code rearrangement */ volatile XLogCtlData *xlogctl = XLogCtl; - bool recoveryPause; + bool recoveryPause; SpinLockAcquire(&xlogctl->info_lck); recoveryPause = xlogctl->recoveryPause; @@ -5771,7 +5773,7 @@ pg_xlog_replay_pause(PG_FUNCTION_ARGS) if (!superuser()) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), - (errmsg("must be superuser to control recovery")))); + (errmsg("must be superuser to control recovery")))); if (!RecoveryInProgress()) ereport(ERROR, @@ -5793,7 +5795,7 @@ pg_xlog_replay_resume(PG_FUNCTION_ARGS) if (!superuser()) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), - (errmsg("must be superuser to control recovery")))); + (errmsg("must be superuser to control recovery")))); if (!RecoveryInProgress()) ereport(ERROR, @@ -5815,7 +5817,7 @@ pg_is_xlog_replay_paused(PG_FUNCTION_ARGS) if (!superuser()) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), - (errmsg("must be superuser to control recovery")))); + (errmsg("must be superuser to control recovery")))); if (!RecoveryInProgress()) ereport(ERROR, @@ -5870,7 +5872,7 @@ GetLatestXTime(void) Datum pg_last_xact_replay_timestamp(PG_FUNCTION_ARGS) { - TimestampTz xtime; + TimestampTz xtime; xtime = GetLatestXTime(); if (xtime == 0) @@ -6132,10 +6134,10 @@ StartupXLOG(void) InRecovery = true; /* force recovery even if SHUTDOWNED */ /* - * Make sure that REDO location exists. This may not be - * the case if there was a crash during an online backup, - * which left a backup_label around that references a WAL - * segment that's already been archived. + * Make sure that REDO location exists. This may not be the case + * if there was a crash during an online backup, which left a + * backup_label around that references a WAL segment that's + * already been archived. */ if (XLByteLT(checkPoint.redo, checkPointLoc)) { @@ -6150,7 +6152,7 @@ StartupXLOG(void) ereport(FATAL, (errmsg("could not locate required checkpoint record"), errhint("If you are not restoring from a backup, try removing the file \"%s/backup_label\".", DataDir))); - wasShutdown = false; /* keep compiler quiet */ + wasShutdown = false; /* keep compiler quiet */ } /* set flag to delete it later */ haveBackupLabel = true; @@ -6330,9 +6332,9 @@ StartupXLOG(void) /* * We're in recovery, so unlogged relations relations may be trashed - * and must be reset. This should be done BEFORE allowing Hot - * Standby connections, so that read-only backends don't try to - * read whatever garbage is left over from before. + * and must be reset. This should be done BEFORE allowing Hot Standby + * connections, so that read-only backends don't try to read whatever + * garbage is left over from before. */ ResetUnloggedRelations(UNLOGGED_RELATION_CLEANUP); @@ -6517,7 +6519,8 @@ StartupXLOG(void) if (recoveryStopsHere(record, &recoveryApply)) { /* - * Pause only if users can connect to send a resume message + * Pause only if users can connect to send a resume + * message */ if (recoveryPauseAtTarget && standbyState == STANDBY_SNAPSHOT_READY) { @@ -7003,8 +7006,8 @@ HotStandbyActive(void) { /* * We check shared state each time only until Hot Standby is active. We - * can't de-activate Hot Standby, so there's no need to keep checking after - * the shared variable has once been seen true. + * can't de-activate Hot Standby, so there's no need to keep checking + * after the shared variable has once been seen true. */ if (LocalHotStandbyActive) return true; @@ -7429,14 +7432,14 @@ LogCheckpointEnd(bool restartpoint) */ longest_secs = (long) (CheckpointStats.ckpt_longest_sync / 1000000); longest_usecs = CheckpointStats.ckpt_longest_sync - - (uint64) longest_secs * 1000000; + (uint64) longest_secs *1000000; average_sync_time = 0; - if (CheckpointStats.ckpt_sync_rels > 0) + if (CheckpointStats.ckpt_sync_rels > 0) average_sync_time = CheckpointStats.ckpt_agg_sync_time / CheckpointStats.ckpt_sync_rels; average_secs = (long) (average_sync_time / 1000000); - average_usecs = average_sync_time - (uint64) average_secs * 1000000; + average_usecs = average_sync_time - (uint64) average_secs *1000000; if (restartpoint) elog(LOG, "restartpoint complete: wrote %d buffers (%.1f%%); " @@ -8241,9 +8244,9 @@ RequestXLogSwitch(void) XLogRecPtr XLogRestorePoint(const char *rpName) { - XLogRecPtr RecPtr; - XLogRecData rdata; - xl_restore_point xlrec; + XLogRecPtr RecPtr; + XLogRecData rdata; + xl_restore_point xlrec; xlrec.rp_time = GetCurrentTimestamp(); strncpy(xlrec.rp_name, rpName, MAXFNAMELEN); @@ -8257,7 +8260,7 @@ XLogRestorePoint(const char *rpName) ereport(LOG, (errmsg("restore point \"%s\" created at %X/%X", - rpName, RecPtr.xlogid, RecPtr.xrecoff))); + rpName, RecPtr.xlogid, RecPtr.xrecoff))); return RecPtr; } @@ -8643,7 +8646,7 @@ get_sync_bit(int method) /* * Optimize writes by bypassing kernel cache with O_DIRECT when using - * O_SYNC/O_FSYNC and O_DSYNC. But only if archiving and streaming are + * O_SYNC/O_FSYNC and O_DSYNC. But only if archiving and streaming are * disabled, otherwise the archive command or walsender process will read * the WAL soon after writing it, which is guaranteed to cause a physical * read if we bypassed the kernel cache. We also skip the @@ -8775,7 +8778,7 @@ pg_start_backup(PG_FUNCTION_ARGS) text *backupid = PG_GETARG_TEXT_P(0); bool fast = PG_GETARG_BOOL(1); char *backupidstr; - XLogRecPtr startpoint; + XLogRecPtr startpoint; char startxlogstr[MAXFNAMELEN]; backupidstr = text_to_cstring(backupid); @@ -8791,7 +8794,7 @@ pg_start_backup(PG_FUNCTION_ARGS) * do_pg_start_backup is the workhorse of the user-visible pg_start_backup() * function. It creates the necessary starting checkpoint and constructs the * backup label file. - * + * * There are two kind of backups: exclusive and non-exclusive. An exclusive * backup is started with pg_start_backup(), and there can be only one active * at a time. The backup label file of an exclusive backup is written to @@ -8826,7 +8829,7 @@ do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile) if (!superuser() && !is_authenticated_user_replication_role()) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), - errmsg("must be superuser or replication role to run a backup"))); + errmsg("must be superuser or replication role to run a backup"))); if (RecoveryInProgress()) ereport(ERROR, @@ -8897,25 +8900,27 @@ do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile) /* Ensure we release forcePageWrites if fail below */ PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive)); { - bool gotUniqueStartpoint = false; + bool gotUniqueStartpoint = false; + do { /* * Force a CHECKPOINT. Aside from being necessary to prevent torn - * page problems, this guarantees that two successive backup runs will - * have different checkpoint positions and hence different history - * file names, even if nothing happened in between. + * page problems, this guarantees that two successive backup runs + * will have different checkpoint positions and hence different + * history file names, even if nothing happened in between. * - * We use CHECKPOINT_IMMEDIATE only if requested by user (via passing - * fast = true). Otherwise this can take awhile. + * We use CHECKPOINT_IMMEDIATE only if requested by user (via + * passing fast = true). Otherwise this can take awhile. */ RequestCheckpoint(CHECKPOINT_FORCE | CHECKPOINT_WAIT | (fast ? CHECKPOINT_IMMEDIATE : 0)); /* - * Now we need to fetch the checkpoint record location, and also its - * REDO pointer. The oldest point in WAL that would be needed to - * restore starting from the checkpoint is precisely the REDO pointer. + * Now we need to fetch the checkpoint record location, and also + * its REDO pointer. The oldest point in WAL that would be needed + * to restore starting from the checkpoint is precisely the REDO + * pointer. */ LWLockAcquire(ControlFileLock, LW_SHARED); checkpointloc = ControlFile->checkPoint; @@ -8923,16 +8928,15 @@ do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile) LWLockRelease(ControlFileLock); /* - * If two base backups are started at the same time (in WAL - * sender processes), we need to make sure that they use - * different checkpoints as starting locations, because we use - * the starting WAL location as a unique identifier for the base - * backup in the end-of-backup WAL record and when we write the - * backup history file. Perhaps it would be better generate a - * separate unique ID for each backup instead of forcing another - * checkpoint, but taking a checkpoint right after another is - * not that expensive either because only few buffers have been - * dirtied yet. + * If two base backups are started at the same time (in WAL sender + * processes), we need to make sure that they use different + * checkpoints as starting locations, because we use the starting + * WAL location as a unique identifier for the base backup in the + * end-of-backup WAL record and when we write the backup history + * file. Perhaps it would be better generate a separate unique ID + * for each backup instead of forcing another checkpoint, but + * taking a checkpoint right after another is not that expensive + * either because only few buffers have been dirtied yet. */ LWLockAcquire(WALInsertLock, LW_SHARED); if (XLByteLT(XLogCtl->Insert.lastBackupStart, startpoint)) @@ -8941,13 +8945,13 @@ do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile) gotUniqueStartpoint = true; } LWLockRelease(WALInsertLock); - } while(!gotUniqueStartpoint); + } while (!gotUniqueStartpoint); XLByteToSeg(startpoint, _logId, _logSeg); XLogFileName(xlogfilename, ThisTimeLineID, _logId, _logSeg); /* - * Construct backup label file + * Construct backup label file */ initStringInfo(&labelfbuf); @@ -8970,8 +8974,8 @@ do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile) { /* * Check for existing backup label --- implies a backup is already - * running. (XXX given that we checked exclusiveBackup above, maybe - * it would be OK to just unlink any such label file?) + * running. (XXX given that we checked exclusiveBackup above, + * maybe it would be OK to just unlink any such label file?) */ if (stat(BACKUP_LABEL_FILE, &stat_buf) != 0) { @@ -9018,7 +9022,7 @@ do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile) static void pg_start_backup_callback(int code, Datum arg) { - bool exclusive = DatumGetBool(arg); + bool exclusive = DatumGetBool(arg); /* Update backup counters and forcePageWrites on failure */ LWLockAcquire(WALInsertLock, LW_EXCLUSIVE); @@ -9101,7 +9105,7 @@ do_pg_stop_backup(char *labelfile, bool waitforarchive) if (!superuser() && !is_authenticated_user_replication_role()) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), - (errmsg("must be superuser or replication role to run a backup")))); + (errmsg("must be superuser or replication role to run a backup")))); if (RecoveryInProgress()) ereport(ERROR, @@ -9145,8 +9149,8 @@ do_pg_stop_backup(char *labelfile, bool waitforarchive) /* * Read the existing label file into memory. */ - struct stat statbuf; - int r; + struct stat statbuf; + int r; if (stat(BACKUP_LABEL_FILE, &statbuf)) { @@ -9197,7 +9201,7 @@ do_pg_stop_backup(char *labelfile, bool waitforarchive) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("invalid data in file \"%s\"", BACKUP_LABEL_FILE))); - remaining = strchr(labelfile, '\n') + 1; /* %n is not portable enough */ + remaining = strchr(labelfile, '\n') + 1; /* %n is not portable enough */ /* * Write the backup-end xlog record @@ -9388,8 +9392,8 @@ pg_switch_xlog(PG_FUNCTION_ARGS) Datum pg_create_restore_point(PG_FUNCTION_ARGS) { - text *restore_name = PG_GETARG_TEXT_P(0); - char *restore_name_str; + text *restore_name = PG_GETARG_TEXT_P(0); + char *restore_name_str; XLogRecPtr restorepoint; char location[MAXFNAMELEN]; @@ -9407,7 +9411,7 @@ pg_create_restore_point(PG_FUNCTION_ARGS) if (!XLogIsNeeded()) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), - errmsg("WAL level not sufficient for creating a restore point"), + errmsg("WAL level not sufficient for creating a restore point"), errhint("wal_level must be set to \"archive\" or \"hot_standby\" at server start."))); restore_name_str = text_to_cstring(restore_name); @@ -9423,7 +9427,7 @@ pg_create_restore_point(PG_FUNCTION_ARGS) * As a convenience, return the WAL location of the restore point record */ snprintf(location, sizeof(location), "%X/%X", - restorepoint.xlogid, restorepoint.xrecoff); + restorepoint.xlogid, restorepoint.xrecoff); PG_RETURN_TEXT_P(cstring_to_text(location)); } @@ -10177,8 +10181,8 @@ retry: } /* - * If it hasn't been long since last attempt, sleep - * to avoid busy-waiting. + * If it hasn't been long since last attempt, sleep to + * avoid busy-waiting. */ now = (pg_time_t) time(NULL); if ((now - last_fail_time) < 5) @@ -10404,7 +10408,7 @@ static bool CheckForStandbyTrigger(void) { struct stat stat_buf; - static bool triggered = false; + static bool triggered = false; if (triggered) return true; @@ -10446,8 +10450,8 @@ CheckPromoteSignal(void) if (stat(PROMOTE_SIGNAL_FILE, &stat_buf) == 0) { /* - * Since we are in a signal handler, it's not safe - * to elog. We silently ignore any error from unlink. + * Since we are in a signal handler, it's not safe to elog. We + * silently ignore any error from unlink. */ unlink(PROMOTE_SIGNAL_FILE); return true; diff --git a/src/backend/catalog/aclchk.c b/src/backend/catalog/aclchk.c index aa3d59d4c9a..693b6343984 100644 --- a/src/backend/catalog/aclchk.c +++ b/src/backend/catalog/aclchk.c @@ -1011,8 +1011,8 @@ SetDefaultACLsInSchemas(InternalDefaultACL *iacls, List *nspnames) /* * Note that we must do the permissions check against the target - * role not the calling user. We require CREATE privileges, - * since without CREATE you won't be able to do anything using the + * role not the calling user. We require CREATE privileges, since + * without CREATE you won't be able to do anything using the * default privs anyway. */ iacls->nspid = get_namespace_oid(nspname, false); @@ -1707,7 +1707,7 @@ ExecGrant_Relation(InternalGrant *istmt) pg_class_tuple->relkind != RELKIND_FOREIGN_TABLE) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("\"%s\" is not a foreign table", + errmsg("\"%s\" is not a foreign table", NameStr(pg_class_tuple->relname)))); /* Adjust the default permissions based on object type */ @@ -1964,13 +1964,13 @@ ExecGrant_Relation(InternalGrant *istmt) this_privileges &= (AclMode) ACL_SELECT; } else if (pg_class_tuple->relkind == RELKIND_FOREIGN_TABLE && - this_privileges & ~((AclMode) ACL_SELECT)) + this_privileges & ~((AclMode) ACL_SELECT)) { /* Foreign tables have the same restriction as sequences. */ ereport(WARNING, - (errcode(ERRCODE_INVALID_GRANT_OPERATION), - errmsg("foreign table \"%s\" only supports SELECT column privileges", - NameStr(pg_class_tuple->relname)))); + (errcode(ERRCODE_INVALID_GRANT_OPERATION), + errmsg("foreign table \"%s\" only supports SELECT column privileges", + NameStr(pg_class_tuple->relname)))); this_privileges &= (AclMode) ACL_SELECT; } @@ -4768,7 +4768,7 @@ pg_extension_ownercheck(Oid ext_oid, Oid roleid) * Note: roles do not have owners per se; instead we use this test in * places where an ownership-like permissions test is needed for a role. * Be sure to apply it to the role trying to do the operation, not the - * role being operated on! Also note that this generally should not be + * role being operated on! Also note that this generally should not be * considered enough privilege if the target role is a superuser. * (We don't handle that consideration here because we want to give a * separate error message for such cases, so the caller has to deal with it.) diff --git a/src/backend/catalog/catalog.c b/src/backend/catalog/catalog.c index 12935754bc1..cbce0072de1 100644 --- a/src/backend/catalog/catalog.c +++ b/src/backend/catalog/catalog.c @@ -80,11 +80,11 @@ forkname_to_number(char *forkName) /* * forkname_chars - * We use this to figure out whether a filename could be a relation - * fork (as opposed to an oddly named stray file that somehow ended - * up in the database directory). If the passed string begins with - * a fork name (other than the main fork name), we return its length, - * and set *fork (if not NULL) to the fork number. If not, we return 0. + * We use this to figure out whether a filename could be a relation + * fork (as opposed to an oddly named stray file that somehow ended + * up in the database directory). If the passed string begins with + * a fork name (other than the main fork name), we return its length, + * and set *fork (if not NULL) to the fork number. If not, we return 0. * * Note that the present coding assumes that there are no fork names which * are prefixes of other fork names. @@ -96,7 +96,8 @@ forkname_chars(const char *str, ForkNumber *fork) for (forkNum = 1; forkNum <= MAX_FORKNUM; forkNum++) { - int len = strlen(forkNames[forkNum]); + int len = strlen(forkNames[forkNum]); + if (strncmp(forkNames[forkNum], str, len) == 0) { if (fork) @@ -150,7 +151,7 @@ relpathbackend(RelFileNode rnode, BackendId backend, ForkNumber forknum) { /* OIDCHARS will suffice for an integer, too */ pathlen = 5 + OIDCHARS + 2 + OIDCHARS + 1 + OIDCHARS + 1 - + FORKNAMECHARS + 1; + + FORKNAMECHARS + 1; path = (char *) palloc(pathlen); if (forknum != MAIN_FORKNUM) snprintf(path, pathlen, "base/%u/t%d_%u_%s", @@ -167,8 +168,8 @@ relpathbackend(RelFileNode rnode, BackendId backend, ForkNumber forknum) if (backend == InvalidBackendId) { pathlen = 9 + 1 + OIDCHARS + 1 - + strlen(TABLESPACE_VERSION_DIRECTORY) + 1 + OIDCHARS + 1 - + OIDCHARS + 1 + FORKNAMECHARS + 1; + + strlen(TABLESPACE_VERSION_DIRECTORY) + 1 + OIDCHARS + 1 + + OIDCHARS + 1 + FORKNAMECHARS + 1; path = (char *) palloc(pathlen); if (forknum != MAIN_FORKNUM) snprintf(path, pathlen, "pg_tblspc/%u/%s/%u/%u_%s", @@ -184,8 +185,8 @@ relpathbackend(RelFileNode rnode, BackendId backend, ForkNumber forknum) { /* OIDCHARS will suffice for an integer, too */ pathlen = 9 + 1 + OIDCHARS + 1 - + strlen(TABLESPACE_VERSION_DIRECTORY) + 1 + OIDCHARS + 2 - + OIDCHARS + 1 + OIDCHARS + 1 + FORKNAMECHARS + 1; + + strlen(TABLESPACE_VERSION_DIRECTORY) + 1 + OIDCHARS + 2 + + OIDCHARS + 1 + OIDCHARS + 1 + FORKNAMECHARS + 1; path = (char *) palloc(pathlen); if (forknum != MAIN_FORKNUM) snprintf(path, pathlen, "pg_tblspc/%u/%s/%u/t%d_%u_%s", diff --git a/src/backend/catalog/dependency.c b/src/backend/catalog/dependency.c index de24ef7a094..ec9bb48c638 100644 --- a/src/backend/catalog/dependency.c +++ b/src/backend/catalog/dependency.c @@ -160,7 +160,7 @@ static const Oid object_classes[MAX_OCLASS] = { ForeignServerRelationId, /* OCLASS_FOREIGN_SERVER */ UserMappingRelationId, /* OCLASS_USER_MAPPING */ DefaultAclRelationId, /* OCLASS_DEFACL */ - ExtensionRelationId /* OCLASS_EXTENSION */ + ExtensionRelationId /* OCLASS_EXTENSION */ }; @@ -1021,8 +1021,8 @@ deleteOneObject(const ObjectAddress *object, Relation depRel) /* * Delete any comments or security labels associated with this object. - * (This is a convenient place to do these things, rather than having every - * object type know to do it.) + * (This is a convenient place to do these things, rather than having + * every object type know to do it.) */ DeleteComments(object->objectId, object->classId, object->objectSubId); DeleteSecurityLabel(object); @@ -1263,7 +1263,7 @@ recordDependencyOnExpr(const ObjectAddress *depender, * whereas 'behavior' is used for everything else. * * NOTE: the caller should ensure that a whole-table dependency on the - * specified relation is created separately, if one is needed. In particular, + * specified relation is created separately, if one is needed. In particular, * a whole-row Var "relation.*" will not cause this routine to emit any * dependency item. This is appropriate behavior for subexpressions of an * ordinary query, so other cases need to cope as necessary. @@ -1383,7 +1383,7 @@ find_expr_references_walker(Node *node, /* * A whole-row Var references no specific columns, so adds no new - * dependency. (We assume that there is a whole-table dependency + * dependency. (We assume that there is a whole-table dependency * arising from each underlying rangetable entry. While we could * record such a dependency when finding a whole-row Var that * references a relation directly, it's quite unclear how to extend @@ -1431,8 +1431,8 @@ find_expr_references_walker(Node *node, /* * We must also depend on the constant's collation: it could be - * different from the datatype's, if a CollateExpr was const-folded - * to a simple constant. However we can save work in the most common + * different from the datatype's, if a CollateExpr was const-folded to + * a simple constant. However we can save work in the most common * case where the collation is "default", since we know that's pinned. */ if (OidIsValid(con->constcollid) && @@ -1695,7 +1695,7 @@ find_expr_references_walker(Node *node, } foreach(ct, rte->funccolcollations) { - Oid collid = lfirst_oid(ct); + Oid collid = lfirst_oid(ct); if (OidIsValid(collid) && collid != DEFAULT_COLLATION_OID) @@ -2224,12 +2224,12 @@ getObjectDescription(const ObjectAddress *object) HeapTuple collTup; collTup = SearchSysCache1(COLLOID, - ObjectIdGetDatum(object->objectId)); + ObjectIdGetDatum(object->objectId)); if (!HeapTupleIsValid(collTup)) elog(ERROR, "cache lookup failed for collation %u", object->objectId); appendStringInfo(&buffer, _("collation %s"), - NameStr(((Form_pg_collation) GETSTRUCT(collTup))->collname)); + NameStr(((Form_pg_collation) GETSTRUCT(collTup))->collname)); ReleaseSysCache(collTup); break; } @@ -2796,7 +2796,7 @@ getObjectDescription(const ObjectAddress *object) char * getObjectDescriptionOids(Oid classid, Oid objid) { - ObjectAddress address; + ObjectAddress address; address.classId = classid; address.objectId = objid; diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c index 5d25ce9ec88..09b26a5c724 100644 --- a/src/backend/catalog/heap.c +++ b/src/backend/catalog/heap.c @@ -431,7 +431,7 @@ CheckAttributeNamesTypes(TupleDesc tupdesc, char relkind, CheckAttributeType(NameStr(tupdesc->attrs[i]->attname), tupdesc->attrs[i]->atttypid, tupdesc->attrs[i]->attcollation, - NIL, /* assume we're creating a new rowtype */ + NIL, /* assume we're creating a new rowtype */ allow_system_table_mods); } } @@ -497,7 +497,7 @@ CheckAttributeType(const char *attname, int i; /* - * Check for self-containment. Eventually we might be able to allow + * Check for self-containment. Eventually we might be able to allow * this (just return without complaint, if so) but it's not clear how * many other places would require anti-recursion defenses before it * would be safe to allow tables to contain their own rowtype. @@ -505,8 +505,8 @@ CheckAttributeType(const char *attname, if (list_member_oid(containing_rowtypes, atttypid)) ereport(ERROR, (errcode(ERRCODE_INVALID_TABLE_DEFINITION), - errmsg("composite type %s cannot be made a member of itself", - format_type_be(atttypid)))); + errmsg("composite type %s cannot be made a member of itself", + format_type_be(atttypid)))); containing_rowtypes = lcons_oid(atttypid, containing_rowtypes); @@ -541,15 +541,15 @@ CheckAttributeType(const char *attname, } /* - * This might not be strictly invalid per SQL standard, but it is - * pretty useless, and it cannot be dumped, so we must disallow it. + * This might not be strictly invalid per SQL standard, but it is pretty + * useless, and it cannot be dumped, so we must disallow it. */ if (!OidIsValid(attcollation) && type_is_collatable(atttypid)) - ereport(ERROR, - (errcode(ERRCODE_INVALID_TABLE_DEFINITION), - errmsg("no collation was derived for column \"%s\" with collatable type %s", - attname, format_type_be(atttypid)), - errhint("Use the COLLATE clause to set the collation explicitly."))); + ereport(ERROR, + (errcode(ERRCODE_INVALID_TABLE_DEFINITION), + errmsg("no collation was derived for column \"%s\" with collatable type %s", + attname, format_type_be(atttypid)), + errhint("Use the COLLATE clause to set the collation explicitly."))); } /* @@ -921,7 +921,7 @@ AddNewRelationType(const char *typeName, -1, /* typmod */ 0, /* array dimensions for typBaseType */ false, /* Type NOT NULL */ - InvalidOid); /* typcollation */ + InvalidOid); /* typcollation */ } /* -------------------------------- @@ -992,9 +992,9 @@ heap_create_with_catalog(const char *relname, CheckAttributeNamesTypes(tupdesc, relkind, allow_system_table_mods); /* - * If the relation already exists, it's an error, unless the user specifies - * "IF NOT EXISTS". In that case, we just print a notice and do nothing - * further. + * If the relation already exists, it's an error, unless the user + * specifies "IF NOT EXISTS". In that case, we just print a notice and do + * nothing further. */ existing_relid = get_relname_relid(relname, relnamespace); if (existing_relid != InvalidOid) @@ -1004,7 +1004,7 @@ heap_create_with_catalog(const char *relname, ereport(NOTICE, (errcode(ERRCODE_DUPLICATE_TABLE), errmsg("relation \"%s\" already exists, skipping", - relname))); + relname))); heap_close(pg_class_desc, RowExclusiveLock); return InvalidOid; } @@ -1048,8 +1048,8 @@ heap_create_with_catalog(const char *relname, if (!OidIsValid(relid)) { /* - * Use binary-upgrade override for pg_class.oid/relfilenode, - * if supplied. + * Use binary-upgrade override for pg_class.oid/relfilenode, if + * supplied. */ if (OidIsValid(binary_upgrade_next_heap_pg_class_oid) && (relkind == RELKIND_RELATION || relkind == RELKIND_SEQUENCE || @@ -1183,7 +1183,7 @@ heap_create_with_catalog(const char *relname, -1, /* typmod */ 0, /* array dimensions for typBaseType */ false, /* Type NOT NULL */ - InvalidOid); /* typcollation */ + InvalidOid); /* typcollation */ pfree(relarrayname); } @@ -1285,12 +1285,12 @@ heap_create_with_catalog(const char *relname, register_on_commit_action(relid, oncommit); /* - * If this is an unlogged relation, it needs an init fork so that it - * can be correctly reinitialized on restart. Since we're going to - * do an immediate sync, we ony need to xlog this if archiving or - * streaming is enabled. And the immediate sync is required, because - * otherwise there's no guarantee that this will hit the disk before - * the next checkpoint moves the redo pointer. + * If this is an unlogged relation, it needs an init fork so that it can + * be correctly reinitialized on restart. Since we're going to do an + * immediate sync, we ony need to xlog this if archiving or streaming is + * enabled. And the immediate sync is required, because otherwise there's + * no guarantee that this will hit the disk before the next checkpoint + * moves the redo pointer. */ if (relpersistence == RELPERSISTENCE_UNLOGGED) { @@ -1654,8 +1654,8 @@ heap_drop_with_catalog(Oid relid) /* * There can no longer be anyone *else* touching the relation, but we - * might still have open queries or cursors, or pending trigger events, - * in our own session. + * might still have open queries or cursors, or pending trigger events, in + * our own session. */ CheckTableNotInUse(rel, "DROP TABLE"); @@ -1664,8 +1664,8 @@ heap_drop_with_catalog(Oid relid) */ if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE) { - Relation rel; - HeapTuple tuple; + Relation rel; + HeapTuple tuple; rel = heap_open(ForeignTableRelationId, RowExclusiveLock); @@ -1899,7 +1899,7 @@ StoreRelCheck(Relation rel, char *ccname, Node *expr, CONSTRAINT_CHECK, /* Constraint Type */ false, /* Is Deferrable */ false, /* Is Deferred */ - true, /* Is Validated */ + true, /* Is Validated */ RelationGetRelid(rel), /* relation */ attNos, /* attrs in the constraint */ keycount, /* # attrs in the constraint */ diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c index 679255a199b..1bf74b3d4fa 100644 --- a/src/backend/catalog/index.c +++ b/src/backend/catalog/index.c @@ -187,18 +187,18 @@ index_check_primary_key(Relation heapRel, int i; /* - * If ALTER TABLE, check that there isn't already a PRIMARY KEY. In - * CREATE TABLE, we have faith that the parser rejected multiple pkey - * clauses; and CREATE INDEX doesn't have a way to say PRIMARY KEY, so - * it's no problem either. + * If ALTER TABLE, check that there isn't already a PRIMARY KEY. In CREATE + * TABLE, we have faith that the parser rejected multiple pkey clauses; + * and CREATE INDEX doesn't have a way to say PRIMARY KEY, so it's no + * problem either. */ if (is_alter_table && relationHasPrimaryKey(heapRel)) { ereport(ERROR, (errcode(ERRCODE_INVALID_TABLE_DEFINITION), - errmsg("multiple primary keys for table \"%s\" are not allowed", - RelationGetRelationName(heapRel)))); + errmsg("multiple primary keys for table \"%s\" are not allowed", + RelationGetRelationName(heapRel)))); } /* @@ -222,7 +222,7 @@ index_check_primary_key(Relation heapRel, continue; atttuple = SearchSysCache2(ATTNUM, - ObjectIdGetDatum(RelationGetRelid(heapRel)), + ObjectIdGetDatum(RelationGetRelid(heapRel)), Int16GetDatum(attnum)); if (!HeapTupleIsValid(atttuple)) elog(ERROR, "cache lookup failed for attribute %d of relation %u", @@ -243,15 +243,14 @@ index_check_primary_key(Relation heapRel, } /* - * XXX: Shouldn't the ALTER TABLE .. SET NOT NULL cascade to child - * tables? Currently, since the PRIMARY KEY itself doesn't cascade, - * we don't cascade the notnull constraint(s) either; but this is - * pretty debatable. + * XXX: Shouldn't the ALTER TABLE .. SET NOT NULL cascade to child tables? + * Currently, since the PRIMARY KEY itself doesn't cascade, we don't + * cascade the notnull constraint(s) either; but this is pretty debatable. * - * XXX: possible future improvement: when being called from ALTER - * TABLE, it would be more efficient to merge this with the outer - * ALTER TABLE, so as to avoid two scans. But that seems to - * complicate DefineIndex's API unduly. + * XXX: possible future improvement: when being called from ALTER TABLE, + * it would be more efficient to merge this with the outer ALTER TABLE, so + * as to avoid two scans. But that seems to complicate DefineIndex's API + * unduly. */ if (cmds) AlterTableInternal(RelationGetRelid(heapRel), cmds, false); @@ -788,8 +787,8 @@ index_create(Relation heapRelation, if (!OidIsValid(indexRelationId)) { /* - * Use binary-upgrade override for pg_class.oid/relfilenode, - * if supplied. + * Use binary-upgrade override for pg_class.oid/relfilenode, if + * supplied. */ if (OidIsValid(binary_upgrade_next_index_pg_class_oid)) { @@ -872,7 +871,7 @@ index_create(Relation heapRelation, * ---------------- */ UpdateIndexRelation(indexRelationId, heapRelationId, indexInfo, - collationObjectId, classObjectId, coloptions, isprimary, is_exclusion, + collationObjectId, classObjectId, coloptions, isprimary, is_exclusion, !deferrable, !concurrent); @@ -947,7 +946,7 @@ index_create(Relation heapRelation, /* * If there are no simply-referenced columns, give the index an - * auto dependency on the whole table. In most cases, this will + * auto dependency on the whole table. In most cases, this will * be redundant, but it might not be if the index expressions and * predicate contain no Vars or only whole-row Vars. */ @@ -1067,7 +1066,7 @@ index_create(Relation heapRelation, /* * Close the index; but we keep the lock that we acquired above until end - * of transaction. Closing the heap is caller's responsibility. + * of transaction. Closing the heap is caller's responsibility. */ index_close(indexRelation, NoLock); @@ -1176,8 +1175,8 @@ index_constraint_create(Relation heapRelation, /* * If the constraint is deferrable, create the deferred uniqueness - * checking trigger. (The trigger will be given an internal - * dependency on the constraint by CreateTrigger.) + * checking trigger. (The trigger will be given an internal dependency on + * the constraint by CreateTrigger.) */ if (deferrable) { @@ -1213,7 +1212,7 @@ index_constraint_create(Relation heapRelation, * have been so marked already, so no need to clear the flag in the other * case. * - * Note: this might better be done by callers. We do it here to avoid + * Note: this might better be done by callers. We do it here to avoid * exposing index_update_stats() globally, but that wouldn't be necessary * if relhaspkey went away. */ @@ -1235,10 +1234,10 @@ index_constraint_create(Relation heapRelation, */ if (update_pgindex && (mark_as_primary || deferrable)) { - Relation pg_index; - HeapTuple indexTuple; - Form_pg_index indexForm; - bool dirty = false; + Relation pg_index; + HeapTuple indexTuple; + Form_pg_index indexForm; + bool dirty = false; pg_index = heap_open(IndexRelationId, RowExclusiveLock); @@ -1303,8 +1302,8 @@ index_drop(Oid indexId) userIndexRelation = index_open(indexId, AccessExclusiveLock); /* - * There can no longer be anyone *else* touching the index, but we - * might still have open queries using it in our own session. + * There can no longer be anyone *else* touching the index, but we might + * still have open queries using it in our own session. */ CheckTableNotInUse(userIndexRelation, "DROP INDEX"); @@ -1739,7 +1738,8 @@ index_build(Relation heapRelation, */ if (heapRelation->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED) { - RegProcedure ambuildempty = indexRelation->rd_am->ambuildempty; + RegProcedure ambuildempty = indexRelation->rd_am->ambuildempty; + RelationOpenSmgr(indexRelation); smgrcreate(indexRelation->rd_smgr, INIT_FORKNUM, false); OidFunctionCall1(ambuildempty, PointerGetDatum(indexRelation)); @@ -2410,7 +2410,7 @@ validate_index(Oid heapId, Oid indexId, Snapshot snapshot) ivinfo.strategy = NULL; state.tuplesort = tuplesort_begin_datum(TIDOID, - TIDLessOperator, InvalidOid, false, + TIDLessOperator, InvalidOid, false, maintenance_work_mem, false); state.htups = state.itups = state.tups_inserted = 0; @@ -2834,7 +2834,7 @@ reindex_index(Oid indexId, bool skip_constraint_checks) * use catalog indexes while collecting the list.) * * To avoid deadlocks, VACUUM FULL or CLUSTER on a system catalog must omit the - * REINDEX_CHECK_CONSTRAINTS flag. REINDEX should be used to rebuild an index + * REINDEX_CHECK_CONSTRAINTS flag. REINDEX should be used to rebuild an index * if constraint inconsistency is suspected. For optimal performance, other * callers should include the flag only after transforming the data in a manner * that risks a change in constraint validity. diff --git a/src/backend/catalog/namespace.c b/src/backend/catalog/namespace.c index 734581e4855..f8fd8276936 100644 --- a/src/backend/catalog/namespace.c +++ b/src/backend/catalog/namespace.c @@ -2446,10 +2446,10 @@ CheckSetNamespace(Oid oldNspOid, Oid nspOid, Oid classid, Oid objid) if (oldNspOid == nspOid) ereport(ERROR, (classid == RelationRelationId ? - errcode(ERRCODE_DUPLICATE_TABLE) : + errcode(ERRCODE_DUPLICATE_TABLE) : classid == ProcedureRelationId ? - errcode(ERRCODE_DUPLICATE_FUNCTION) : - errcode(ERRCODE_DUPLICATE_OBJECT), + errcode(ERRCODE_DUPLICATE_FUNCTION) : + errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("%s is already in schema \"%s\"", getObjectDescriptionOids(classid, objid), get_namespace_name(nspOid)))); @@ -2458,7 +2458,7 @@ CheckSetNamespace(Oid oldNspOid, Oid nspOid, Oid classid, Oid objid) if (isAnyTempNamespace(nspOid) || isAnyTempNamespace(oldNspOid)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("cannot move objects into or out of temporary schemas"))); + errmsg("cannot move objects into or out of temporary schemas"))); /* same for TOAST schema */ if (nspOid == PG_TOAST_NAMESPACE || oldNspOid == PG_TOAST_NAMESPACE) @@ -2525,7 +2525,7 @@ QualifiedNameGetCreationNamespace(List *names, char **objname_p) /* * get_namespace_oid - given a namespace name, look up the OID * - * If missing_ok is false, throw an error if namespace name not found. If + * If missing_ok is false, throw an error if namespace name not found. If * true, just return InvalidOid. */ Oid @@ -2535,9 +2535,9 @@ get_namespace_oid(const char *nspname, bool missing_ok) oid = GetSysCacheOid1(NAMESPACENAME, CStringGetDatum(nspname)); if (!OidIsValid(oid) && !missing_ok) - ereport(ERROR, - (errcode(ERRCODE_UNDEFINED_SCHEMA), - errmsg("schema \"%s\" does not exist", nspname))); + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_SCHEMA), + errmsg("schema \"%s\" does not exist", nspname))); return oid; } @@ -2727,7 +2727,7 @@ GetTempNamespaceBackendId(Oid namespaceId) /* See if the namespace name starts with "pg_temp_" or "pg_toast_temp_" */ nspname = get_namespace_name(namespaceId); if (!nspname) - return InvalidBackendId; /* no such namespace? */ + return InvalidBackendId; /* no such namespace? */ if (strncmp(nspname, "pg_temp_", 8) == 0) result = atoi(nspname + 8); else if (strncmp(nspname, "pg_toast_temp_", 14) == 0) @@ -2798,8 +2798,8 @@ GetOverrideSearchPath(MemoryContext context) * * It's possible that newpath->useTemp is set but there is no longer any * active temp namespace, if the path was saved during a transaction that - * created a temp namespace and was later rolled back. In that case we just - * ignore useTemp. A plausible alternative would be to create a new temp + * created a temp namespace and was later rolled back. In that case we just + * ignore useTemp. A plausible alternative would be to create a new temp * namespace, but for existing callers that's not necessary because an empty * temp namespace wouldn't affect their results anyway. * @@ -3522,7 +3522,7 @@ check_search_path(char **newval, void **extra, GucSource source) if (source == PGC_S_TEST) ereport(NOTICE, (errcode(ERRCODE_UNDEFINED_SCHEMA), - errmsg("schema \"%s\" does not exist", curname))); + errmsg("schema \"%s\" does not exist", curname))); else { GUC_check_errdetail("schema \"%s\" does not exist", curname); diff --git a/src/backend/catalog/objectaddress.c b/src/backend/catalog/objectaddress.c index 0d21d310a65..bf25091582f 100644 --- a/src/backend/catalog/objectaddress.c +++ b/src/backend/catalog/objectaddress.c @@ -78,7 +78,7 @@ static Relation get_relation_by_qualified_name(ObjectType objtype, static ObjectAddress get_object_address_relobject(ObjectType objtype, List *objname, Relation *relp); static ObjectAddress get_object_address_attribute(ObjectType objtype, - List *objname, Relation *relp, LOCKMODE lockmode); + List *objname, Relation *relp, LOCKMODE lockmode); static ObjectAddress get_object_address_opcf(ObjectType objtype, List *objname, List *objargs); static bool object_exists(ObjectAddress address); @@ -108,8 +108,8 @@ ObjectAddress get_object_address(ObjectType objtype, List *objname, List *objargs, Relation *relp, LOCKMODE lockmode) { - ObjectAddress address; - Relation relation = NULL; + ObjectAddress address; + Relation relation = NULL; /* Some kind of lock must be taken. */ Assert(lockmode != NoLock); @@ -130,7 +130,7 @@ get_object_address(ObjectType objtype, List *objname, List *objargs, case OBJECT_COLUMN: address = get_object_address_attribute(objtype, objname, &relation, - lockmode); + lockmode); break; case OBJECT_RULE: case OBJECT_TRIGGER: @@ -201,10 +201,10 @@ get_object_address(ObjectType objtype, List *objname, List *objargs, break; case OBJECT_CAST: { - TypeName *sourcetype = (TypeName *) linitial(objname); - TypeName *targettype = (TypeName *) linitial(objargs); - Oid sourcetypeid = typenameTypeId(NULL, sourcetype); - Oid targettypeid = typenameTypeId(NULL, targettype); + TypeName *sourcetype = (TypeName *) linitial(objname); + TypeName *targettype = (TypeName *) linitial(objargs); + Oid sourcetypeid = typenameTypeId(NULL, sourcetype); + Oid targettypeid = typenameTypeId(NULL, targettype); address.classId = CastRelationId; address.objectId = @@ -242,8 +242,8 @@ get_object_address(ObjectType objtype, List *objname, List *objargs, /* * If we're dealing with a relation or attribute, then the relation is - * already locked. If we're dealing with any other type of object, we need - * to lock it and then verify that it still exists. + * already locked. If we're dealing with any other type of object, we + * need to lock it and then verify that it still exists. */ if (address.classId != RelationRelationId) { @@ -308,7 +308,7 @@ get_object_address_unqualified(ObjectType objtype, List *qualname) break; default: elog(ERROR, "unrecognized objtype: %d", (int) objtype); - msg = NULL; /* placate compiler */ + msg = NULL; /* placate compiler */ } ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), @@ -379,7 +379,7 @@ static Relation get_relation_by_qualified_name(ObjectType objtype, List *objname, LOCKMODE lockmode) { - Relation relation; + Relation relation; relation = relation_openrv(makeRangeVarFromNameList(objname), lockmode); switch (objtype) @@ -449,7 +449,7 @@ get_object_address_relobject(ObjectType objtype, List *objname, Relation *relp) nnames = list_length(objname); if (nnames < 2) { - Oid reloid; + Oid reloid; /* * For compatibility with very old releases, we sometimes allow users @@ -514,7 +514,7 @@ static ObjectAddress get_object_address_attribute(ObjectType objtype, List *objname, Relation *relp, LOCKMODE lockmode) { - ObjectAddress address; + ObjectAddress address; List *relname; Oid reloid; Relation relation; @@ -534,7 +534,7 @@ get_object_address_attribute(ObjectType objtype, List *objname, ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("column \"%s\" of relation \"%s\" does not exist", - attname, RelationGetRelationName(relation)))); + attname, RelationGetRelationName(relation)))); *relp = relation; return address; @@ -584,8 +584,8 @@ object_exists(ObjectAddress address) int cache = -1; Oid indexoid = InvalidOid; Relation rel; - ScanKeyData skey[1]; - SysScanDesc sd; + ScanKeyData skey[1]; + SysScanDesc sd; bool found; /* Sub-objects require special treatment. */ @@ -609,9 +609,9 @@ object_exists(ObjectAddress address) /* * For object types that have a relevant syscache, we use it; for - * everything else, we'll have to do an index-scan. This switch - * sets either the cache to be used for the syscache lookup, or the - * index to be used for the index scan. + * everything else, we'll have to do an index-scan. This switch sets + * either the cache to be used for the syscache lookup, or the index to be + * used for the index scan. */ switch (address.classId) { @@ -664,6 +664,7 @@ object_exists(ObjectAddress address) cache = OPFAMILYOID; break; case LargeObjectRelationId: + /* * Weird backward compatibility hack: ObjectAddress notation uses * LargeObjectRelationId for large objects, but since PostgreSQL @@ -816,15 +817,15 @@ check_object_ownership(Oid roleid, ObjectType objtype, ObjectAddress address, ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("must be owner of large object %u", - address.objectId))); + address.objectId))); break; case OBJECT_CAST: { /* We can only check permissions on the source/target types */ - TypeName *sourcetype = (TypeName *) linitial(objname); - TypeName *targettype = (TypeName *) linitial(objargs); - Oid sourcetypeid = typenameTypeId(NULL, sourcetype); - Oid targettypeid = typenameTypeId(NULL, targettype); + TypeName *sourcetype = (TypeName *) linitial(objname); + TypeName *targettype = (TypeName *) linitial(objargs); + Oid sourcetypeid = typenameTypeId(NULL, sourcetype); + Oid targettypeid = typenameTypeId(NULL, targettype); if (!pg_type_ownercheck(sourcetypeid, roleid) && !pg_type_ownercheck(targettypeid, roleid)) @@ -851,6 +852,7 @@ check_object_ownership(Oid roleid, ObjectType objtype, ObjectAddress address, NameListToString(objname)); break; case OBJECT_ROLE: + /* * We treat roles as being "owned" by those with CREATEROLE priv, * except that superusers are only owned by superusers. diff --git a/src/backend/catalog/pg_collation.c b/src/backend/catalog/pg_collation.c index 708078463ba..5b92a4c0c28 100644 --- a/src/backend/catalog/pg_collation.c +++ b/src/backend/catalog/pg_collation.c @@ -46,7 +46,9 @@ CollationCreate(const char *collname, Oid collnamespace, HeapTuple tup; Datum values[Natts_pg_collation]; bool nulls[Natts_pg_collation]; - NameData name_name, name_collate, name_ctype; + NameData name_name, + name_collate, + name_ctype; Oid oid; ObjectAddress myself, referenced; @@ -60,9 +62,9 @@ CollationCreate(const char *collname, Oid collnamespace, /* * Make sure there is no existing collation of same name & encoding. * - * This would be caught by the unique index anyway; we're just giving - * a friendlier error message. The unique index provides a backstop - * against race conditions. + * This would be caught by the unique index anyway; we're just giving a + * friendlier error message. The unique index provides a backstop against + * race conditions. */ if (SearchSysCacheExists3(COLLNAMEENCNSP, PointerGetDatum(collname), @@ -74,9 +76,9 @@ CollationCreate(const char *collname, Oid collnamespace, collname, pg_encoding_to_char(collencoding)))); /* - * Also forbid matching an any-encoding entry. This test of course is - * not backed up by the unique index, but it's not a problem since we - * don't support adding any-encoding entries after initdb. + * Also forbid matching an any-encoding entry. This test of course is not + * backed up by the unique index, but it's not a problem since we don't + * support adding any-encoding entries after initdb. */ if (SearchSysCacheExists3(COLLNAMEENCNSP, PointerGetDatum(collname), diff --git a/src/backend/catalog/pg_constraint.c b/src/backend/catalog/pg_constraint.c index 6619eed431c..69979942af4 100644 --- a/src/backend/catalog/pg_constraint.c +++ b/src/backend/catalog/pg_constraint.c @@ -799,10 +799,10 @@ get_constraint_oid(Oid relid, const char *conname, bool missing_ok) * the rel of interest are Vars with the indicated varno/varlevelsup. * * Currently we only check to see if the rel has a primary key that is a - * subset of the grouping_columns. We could also use plain unique constraints + * subset of the grouping_columns. We could also use plain unique constraints * if all their columns are known not null, but there's a problem: we need * to be able to represent the not-null-ness as part of the constraints added - * to *constraintDeps. FIXME whenever not-null constraints get represented + * to *constraintDeps. FIXME whenever not-null constraints get represented * in pg_constraint. */ bool @@ -852,7 +852,7 @@ check_functional_grouping(Oid relid, if (isNull) elog(ERROR, "null conkey for constraint %u", HeapTupleGetOid(tuple)); - arr = DatumGetArrayTypeP(adatum); /* ensure not toasted */ + arr = DatumGetArrayTypeP(adatum); /* ensure not toasted */ numkeys = ARR_DIMS(arr)[0]; if (ARR_NDIM(arr) != 1 || numkeys < 0 || diff --git a/src/backend/catalog/pg_depend.c b/src/backend/catalog/pg_depend.c index 2bb7bb3d5fa..67aad86d4e7 100644 --- a/src/backend/catalog/pg_depend.c +++ b/src/backend/catalog/pg_depend.c @@ -126,7 +126,7 @@ recordMultipleDependencies(const ObjectAddress *depender, /* * If we are executing a CREATE EXTENSION operation, mark the given object - * as being a member of the extension. Otherwise, do nothing. + * as being a member of the extension. Otherwise, do nothing. * * This must be called during creation of any user-definable object type * that could be a member of an extension. @@ -136,7 +136,7 @@ recordDependencyOnCurrentExtension(const ObjectAddress *object) { if (creating_extension) { - ObjectAddress extension; + ObjectAddress extension; extension.classId = ExtensionRelationId; extension.objectId = CurrentExtensionObject; @@ -155,7 +155,7 @@ recordDependencyOnCurrentExtension(const ObjectAddress *object) * (possibly with some differences from before). * * If skipExtensionDeps is true, we do not delete any dependencies that - * show that the given object is a member of an extension. This avoids + * show that the given object is a member of an extension. This avoids * needing a lot of extra logic to fetch and recreate that dependency. */ long @@ -185,7 +185,7 @@ deleteDependencyRecordsFor(Oid classId, Oid objectId, while (HeapTupleIsValid(tup = systable_getnext(scan))) { if (skipExtensionDeps && - ((Form_pg_depend) GETSTRUCT(tup))->deptype == DEPENDENCY_EXTENSION) + ((Form_pg_depend) GETSTRUCT(tup))->deptype == DEPENDENCY_EXTENSION) continue; simple_heap_delete(depRel, &tup->t_self); diff --git a/src/backend/catalog/pg_enum.c b/src/backend/catalog/pg_enum.c index e87a9311bdd..08d8aa13f33 100644 --- a/src/backend/catalog/pg_enum.c +++ b/src/backend/catalog/pg_enum.c @@ -29,7 +29,7 @@ /* Potentially set by contrib/pg_upgrade_support functions */ -Oid binary_upgrade_next_pg_enum_oid = InvalidOid; +Oid binary_upgrade_next_pg_enum_oid = InvalidOid; static void RenumberEnumType(Relation pg_enum, HeapTuple *existing, int nelems); static int oid_cmp(const void *p1, const void *p2); @@ -58,9 +58,9 @@ EnumValuesCreate(Oid enumTypeOid, List *vals) num_elems = list_length(vals); /* - * We do not bother to check the list of values for duplicates --- if - * you have any, you'll get a less-than-friendly unique-index violation. - * It is probably not worth trying harder. + * We do not bother to check the list of values for duplicates --- if you + * have any, you'll get a less-than-friendly unique-index violation. It is + * probably not worth trying harder. */ pg_enum = heap_open(EnumRelationId, RowExclusiveLock); @@ -69,10 +69,9 @@ EnumValuesCreate(Oid enumTypeOid, List *vals) * Allocate OIDs for the enum's members. * * While this method does not absolutely guarantee that we generate no - * duplicate OIDs (since we haven't entered each oid into the table - * before allocating the next), trouble could only occur if the OID - * counter wraps all the way around before we finish. Which seems - * unlikely. + * duplicate OIDs (since we haven't entered each oid into the table before + * allocating the next), trouble could only occur if the OID counter wraps + * all the way around before we finish. Which seems unlikely. */ oids = (Oid *) palloc(num_elems * sizeof(Oid)); @@ -83,9 +82,10 @@ EnumValuesCreate(Oid enumTypeOid, List *vals) * tells the comparison functions the OIDs are in the correct sort * order and can be compared directly. */ - Oid new_oid; + Oid new_oid; - do { + do + { new_oid = GetNewOid(pg_enum); } while (new_oid & 1); oids[elemno] = new_oid; @@ -202,9 +202,9 @@ AddEnumLabel(Oid enumTypeOid, /* * Acquire a lock on the enum type, which we won't release until commit. * This ensures that two backends aren't concurrently modifying the same - * enum type. Without that, we couldn't be sure to get a consistent - * view of the enum members via the syscache. Note that this does not - * block other backends from inspecting the type; see comments for + * enum type. Without that, we couldn't be sure to get a consistent view + * of the enum members via the syscache. Note that this does not block + * other backends from inspecting the type; see comments for * RenumberEnumType. */ LockDatabaseObject(TypeRelationId, enumTypeOid, 0, ExclusiveLock); @@ -217,7 +217,7 @@ restart: /* Get the list of existing members of the enum */ list = SearchSysCacheList1(ENUMTYPOIDNAME, ObjectIdGetDatum(enumTypeOid)); - nelems = list->n_members; + nelems = list->n_members; /* Sort the existing members by enumsortorder */ existing = (HeapTuple *) palloc(nelems * sizeof(HeapTuple)); @@ -229,8 +229,8 @@ restart: if (neighbor == NULL) { /* - * Put the new label at the end of the list. - * No change to existing tuples is required. + * Put the new label at the end of the list. No change to existing + * tuples is required. */ if (nelems > 0) { @@ -244,10 +244,10 @@ restart: else { /* BEFORE or AFTER was specified */ - int nbr_index; - int other_nbr_index; - Form_pg_enum nbr_en; - Form_pg_enum other_nbr_en; + int nbr_index; + int other_nbr_index; + Form_pg_enum nbr_en; + Form_pg_enum other_nbr_en; /* Locate the neighbor element */ for (nbr_index = 0; nbr_index < nelems; nbr_index++) @@ -265,14 +265,14 @@ restart: nbr_en = (Form_pg_enum) GETSTRUCT(existing[nbr_index]); /* - * Attempt to assign an appropriate enumsortorder value: one less - * than the smallest member, one more than the largest member, - * or halfway between two existing members. + * Attempt to assign an appropriate enumsortorder value: one less than + * the smallest member, one more than the largest member, or halfway + * between two existing members. * * In the "halfway" case, because of the finite precision of float4, - * we might compute a value that's actually equal to one or the - * other of its neighbors. In that case we renumber the existing - * members and try again. + * we might compute a value that's actually equal to one or the other + * of its neighbors. In that case we renumber the existing members + * and try again. */ if (newValIsAfter) other_nbr_index = nbr_index + 1; @@ -291,10 +291,10 @@ restart: /* * On some machines, newelemorder may be in a register that's - * wider than float4. We need to force it to be rounded to - * float4 precision before making the following comparisons, - * or we'll get wrong results. (Such behavior violates the C - * standard, but fixing the compilers is out of our reach.) + * wider than float4. We need to force it to be rounded to float4 + * precision before making the following comparisons, or we'll get + * wrong results. (Such behavior violates the C standard, but + * fixing the compilers is out of our reach.) */ newelemorder = DatumGetFloat4(Float4GetDatum(newelemorder)); @@ -314,9 +314,9 @@ restart: if (OidIsValid(binary_upgrade_next_pg_enum_oid)) { /* - * Use binary-upgrade override for pg_enum.oid, if supplied. - * During binary upgrade, all pg_enum.oid's are set this way - * so they are guaranteed to be consistent. + * Use binary-upgrade override for pg_enum.oid, if supplied. During + * binary upgrade, all pg_enum.oid's are set this way so they are + * guaranteed to be consistent. */ if (neighbor != NULL) ereport(ERROR, @@ -337,7 +337,7 @@ restart: */ for (;;) { - bool sorts_ok; + bool sorts_ok; /* Get a new OID (different from all existing pg_enum tuples) */ newOid = GetNewOid(pg_enum); @@ -345,8 +345,8 @@ restart: /* * Detect whether it sorts correctly relative to existing * even-numbered labels of the enum. We can ignore existing - * labels with odd Oids, since a comparison involving one of - * those will not take the fast path anyway. + * labels with odd Oids, since a comparison involving one of those + * will not take the fast path anyway. */ sorts_ok = true; for (i = 0; i < nelems; i++) @@ -385,9 +385,9 @@ restart: break; /* - * If it's odd, and sorts OK, loop back to get another OID - * and try again. Probably, the next available even OID - * will sort correctly too, so it's worth trying. + * If it's odd, and sorts OK, loop back to get another OID and + * try again. Probably, the next available even OID will sort + * correctly too, so it's worth trying. */ } else @@ -435,7 +435,7 @@ restart: * We avoid doing this unless absolutely necessary; in most installations * it will never happen. The reason is that updating existing pg_enum * entries creates hazards for other backends that are concurrently reading - * pg_enum with SnapshotNow semantics. A concurrent SnapshotNow scan could + * pg_enum with SnapshotNow semantics. A concurrent SnapshotNow scan could * see both old and new versions of an updated row as valid, or neither of * them, if the commit happens between scanning the two versions. It's * also quite likely for a concurrent scan to see an inconsistent set of @@ -510,10 +510,10 @@ oid_cmp(const void *p1, const void *p2) static int sort_order_cmp(const void *p1, const void *p2) { - HeapTuple v1 = *((const HeapTuple *) p1); - HeapTuple v2 = *((const HeapTuple *) p2); - Form_pg_enum en1 = (Form_pg_enum) GETSTRUCT(v1); - Form_pg_enum en2 = (Form_pg_enum) GETSTRUCT(v2); + HeapTuple v1 = *((const HeapTuple *) p1); + HeapTuple v2 = *((const HeapTuple *) p2); + Form_pg_enum en1 = (Form_pg_enum) GETSTRUCT(v1); + Form_pg_enum en2 = (Form_pg_enum) GETSTRUCT(v2); if (en1->enumsortorder < en2->enumsortorder) return -1; diff --git a/src/backend/catalog/pg_proc.c b/src/backend/catalog/pg_proc.c index 6138165cc37..47a8ff4d989 100644 --- a/src/backend/catalog/pg_proc.c +++ b/src/backend/catalog/pg_proc.c @@ -842,8 +842,8 @@ fmgr_sql_validator(PG_FUNCTION_ARGS) if (!haspolyarg) { /* - * OK to do full precheck: analyze and rewrite the queries, - * then verify the result type. + * OK to do full precheck: analyze and rewrite the queries, then + * verify the result type. */ SQLFunctionParseInfoPtr pinfo; @@ -858,7 +858,7 @@ fmgr_sql_validator(PG_FUNCTION_ARGS) querytree_sublist = pg_analyze_and_rewrite_params(parsetree, prosrc, - (ParserSetupHook) sql_fn_parser_setup, + (ParserSetupHook) sql_fn_parser_setup, pinfo); querytree_list = list_concat(querytree_list, querytree_sublist); diff --git a/src/backend/catalog/pg_type.c b/src/backend/catalog/pg_type.c index 06301c075bb..9e35e73f9cf 100644 --- a/src/backend/catalog/pg_type.c +++ b/src/backend/catalog/pg_type.c @@ -115,7 +115,7 @@ TypeShellMake(const char *typeName, Oid typeNamespace, Oid ownerId) values[i++] = ObjectIdGetDatum(InvalidOid); /* typbasetype */ values[i++] = Int32GetDatum(-1); /* typtypmod */ values[i++] = Int32GetDatum(0); /* typndims */ - values[i++] = ObjectIdGetDatum(InvalidOid); /* typcollation */ + values[i++] = ObjectIdGetDatum(InvalidOid); /* typcollation */ nulls[i++] = true; /* typdefaultbin */ nulls[i++] = true; /* typdefault */ @@ -352,7 +352,7 @@ TypeCreate(Oid newTypeOid, values[i++] = ObjectIdGetDatum(baseType); /* typbasetype */ values[i++] = Int32GetDatum(typeMod); /* typtypmod */ values[i++] = Int32GetDatum(typNDims); /* typndims */ - values[i++] = ObjectIdGetDatum(typeCollation); /* typcollation */ + values[i++] = ObjectIdGetDatum(typeCollation); /* typcollation */ /* * initialize the default binary value for this type. Check for nulls of diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c index 221f9f5c12c..57987be2c0a 100644 --- a/src/backend/catalog/storage.c +++ b/src/backend/catalog/storage.c @@ -119,7 +119,7 @@ RelationCreateStorage(RelFileNode rnode, char relpersistence) break; default: elog(ERROR, "invalid relpersistence: %c", relpersistence); - return; /* placate compiler */ + return; /* placate compiler */ } srel = smgropen(rnode, backend); @@ -379,7 +379,7 @@ smgrDoPendingDeletes(bool isCommit) * *ptr is set to point to a freshly-palloc'd array of RelFileNodes. * If there are no relations to be deleted, *ptr is set to NULL. * - * Only non-temporary relations are included in the returned list. This is OK + * Only non-temporary relations are included in the returned list. This is OK * because the list is used only in contexts where temporary relations don't * matter: we're either writing to the two-phase state file (and transactions * that have touched temp tables can't be prepared) or we're writing to xlog diff --git a/src/backend/catalog/toasting.c b/src/backend/catalog/toasting.c index 5d5496df989..452ca9bef02 100644 --- a/src/backend/catalog/toasting.c +++ b/src/backend/catalog/toasting.c @@ -279,7 +279,7 @@ create_toast_table(Relation rel, Oid toastOid, Oid toastIndexOid, Datum reloptio list_make2("chunk_id", "chunk_seq"), BTREE_AM_OID, rel->rd_rel->reltablespace, - collationObjectId, classObjectId, coloptions, (Datum) 0, + collationObjectId, classObjectId, coloptions, (Datum) 0, true, false, false, false, true, false, false); diff --git a/src/backend/commands/alter.c b/src/backend/commands/alter.c index 99fdd7dba30..215e21cae08 100644 --- a/src/backend/commands/alter.c +++ b/src/backend/commands/alter.c @@ -282,26 +282,26 @@ AlterObjectNamespace_oid(Oid classId, Oid objid, Oid nspOid) switch (getObjectClass(&dep)) { case OCLASS_CLASS: - { - Relation rel; - Relation classRel; + { + Relation rel; + Relation classRel; - rel = relation_open(objid, AccessExclusiveLock); - oldNspOid = RelationGetNamespace(rel); + rel = relation_open(objid, AccessExclusiveLock); + oldNspOid = RelationGetNamespace(rel); - classRel = heap_open(RelationRelationId, RowExclusiveLock); + classRel = heap_open(RelationRelationId, RowExclusiveLock); - AlterRelationNamespaceInternal(classRel, - objid, - oldNspOid, - nspOid, - true); + AlterRelationNamespaceInternal(classRel, + objid, + oldNspOid, + nspOid, + true); - heap_close(classRel, RowExclusiveLock); + heap_close(classRel, RowExclusiveLock); - relation_close(rel, NoLock); - break; - } + relation_close(rel, NoLock); + break; + } case OCLASS_PROC: oldNspOid = AlterFunctionNamespace_oid(objid, nspOid); @@ -386,9 +386,11 @@ AlterObjectNamespace(Relation rel, int oidCacheId, int nameCacheId, { Oid classId = RelationGetRelid(rel); Oid oldNspOid; - Datum name, namespace; - bool isnull; - HeapTuple tup, newtup; + Datum name, + namespace; + bool isnull; + HeapTuple tup, + newtup; Datum *values; bool *nulls; bool *replaces; @@ -410,7 +412,7 @@ AlterObjectNamespace(Relation rel, int oidCacheId, int nameCacheId, /* Permission checks ... superusers can always do it */ if (!superuser()) { - Datum owner; + Datum owner; Oid ownerId; AclResult aclresult; diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c index 774bb044715..dde301b89aa 100644 --- a/src/backend/commands/analyze.c +++ b/src/backend/commands/analyze.c @@ -95,7 +95,7 @@ static void compute_index_stats(Relation onerel, double totalrows, HeapTuple *rows, int numrows, MemoryContext col_context); static VacAttrStats *examine_attribute(Relation onerel, int attnum, - Node *index_expr); + Node *index_expr); static int acquire_sample_rows(Relation onerel, HeapTuple *rows, int targrows, double *totalrows, double *totaldeadrows); static double random_fract(void); @@ -160,8 +160,8 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt, if (IsAutoVacuumWorkerProcess() && Log_autovacuum_min_duration >= 0) ereport(LOG, (errcode(ERRCODE_LOCK_NOT_AVAILABLE), - errmsg("skipping analyze of \"%s\" --- lock not available", - vacstmt->relation->relname))); + errmsg("skipping analyze of \"%s\" --- lock not available", + vacstmt->relation->relname))); } if (!onerel) return; @@ -853,10 +853,10 @@ examine_attribute(Relation onerel, int attnum, Node *index_expr) /* * When analyzing an expression index, believe the expression tree's type * not the column datatype --- the latter might be the opckeytype storage - * type of the opclass, which is not interesting for our purposes. (Note: + * type of the opclass, which is not interesting for our purposes. (Note: * if we did anything with non-expression index columns, we'd need to * figure out where to get the correct type info from, but for now that's - * not a problem.) It's not clear whether anyone will care about the + * not a problem.) It's not clear whether anyone will care about the * typmod, but we store that too just in case. */ if (index_expr) diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c index 4c4f356e790..2cc2aaa8f64 100644 --- a/src/backend/commands/cluster.c +++ b/src/backend/commands/cluster.c @@ -718,7 +718,7 @@ copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex, TransactionId OldestXmin; TransactionId FreezeXid; RewriteState rwstate; - bool use_sort; + bool use_sort; Tuplesortstate *tuplesort; double num_tuples = 0, tups_vacuumed = 0, @@ -813,11 +813,11 @@ copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex, rwstate = begin_heap_rewrite(NewHeap, OldestXmin, FreezeXid, use_wal); /* - * Decide whether to use an indexscan or seqscan-and-optional-sort to - * scan the OldHeap. We know how to use a sort to duplicate the ordering - * of a btree index, and will use seqscan-and-sort for that case if the - * planner tells us it's cheaper. Otherwise, always indexscan if an - * index is provided, else plain seqscan. + * Decide whether to use an indexscan or seqscan-and-optional-sort to scan + * the OldHeap. We know how to use a sort to duplicate the ordering of a + * btree index, and will use seqscan-and-sort for that case if the planner + * tells us it's cheaper. Otherwise, always indexscan if an index is + * provided, else plain seqscan. */ if (OldIndex != NULL && OldIndex->rd_rel->relam == BTREE_AM_OID) use_sort = plan_cluster_use_sort(OIDOldHeap, OIDOldIndex); @@ -869,8 +869,8 @@ copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex, /* * Scan through the OldHeap, either in OldIndex order or sequentially; * copy each tuple into the NewHeap, or transiently to the tuplesort - * module. Note that we don't bother sorting dead tuples (they won't - * get to the new table anyway). + * module. Note that we don't bother sorting dead tuples (they won't get + * to the new table anyway). */ for (;;) { @@ -984,8 +984,8 @@ copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex, heap_endscan(heapScan); /* - * In scan-and-sort mode, complete the sort, then read out all live - * tuples from the tuplestore and write them to the new relation. + * In scan-and-sort mode, complete the sort, then read out all live tuples + * from the tuplestore and write them to the new relation. */ if (tuplesort != NULL) { @@ -1554,7 +1554,7 @@ reform_and_rewrite_tuple(HeapTuple tuple, bool newRelHasOids, RewriteState rwstate) { HeapTuple copiedTuple; - int i; + int i; heap_deform_tuple(tuple, oldTupDesc, values, isnull); diff --git a/src/backend/commands/collationcmds.c b/src/backend/commands/collationcmds.c index 2a6938fd04b..7f8a108374e 100644 --- a/src/backend/commands/collationcmds.c +++ b/src/backend/commands/collationcmds.c @@ -34,7 +34,7 @@ #include "utils/syscache.h" static void AlterCollationOwner_internal(Relation rel, Oid collationOid, - Oid newOwnerId); + Oid newOwnerId); /* * CREATE COLLATION @@ -46,10 +46,10 @@ DefineCollation(List *names, List *parameters) Oid collNamespace; AclResult aclresult; ListCell *pl; - DefElem *fromEl = NULL; - DefElem *localeEl = NULL; - DefElem *lccollateEl = NULL; - DefElem *lcctypeEl = NULL; + DefElem *fromEl = NULL; + DefElem *localeEl = NULL; + DefElem *lccollateEl = NULL; + DefElem *lcctypeEl = NULL; char *collcollate = NULL; char *collctype = NULL; Oid newoid; @@ -63,7 +63,7 @@ DefineCollation(List *names, List *parameters) foreach(pl, parameters) { - DefElem *defel = (DefElem *) lfirst(pl); + DefElem *defel = (DefElem *) lfirst(pl); DefElem **defelp; if (pg_strcasecmp(defel->defname, "from") == 0) @@ -97,7 +97,7 @@ DefineCollation(List *names, List *parameters) Oid collid; HeapTuple tp; - collid = get_collation_oid(defGetQualifiedName(fromEl), false); + collid = get_collation_oid(defGetQualifiedName(fromEl), false); tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid)); if (!HeapTupleIsValid(tp)) elog(ERROR, "cache lookup failed for collation %u", collid); @@ -123,7 +123,7 @@ DefineCollation(List *names, List *parameters) if (!collcollate) ereport(ERROR, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("parameter \"lc_collate\" parameter must be specified"))); + errmsg("parameter \"lc_collate\" parameter must be specified"))); if (!collctype) ereport(ERROR, @@ -391,7 +391,7 @@ AlterCollationNamespace(List *name, const char *newschema) Oid AlterCollationNamespace_oid(Oid collOid, Oid newNspOid) { - Oid oldNspOid; + Oid oldNspOid; Relation rel; char *collation_name; diff --git a/src/backend/commands/comment.c b/src/backend/commands/comment.c index 3fbeefa018b..d09bef06824 100644 --- a/src/backend/commands/comment.c +++ b/src/backend/commands/comment.c @@ -37,8 +37,8 @@ void CommentObject(CommentStmt *stmt) { - ObjectAddress address; - Relation relation; + ObjectAddress address; + Relation relation; /* * When loading a dump, we may see a COMMENT ON DATABASE for the old name @@ -46,12 +46,13 @@ CommentObject(CommentStmt *stmt) * (which is really pg_restore's fault, but for now we will work around * the problem here). Consensus is that the best fix is to treat wrong * database name as a WARNING not an ERROR; hence, the following special - * case. (If the length of stmt->objname is not 1, get_object_address will - * throw an error below; that's OK.) + * case. (If the length of stmt->objname is not 1, get_object_address + * will throw an error below; that's OK.) */ if (stmt->objtype == OBJECT_DATABASE && list_length(stmt->objname) == 1) { - char *database = strVal(linitial(stmt->objname)); + char *database = strVal(linitial(stmt->objname)); + if (!OidIsValid(get_database_oid(database, true))) { ereport(WARNING, @@ -62,10 +63,10 @@ CommentObject(CommentStmt *stmt) } /* - * Translate the parser representation that identifies this object into - * an ObjectAddress. get_object_address() will throw an error if the - * object does not exist, and will also acquire a lock on the target - * to guard against concurrent DROP operations. + * Translate the parser representation that identifies this object into an + * ObjectAddress. get_object_address() will throw an error if the object + * does not exist, and will also acquire a lock on the target to guard + * against concurrent DROP operations. */ address = get_object_address(stmt->objtype, stmt->objname, stmt->objargs, &relation, ShareUpdateExclusiveLock); @@ -78,6 +79,7 @@ CommentObject(CommentStmt *stmt) switch (stmt->objtype) { case OBJECT_COLUMN: + /* * Allow comments only on columns of tables, views, composite * types, and foreign tables (which are the only relkinds for diff --git a/src/backend/commands/conversioncmds.c b/src/backend/commands/conversioncmds.c index b5e4420ca8d..2c1c6da9009 100644 --- a/src/backend/commands/conversioncmds.c +++ b/src/backend/commands/conversioncmds.c @@ -335,7 +335,8 @@ AlterConversionOwner_internal(Relation rel, Oid conversionOid, Oid newOwnerId) void AlterConversionNamespace(List *name, const char *newschema) { - Oid convOid, nspOid; + Oid convOid, + nspOid; Relation rel; rel = heap_open(ConversionRelationId, RowExclusiveLock); @@ -361,7 +362,7 @@ AlterConversionNamespace(List *name, const char *newschema) Oid AlterConversionNamespace_oid(Oid convOid, Oid newNspOid) { - Oid oldNspOid; + Oid oldNspOid; Relation rel; rel = heap_open(ConversionRelationId, RowExclusiveLock); diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c index 3af0b097198..57429035e89 100644 --- a/src/backend/commands/copy.c +++ b/src/backend/commands/copy.c @@ -115,7 +115,7 @@ typedef struct CopyStateData char *quote; /* CSV quote char (must be 1 byte) */ char *escape; /* CSV escape char (must be 1 byte) */ List *force_quote; /* list of column names */ - bool force_quote_all; /* FORCE QUOTE *? */ + bool force_quote_all; /* FORCE QUOTE *? */ bool *force_quote_flags; /* per-column CSV FQ flags */ List *force_notnull; /* list of column names */ bool *force_notnull_flags; /* per-column CSV FNN flags */ @@ -161,8 +161,8 @@ typedef struct CopyStateData /* field raw data pointers found by COPY FROM */ - int max_fields; - char ** raw_fields; + int max_fields; + char **raw_fields; /* * Similarly, line_buf holds the whole input line being processed. The @@ -266,10 +266,10 @@ static const char BinarySignature[11] = "PGCOPY\n\377\r\n\0"; /* non-export function prototypes */ static CopyState BeginCopy(bool is_from, Relation rel, Node *raw_query, - const char *queryString, List *attnamelist, List *options); + const char *queryString, List *attnamelist, List *options); static void EndCopy(CopyState cstate); static CopyState BeginCopyTo(Relation rel, Node *query, const char *queryString, - const char *filename, List *attnamelist, List *options); + const char *filename, List *attnamelist, List *options); static void EndCopyTo(CopyState cstate); static uint64 DoCopyTo(CopyState cstate); static uint64 CopyTo(CopyState cstate); @@ -278,8 +278,8 @@ static void CopyOneRowTo(CopyState cstate, Oid tupleOid, static uint64 CopyFrom(CopyState cstate); static bool CopyReadLine(CopyState cstate); static bool CopyReadLineText(CopyState cstate); -static int CopyReadAttributesText(CopyState cstate); -static int CopyReadAttributesCSV(CopyState cstate); +static int CopyReadAttributesText(CopyState cstate); +static int CopyReadAttributesCSV(CopyState cstate); static Datum CopyReadBinaryAttribute(CopyState cstate, int column_no, FmgrInfo *flinfo, Oid typioparam, int32 typmod, @@ -748,17 +748,17 @@ DoCopy(const CopyStmt *stmt, const char *queryString) if (stmt->relation) { - TupleDesc tupDesc; - AclMode required_access = (is_from ? ACL_INSERT : ACL_SELECT); - RangeTblEntry *rte; - List *attnums; - ListCell *cur; + TupleDesc tupDesc; + AclMode required_access = (is_from ? ACL_INSERT : ACL_SELECT); + RangeTblEntry *rte; + List *attnums; + ListCell *cur; Assert(!stmt->query); /* Open and lock the relation, using the appropriate lock type. */ rel = heap_openrv(stmt->relation, - (is_from ? RowExclusiveLock : AccessShareLock)); + (is_from ? RowExclusiveLock : AccessShareLock)); rte = makeNode(RangeTblEntry); rte->rtekind = RTE_RELATION; @@ -770,8 +770,8 @@ DoCopy(const CopyStmt *stmt, const char *queryString) attnums = CopyGetAttnums(tupDesc, rel, stmt->attlist); foreach(cur, attnums) { - int attno = lfirst_int(cur) - - FirstLowInvalidHeapAttributeNumber; + int attno = lfirst_int(cur) - + FirstLowInvalidHeapAttributeNumber; if (is_from) rte->modifiedCols = bms_add_member(rte->modifiedCols, attno); @@ -1136,8 +1136,8 @@ BeginCopy(bool is_from, cstate = (CopyStateData *) palloc0(sizeof(CopyStateData)); /* - * We allocate everything used by a cstate in a new memory context. - * This avoids memory leaks during repeated use of COPY in a query. + * We allocate everything used by a cstate in a new memory context. This + * avoids memory leaks during repeated use of COPY in a query. */ cstate->copycontext = AllocSetContextCreate(CurrentMemoryContext, "COPY", @@ -1300,9 +1300,9 @@ BeginCopy(bool is_from, cstate->file_encoding = pg_get_client_encoding(); /* - * Set up encoding conversion info. Even if the file and server - * encodings are the same, we must apply pg_any_to_server() to validate - * data in multibyte encodings. + * Set up encoding conversion info. Even if the file and server encodings + * are the same, we must apply pg_any_to_server() to validate data in + * multibyte encodings. */ cstate->need_transcoding = (cstate->file_encoding != GetDatabaseEncoding() || @@ -1552,8 +1552,8 @@ CopyTo(CopyState cstate) */ if (cstate->need_transcoding) cstate->null_print_client = pg_server_to_any(cstate->null_print, - cstate->null_print_len, - cstate->file_encoding); + cstate->null_print_len, + cstate->file_encoding); /* if a header has been requested send the line */ if (cstate->header_line) @@ -2001,9 +2001,9 @@ CopyFrom(CopyState cstate) { slot = ExecBRInsertTriggers(estate, resultRelInfo, slot); - if (slot == NULL) /* "do nothing" */ + if (slot == NULL) /* "do nothing" */ skip_tuple = true; - else /* trigger might have changed tuple */ + else /* trigger might have changed tuple */ tuple = ExecMaterializeSlot(slot); } @@ -2159,7 +2159,7 @@ BeginCopyFrom(Relation rel, { /* Initialize expressions in copycontext. */ defexprs[num_defaults] = ExecInitExpr( - expression_planner((Expr *) defexpr), NULL); + expression_planner((Expr *) defexpr), NULL); defmap[num_defaults] = attnum - 1; num_defaults++; } @@ -2255,7 +2255,7 @@ BeginCopyFrom(Relation rel, if (!cstate->binary) { AttrNumber attr_count = list_length(cstate->attnumlist); - int nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count; + int nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count; cstate->max_fields = nfields; cstate->raw_fields = (char **) palloc(nfields * sizeof(char *)); @@ -2291,7 +2291,7 @@ NextCopyFromRawFields(CopyState cstate, char ***fields, int *nfields) { cstate->cur_lineno++; if (CopyReadLine(cstate)) - return false; /* done */ + return false; /* done */ } cstate->cur_lineno++; @@ -2300,9 +2300,9 @@ NextCopyFromRawFields(CopyState cstate, char ***fields, int *nfields) done = CopyReadLine(cstate); /* - * EOF at start of line means we're done. If we see EOF after - * some characters, we act as though it was newline followed by - * EOF, ie, process the line and then exit loop on next iteration. + * EOF at start of line means we're done. If we see EOF after some + * characters, we act as though it was newline followed by EOF, ie, + * process the line and then exit loop on next iteration. */ if (done && cstate->line_buf.len == 0) return false; @@ -2341,7 +2341,7 @@ NextCopyFrom(CopyState cstate, ExprContext *econtext, FmgrInfo *in_functions = cstate->in_functions; Oid *typioparams = cstate->typioparams; int i; - int nfields; + int nfields; bool isnull; bool file_has_oids = cstate->file_has_oids; int *defmap = cstate->defmap; @@ -2456,18 +2456,18 @@ NextCopyFrom(CopyState cstate, ExprContext *econtext, if (fld_count == -1) { /* - * Received EOF marker. In a V3-protocol copy, wait for - * the protocol-level EOF, and complain if it doesn't come - * immediately. This ensures that we correctly handle - * CopyFail, if client chooses to send that now. + * Received EOF marker. In a V3-protocol copy, wait for the + * protocol-level EOF, and complain if it doesn't come + * immediately. This ensures that we correctly handle CopyFail, + * if client chooses to send that now. * - * Note that we MUST NOT try to read more data in an - * old-protocol copy, since there is no protocol-level EOF - * marker then. We could go either way for copy from file, - * but choose to throw error if there's data after the EOF - * marker, for consistency with the new-protocol case. + * Note that we MUST NOT try to read more data in an old-protocol + * copy, since there is no protocol-level EOF marker then. We + * could go either way for copy from file, but choose to throw + * error if there's data after the EOF marker, for consistency + * with the new-protocol case. */ - char dummy; + char dummy; if (cstate->copy_dest != COPY_OLD_FE && CopyGetData(cstate, &dummy, 1, 1) > 0) @@ -2485,14 +2485,14 @@ NextCopyFrom(CopyState cstate, ExprContext *econtext, if (file_has_oids) { - Oid loaded_oid; + Oid loaded_oid; cstate->cur_attname = "oid"; loaded_oid = DatumGetObjectId(CopyReadBinaryAttribute(cstate, 0, - &cstate->oid_in_function, - cstate->oid_typioparam, + &cstate->oid_in_function, + cstate->oid_typioparam, -1, &isnull)); if (isnull || loaded_oid == InvalidOid) @@ -2524,8 +2524,8 @@ NextCopyFrom(CopyState cstate, ExprContext *econtext, /* * Now compute and insert any defaults available for the columns not - * provided by the input data. Anything not processed here or above - * will remain NULL. + * provided by the input data. Anything not processed here or above will + * remain NULL. */ for (i = 0; i < num_defaults; i++) { @@ -3023,12 +3023,12 @@ GetDecimalFromHex(char hex) * performing de-escaping as needed. * * The input is in line_buf. We use attribute_buf to hold the result - * strings. cstate->raw_fields[k] is set to point to the k'th attribute - * string, or NULL when the input matches the null marker string. + * strings. cstate->raw_fields[k] is set to point to the k'th attribute + * string, or NULL when the input matches the null marker string. * This array is expanded as necessary. * - * (Note that the caller cannot check for nulls since the returned - * string would be the post-de-escaping equivalent, which may look + * (Note that the caller cannot check for nulls since the returned + * string would be the post-de-escaping equivalent, which may look * the same as some valid data string.) * * delim is the column delimiter string (must be just one byte for now). @@ -3090,8 +3090,8 @@ CopyReadAttributesText(CopyState cstate) if (fieldno >= cstate->max_fields) { cstate->max_fields *= 2; - cstate->raw_fields = - repalloc(cstate->raw_fields, cstate->max_fields*sizeof(char *)); + cstate->raw_fields = + repalloc(cstate->raw_fields, cstate->max_fields * sizeof(char *)); } /* Remember start of field on both input and output sides */ @@ -3307,8 +3307,8 @@ CopyReadAttributesCSV(CopyState cstate) if (fieldno >= cstate->max_fields) { cstate->max_fields *= 2; - cstate->raw_fields = - repalloc(cstate->raw_fields, cstate->max_fields*sizeof(char *)); + cstate->raw_fields = + repalloc(cstate->raw_fields, cstate->max_fields * sizeof(char *)); } /* Remember start of field on both input and output sides */ diff --git a/src/backend/commands/dbcommands.c b/src/backend/commands/dbcommands.c index 87d9e545b4f..f319eb539c3 100644 --- a/src/backend/commands/dbcommands.c +++ b/src/backend/commands/dbcommands.c @@ -680,8 +680,8 @@ createdb(const CreatedbStmt *stmt) void check_encoding_locale_matches(int encoding, const char *collate, const char *ctype) { - int ctype_encoding = pg_get_encoding_from_locale(ctype, true); - int collate_encoding = pg_get_encoding_from_locale(collate, true); + int ctype_encoding = pg_get_encoding_from_locale(ctype, true); + int collate_encoding = pg_get_encoding_from_locale(collate, true); if (!(ctype_encoding == encoding || ctype_encoding == PG_SQL_ASCII || @@ -1849,10 +1849,10 @@ get_database_oid(const char *dbname, bool missing_ok) heap_close(pg_database, AccessShareLock); if (!OidIsValid(oid) && !missing_ok) - ereport(ERROR, - (errcode(ERRCODE_UNDEFINED_DATABASE), - errmsg("database \"%s\" does not exist", - dbname))); + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_DATABASE), + errmsg("database \"%s\" does not exist", + dbname))); return oid; } diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c index 1d9586f07d4..7a361585bdd 100644 --- a/src/backend/commands/explain.c +++ b/src/backend/commands/explain.c @@ -59,26 +59,26 @@ static void ExplainNode(PlanState *planstate, List *ancestors, const char *relationship, const char *plan_name, ExplainState *es); static void show_plan_tlist(PlanState *planstate, List *ancestors, - ExplainState *es); + ExplainState *es); static void show_expression(Node *node, const char *qlabel, PlanState *planstate, List *ancestors, bool useprefix, ExplainState *es); static void show_qual(List *qual, const char *qlabel, - PlanState *planstate, List *ancestors, - bool useprefix, ExplainState *es); + PlanState *planstate, List *ancestors, + bool useprefix, ExplainState *es); static void show_scan_qual(List *qual, const char *qlabel, - PlanState *planstate, List *ancestors, - ExplainState *es); + PlanState *planstate, List *ancestors, + ExplainState *es); static void show_upper_qual(List *qual, const char *qlabel, - PlanState *planstate, List *ancestors, - ExplainState *es); + PlanState *planstate, List *ancestors, + ExplainState *es); static void show_sort_keys(SortState *sortstate, List *ancestors, - ExplainState *es); + ExplainState *es); static void show_merge_append_keys(MergeAppendState *mstate, List *ancestors, - ExplainState *es); + ExplainState *es); static void show_sort_keys_common(PlanState *planstate, - int nkeys, AttrNumber *keycols, - List *ancestors, ExplainState *es); + int nkeys, AttrNumber *keycols, + List *ancestors, ExplainState *es); static void show_sort_info(SortState *sortstate, ExplainState *es); static void show_hash_info(HashState *hashstate, ExplainState *es); static void show_foreignscan_info(ForeignScanState *fsstate, ExplainState *es); @@ -89,7 +89,7 @@ static void ExplainTargetRel(Plan *plan, Index rti, ExplainState *es); static void ExplainMemberNodes(List *plans, PlanState **planstates, List *ancestors, ExplainState *es); static void ExplainSubPlans(List *plans, List *ancestors, - const char *relationship, ExplainState *es); + const char *relationship, ExplainState *es); static void ExplainProperty(const char *qlabel, const char *value, bool numeric, ExplainState *es); static void ExplainOpenGroup(const char *objtype, const char *labelname, @@ -1358,7 +1358,7 @@ show_scan_qual(List *qual, const char *qlabel, { bool useprefix; - useprefix = (IsA(planstate->plan, SubqueryScan) || es->verbose); + useprefix = (IsA(planstate->plan, SubqueryScan) ||es->verbose); show_qual(qual, qlabel, planstate, ancestors, useprefix, es); } diff --git a/src/backend/commands/extension.c b/src/backend/commands/extension.c index 7c3e8107dee..d848926ae55 100644 --- a/src/backend/commands/extension.c +++ b/src/backend/commands/extension.c @@ -56,8 +56,8 @@ /* Globally visible state variables */ -bool creating_extension = false; -Oid CurrentExtensionObject = InvalidOid; +bool creating_extension = false; +Oid CurrentExtensionObject = InvalidOid; /* * Internal data structure to hold the results of parsing a control file @@ -66,8 +66,8 @@ typedef struct ExtensionControlFile { char *name; /* name of the extension */ char *directory; /* directory for script files */ - char *default_version; /* default install target version, if any */ - char *module_pathname; /* string to substitute for MODULE_PATHNAME */ + char *default_version; /* default install target version, if any */ + char *module_pathname; /* string to substitute for MODULE_PATHNAME */ char *comment; /* comment, if any */ char *schema; /* target schema (allowed if !relocatable) */ bool relocatable; /* is ALTER EXTENSION SET SCHEMA supported? */ @@ -85,9 +85,9 @@ typedef struct ExtensionVersionInfo List *reachable; /* List of ExtensionVersionInfo's */ bool installable; /* does this version have an install script? */ /* working state for Dijkstra's algorithm: */ - bool distance_known; /* is distance from start known yet? */ + bool distance_known; /* is distance from start known yet? */ int distance; /* current worst-case distance estimate */ - struct ExtensionVersionInfo *previous; /* current best predecessor */ + struct ExtensionVersionInfo *previous; /* current best predecessor */ } ExtensionVersionInfo; /* Local functions */ @@ -107,7 +107,7 @@ static void ApplyExtensionUpdates(Oid extensionOid, /* * get_extension_oid - given an extension name, look up the OID * - * If missing_ok is false, throw an error if extension name not found. If + * If missing_ok is false, throw an error if extension name not found. If * true, just return InvalidOid. */ Oid @@ -142,10 +142,10 @@ get_extension_oid(const char *extname, bool missing_ok) heap_close(rel, AccessShareLock); if (!OidIsValid(result) && !missing_ok) - ereport(ERROR, - (errcode(ERRCODE_UNDEFINED_OBJECT), - errmsg("extension \"%s\" does not exist", - extname))); + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_OBJECT), + errmsg("extension \"%s\" does not exist", + extname))); return result; } @@ -237,8 +237,8 @@ check_valid_extension_name(const char *extensionname) int namelen = strlen(extensionname); /* - * Disallow empty names (the parser rejects empty identifiers anyway, - * but let's check). + * Disallow empty names (the parser rejects empty identifiers anyway, but + * let's check). */ if (namelen == 0) ereport(ERROR, @@ -256,16 +256,16 @@ check_valid_extension_name(const char *extensionname) errdetail("Extension names must not contain \"--\"."))); /* - * No leading or trailing dash either. (We could probably allow this, - * but it would require much care in filename parsing and would make - * filenames visually if not formally ambiguous. Since there's no - * real-world use case, let's just forbid it.) + * No leading or trailing dash either. (We could probably allow this, but + * it would require much care in filename parsing and would make filenames + * visually if not formally ambiguous. Since there's no real-world use + * case, let's just forbid it.) */ if (extensionname[0] == '-' || extensionname[namelen - 1] == '-') ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid extension name: \"%s\"", extensionname), - errdetail("Extension names must not begin or end with \"-\"."))); + errdetail("Extension names must not begin or end with \"-\"."))); /* * No directory separators either (this is sufficient to prevent ".." @@ -290,7 +290,7 @@ check_valid_version_name(const char *versionname) if (namelen == 0) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("invalid extension version name: \"%s\"", versionname), + errmsg("invalid extension version name: \"%s\"", versionname), errdetail("Version names must not be empty."))); /* @@ -299,7 +299,7 @@ check_valid_version_name(const char *versionname) if (strstr(versionname, "--")) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("invalid extension version name: \"%s\"", versionname), + errmsg("invalid extension version name: \"%s\"", versionname), errdetail("Version names must not contain \"--\"."))); /* @@ -308,8 +308,8 @@ check_valid_version_name(const char *versionname) if (versionname[0] == '-' || versionname[namelen - 1] == '-') ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("invalid extension version name: \"%s\"", versionname), - errdetail("Version names must not begin or end with \"-\"."))); + errmsg("invalid extension version name: \"%s\"", versionname), + errdetail("Version names must not begin or end with \"-\"."))); /* * No directory separators either (this is sufficient to prevent ".." @@ -318,7 +318,7 @@ check_valid_version_name(const char *versionname) if (first_dir_separator(versionname) != NULL) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("invalid extension version name: \"%s\"", versionname), + errmsg("invalid extension version name: \"%s\"", versionname), errdetail("Version names must not contain directory separator characters."))); } @@ -386,7 +386,7 @@ get_extension_script_directory(ExtensionControlFile *control) get_share_path(my_exec_path, sharepath); result = (char *) palloc(MAXPGPATH); - snprintf(result, MAXPGPATH, "%s/%s", sharepath, control->directory); + snprintf(result, MAXPGPATH, "%s/%s", sharepath, control->directory); return result; } @@ -434,7 +434,7 @@ get_extension_script_filename(ExtensionControlFile *control, /* * Parse contents of primary or auxiliary control file, and fill in - * fields of *control. We parse primary file if version == NULL, + * fields of *control. We parse primary file if version == NULL, * else the optional auxiliary file for that version. * * Control files are supposed to be very short, half a dozen lines, @@ -448,8 +448,8 @@ parse_extension_control_file(ExtensionControlFile *control, char *filename; FILE *file; ConfigVariable *item, - *head = NULL, - *tail = NULL; + *head = NULL, + *tail = NULL; /* * Locate the file to read. Auxiliary files are optional. @@ -553,8 +553,8 @@ parse_extension_control_file(ExtensionControlFile *control, /* syntax error in name list */ ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("parameter \"%s\" must be a list of extension names", - item->name))); + errmsg("parameter \"%s\" must be a list of extension names", + item->name))); } } else @@ -632,12 +632,12 @@ static char * read_extension_script_file(const ExtensionControlFile *control, const char *filename) { - int src_encoding; - int dest_encoding = GetDatabaseEncoding(); - bytea *content; + int src_encoding; + int dest_encoding = GetDatabaseEncoding(); + bytea *content; char *src_str; - char *dest_str; - int len; + char *dest_str; + int len; content = read_binary_file(filename, 0, -1); @@ -675,7 +675,7 @@ read_extension_script_file(const ExtensionControlFile *control, * filename is used only to report errors. * * Note: it's tempting to just use SPI to execute the string, but that does - * not work very well. The really serious problem is that SPI will parse, + * not work very well. The really serious problem is that SPI will parse, * analyze, and plan the whole string before executing any of it; of course * this fails if there are any plannable statements referring to objects * created earlier in the script. A lesser annoyance is that SPI insists @@ -774,7 +774,7 @@ execute_extension_script(Oid extensionOid, ExtensionControlFile *control, List *requiredSchemas, const char *schemaName, Oid schemaOid) { - char *filename; + char *filename; char *save_client_min_messages, *save_log_min_messages, *save_search_path; @@ -809,8 +809,8 @@ execute_extension_script(Oid extensionOid, ExtensionControlFile *control, * so that we won't spam the user with useless NOTICE messages from common * script actions like creating shell types. * - * We use the equivalent of SET LOCAL to ensure the setting is undone - * upon error. + * We use the equivalent of SET LOCAL to ensure the setting is undone upon + * error. */ save_client_min_messages = pstrdup(GetConfigOption("client_min_messages", false)); @@ -832,8 +832,8 @@ execute_extension_script(Oid extensionOid, ExtensionControlFile *control, * makes the target schema be the default creation target namespace. * * Note: it might look tempting to use PushOverrideSearchPath for this, - * but we cannot do that. We have to actually set the search_path GUC - * in case the extension script examines or changes it. + * but we cannot do that. We have to actually set the search_path GUC in + * case the extension script examines or changes it. */ save_search_path = pstrdup(GetConfigOption("search_path", false)); @@ -855,32 +855,32 @@ execute_extension_script(Oid extensionOid, ExtensionControlFile *control, /* * Set creating_extension and related variables so that * recordDependencyOnCurrentExtension and other functions do the right - * things. On failure, ensure we reset these variables. + * things. On failure, ensure we reset these variables. */ creating_extension = true; CurrentExtensionObject = extensionOid; PG_TRY(); { - char *sql = read_extension_script_file(control, filename); + char *sql = read_extension_script_file(control, filename); /* * If it's not relocatable, substitute the target schema name for * occcurrences of @extschema@. * - * For a relocatable extension, we just run the script as-is. - * There cannot be any need for @extschema@, else it wouldn't - * be relocatable. + * For a relocatable extension, we just run the script as-is. There + * cannot be any need for @extschema@, else it wouldn't be + * relocatable. */ if (!control->relocatable) { - const char *qSchemaName = quote_identifier(schemaName); + const char *qSchemaName = quote_identifier(schemaName); sql = text_to_cstring( - DatumGetTextPP( - DirectFunctionCall3(replace_text, - CStringGetTextDatum(sql), - CStringGetTextDatum("@extschema@"), - CStringGetTextDatum(qSchemaName)))); + DatumGetTextPP( + DirectFunctionCall3(replace_text, + CStringGetTextDatum(sql), + CStringGetTextDatum("@extschema@"), + CStringGetTextDatum(qSchemaName)))); } /* @@ -890,11 +890,11 @@ execute_extension_script(Oid extensionOid, ExtensionControlFile *control, if (control->module_pathname) { sql = text_to_cstring( - DatumGetTextPP( - DirectFunctionCall3(replace_text, - CStringGetTextDatum(sql), - CStringGetTextDatum("MODULE_PATHNAME"), - CStringGetTextDatum(control->module_pathname)))); + DatumGetTextPP( + DirectFunctionCall3(replace_text, + CStringGetTextDatum(sql), + CStringGetTextDatum("MODULE_PATHNAME"), + CStringGetTextDatum(control->module_pathname)))); } execute_sql_string(sql, filename); @@ -1004,7 +1004,7 @@ get_ext_ver_list(ExtensionControlFile *control) struct dirent *de; location = get_extension_script_directory(control); - dir = AllocateDir(location); + dir = AllocateDir(location); while ((de = ReadDir(dir, location)) != NULL) { char *vername; @@ -1094,7 +1094,7 @@ identify_update_path(ExtensionControlFile *control, * is still good. * * Result is a List of names of versions to transition through (the initial - * version is *not* included). Returns NIL if no such path. + * version is *not* included). Returns NIL if no such path. */ static List * find_update_path(List *evi_list, @@ -1132,7 +1132,7 @@ find_update_path(List *evi_list, foreach(lc, evi->reachable) { ExtensionVersionInfo *evi2 = (ExtensionVersionInfo *) lfirst(lc); - int newdist; + int newdist; newdist = evi->distance + 1; if (newdist < evi2->distance) @@ -1178,10 +1178,10 @@ CreateExtension(CreateExtensionStmt *stmt) DefElem *d_schema = NULL; DefElem *d_new_version = NULL; DefElem *d_old_version = NULL; - char *schemaName; + char *schemaName; Oid schemaOid; - char *versionName; - char *oldVersionName; + char *versionName; + char *oldVersionName; Oid extowner = GetUserId(); ExtensionControlFile *pcontrol; ExtensionControlFile *control; @@ -1195,10 +1195,10 @@ CreateExtension(CreateExtensionStmt *stmt) check_valid_extension_name(stmt->extname); /* - * Check for duplicate extension name. The unique index on + * Check for duplicate extension name. The unique index on * pg_extension.extname would catch this anyway, and serves as a backstop - * in case of race conditions; but this is a friendlier error message, - * and besides we need a check to support IF NOT EXISTS. + * in case of race conditions; but this is a friendlier error message, and + * besides we need a check to support IF NOT EXISTS. */ if (get_extension_oid(stmt->extname, true) != InvalidOid) { @@ -1218,8 +1218,8 @@ CreateExtension(CreateExtensionStmt *stmt) } /* - * We use global variables to track the extension being created, so we - * can create only one extension at the same time. + * We use global variables to track the extension being created, so we can + * create only one extension at the same time. */ if (creating_extension) ereport(ERROR, @@ -1306,8 +1306,8 @@ CreateExtension(CreateExtensionStmt *stmt) if (list_length(updateVersions) == 1) { /* - * Simple case where there's just one update script to run. - * We will not need any follow-on update steps. + * Simple case where there's just one update script to run. We + * will not need any follow-on update steps. */ Assert(strcmp((char *) linitial(updateVersions), versionName) == 0); updateVersions = NIL; @@ -1351,9 +1351,9 @@ CreateExtension(CreateExtensionStmt *stmt) strcmp(control->schema, schemaName) != 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("extension \"%s\" must be installed in schema \"%s\"", - control->name, - control->schema))); + errmsg("extension \"%s\" must be installed in schema \"%s\"", + control->name, + control->schema))); /* If the user is giving us the schema name, it must exist already */ schemaOid = get_namespace_oid(schemaName, false); @@ -1362,7 +1362,7 @@ CreateExtension(CreateExtensionStmt *stmt) { /* * The extension is not relocatable and the author gave us a schema - * for it. We create the schema here if it does not already exist. + * for it. We create the schema here if it does not already exist. */ schemaName = control->schema; schemaOid = get_namespace_oid(schemaName, true); @@ -1380,13 +1380,13 @@ CreateExtension(CreateExtensionStmt *stmt) * Else, use the current default creation namespace, which is the * first explicit entry in the search_path. */ - List *search_path = fetch_search_path(false); + List *search_path = fetch_search_path(false); - if (search_path == NIL) /* probably can't happen */ + if (search_path == NIL) /* probably can't happen */ elog(ERROR, "there is no default creation target"); schemaOid = linitial_oid(search_path); schemaName = get_namespace_name(schemaOid); - if (schemaName == NULL) /* recently-deleted namespace? */ + if (schemaName == NULL) /* recently-deleted namespace? */ elog(ERROR, "there is no default creation target"); list_free(search_path); @@ -1397,13 +1397,13 @@ CreateExtension(CreateExtensionStmt *stmt) * extension script actually creates any objects there, it will fail if * the user doesn't have such permissions. But there are cases such as * procedural languages where it's convenient to set schema = pg_catalog - * yet we don't want to restrict the command to users with ACL_CREATE - * for pg_catalog. + * yet we don't want to restrict the command to users with ACL_CREATE for + * pg_catalog. */ /* - * Look up the prerequisite extensions, and build lists of their OIDs - * and the OIDs of their target schemas. + * Look up the prerequisite extensions, and build lists of their OIDs and + * the OIDs of their target schemas. */ requiredExtensions = NIL; requiredSchemas = NIL; @@ -1453,8 +1453,8 @@ CreateExtension(CreateExtensionStmt *stmt) schemaName, schemaOid); /* - * If additional update scripts have to be executed, apply the updates - * as though a series of ALTER EXTENSION UPDATE commands were given + * If additional update scripts have to be executed, apply the updates as + * though a series of ALTER EXTENSION UPDATE commands were given */ ApplyExtensionUpdates(extensionOid, pcontrol, versionName, updateVersions); @@ -1653,7 +1653,7 @@ RemoveExtensionById(Oid extId) /* * This function lists the available extensions (one row per primary control - * file in the control directory). We parse each control file and report the + * file in the control directory). We parse each control file and report the * interesting fields. * * The system view pg_available_extensions provides a user interface to this @@ -1663,14 +1663,14 @@ RemoveExtensionById(Oid extId) Datum pg_available_extensions(PG_FUNCTION_ARGS) { - ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo; - TupleDesc tupdesc; - Tuplestorestate *tupstore; - MemoryContext per_query_ctx; - MemoryContext oldcontext; - char *location; - DIR *dir; - struct dirent *de; + ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo; + TupleDesc tupdesc; + Tuplestorestate *tupstore; + MemoryContext per_query_ctx; + MemoryContext oldcontext; + char *location; + DIR *dir; + struct dirent *de; /* check to see if caller supports us returning a tuplestore */ if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo)) @@ -1699,11 +1699,11 @@ pg_available_extensions(PG_FUNCTION_ARGS) MemoryContextSwitchTo(oldcontext); location = get_extension_control_directory(); - dir = AllocateDir(location); + dir = AllocateDir(location); /* - * If the control directory doesn't exist, we want to silently return - * an empty set. Any other error will be reported by ReadDir. + * If the control directory doesn't exist, we want to silently return an + * empty set. Any other error will be reported by ReadDir. */ if (dir == NULL && errno == ENOENT) { @@ -1762,7 +1762,7 @@ pg_available_extensions(PG_FUNCTION_ARGS) /* * This function lists the available extension versions (one row per - * extension installation script). For each version, we parse the related + * extension installation script). For each version, we parse the related * control file(s) and report the interesting fields. * * The system view pg_available_extension_versions provides a user interface @@ -1772,14 +1772,14 @@ pg_available_extensions(PG_FUNCTION_ARGS) Datum pg_available_extension_versions(PG_FUNCTION_ARGS) { - ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo; - TupleDesc tupdesc; - Tuplestorestate *tupstore; - MemoryContext per_query_ctx; - MemoryContext oldcontext; - char *location; - DIR *dir; - struct dirent *de; + ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo; + TupleDesc tupdesc; + Tuplestorestate *tupstore; + MemoryContext per_query_ctx; + MemoryContext oldcontext; + char *location; + DIR *dir; + struct dirent *de; /* check to see if caller supports us returning a tuplestore */ if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo)) @@ -1808,11 +1808,11 @@ pg_available_extension_versions(PG_FUNCTION_ARGS) MemoryContextSwitchTo(oldcontext); location = get_extension_control_directory(); - dir = AllocateDir(location); + dir = AllocateDir(location); /* - * If the control directory doesn't exist, we want to silently return - * an empty set. Any other error will be reported by ReadDir. + * If the control directory doesn't exist, we want to silently return an + * empty set. Any other error will be reported by ReadDir. */ if (dir == NULL && errno == ENOENT) { @@ -1867,7 +1867,7 @@ get_available_versions_for_extension(ExtensionControlFile *pcontrol, struct dirent *de; location = get_extension_script_directory(pcontrol); - dir = AllocateDir(location); + dir = AllocateDir(location); /* Note this will fail if script directory doesn't exist */ while ((de = ReadDir(dir, location)) != NULL) { @@ -1962,11 +1962,11 @@ Datum pg_extension_update_paths(PG_FUNCTION_ARGS) { Name extname = PG_GETARG_NAME(0); - ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo; - TupleDesc tupdesc; - Tuplestorestate *tupstore; - MemoryContext per_query_ctx; - MemoryContext oldcontext; + ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo; + TupleDesc tupdesc; + Tuplestorestate *tupstore; + MemoryContext per_query_ctx; + MemoryContext oldcontext; List *evi_list; ExtensionControlFile *control; ListCell *lc1; @@ -2079,8 +2079,8 @@ pg_extension_config_dump(PG_FUNCTION_ARGS) text *wherecond = PG_GETARG_TEXT_P(1); char *tablename; Relation extRel; - ScanKeyData key[1]; - SysScanDesc extScan; + ScanKeyData key[1]; + SysScanDesc extScan; HeapTuple extTup; Datum arrayDatum; Datum elementDatum; @@ -2092,8 +2092,8 @@ pg_extension_config_dump(PG_FUNCTION_ARGS) ArrayType *a; /* - * We only allow this to be called from an extension's SQL script. - * We shouldn't need any permissions check beyond that. + * We only allow this to be called from an extension's SQL script. We + * shouldn't need any permissions check beyond that. */ if (!creating_extension) ereport(ERROR, @@ -2103,8 +2103,8 @@ pg_extension_config_dump(PG_FUNCTION_ARGS) /* * Check that the table exists and is a member of the extension being - * created. This ensures that we don't need to register a dependency - * to protect the extconfig entry. + * created. This ensures that we don't need to register a dependency to + * protect the extconfig entry. */ tablename = get_rel_name(tableoid); if (tablename == NULL) @@ -2115,12 +2115,12 @@ pg_extension_config_dump(PG_FUNCTION_ARGS) CurrentExtensionObject) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), - errmsg("table \"%s\" is not a member of the extension being created", - tablename))); + errmsg("table \"%s\" is not a member of the extension being created", + tablename))); /* - * Add the table OID and WHERE condition to the extension's extconfig - * and extcondition arrays. + * Add the table OID and WHERE condition to the extension's extconfig and + * extcondition arrays. */ /* Find the pg_extension tuple */ @@ -2136,7 +2136,7 @@ pg_extension_config_dump(PG_FUNCTION_ARGS) extTup = systable_getnext(extScan); - if (!HeapTupleIsValid(extTup)) /* should not happen */ + if (!HeapTupleIsValid(extTup)) /* should not happen */ elog(ERROR, "extension with oid %u does not exist", CurrentExtensionObject); @@ -2162,7 +2162,7 @@ pg_extension_config_dump(PG_FUNCTION_ARGS) Assert(ARR_NDIM(a) == 1); Assert(ARR_LBOUND(a)[0] == 1); - arrayIndex = ARR_DIMS(a)[0] + 1; /* add after end */ + arrayIndex = ARR_DIMS(a)[0] + 1; /* add after end */ a = array_set(a, 1, &arrayIndex, elementDatum, @@ -2193,7 +2193,7 @@ pg_extension_config_dump(PG_FUNCTION_ARGS) Assert(ARR_NDIM(a) == 1); Assert(ARR_LBOUND(a)[0] == 1); - arrayIndex = ARR_DIMS(a)[0] + 1; /* add after end */ + arrayIndex = ARR_DIMS(a)[0] + 1; /* add after end */ a = array_set(a, 1, &arrayIndex, elementDatum, @@ -2231,12 +2231,12 @@ AlterExtensionNamespace(List *names, const char *newschema) Oid oldNspOid = InvalidOid; AclResult aclresult; Relation extRel; - ScanKeyData key[2]; - SysScanDesc extScan; + ScanKeyData key[2]; + SysScanDesc extScan; HeapTuple extTup; Form_pg_extension extForm; Relation depRel; - SysScanDesc depScan; + SysScanDesc depScan; HeapTuple depTup; if (list_length(names) != 1) @@ -2275,7 +2275,7 @@ AlterExtensionNamespace(List *names, const char *newschema) extTup = systable_getnext(extScan); - if (!HeapTupleIsValid(extTup)) /* should not happen */ + if (!HeapTupleIsValid(extTup)) /* should not happen */ elog(ERROR, "extension with oid %u does not exist", extensionOid); /* Copy tuple so we can modify it below */ @@ -2285,8 +2285,8 @@ AlterExtensionNamespace(List *names, const char *newschema) systable_endscan(extScan); /* - * If the extension is already in the target schema, just silently - * do nothing. + * If the extension is already in the target schema, just silently do + * nothing. */ if (extForm->extnamespace == nspOid) { @@ -2323,10 +2323,10 @@ AlterExtensionNamespace(List *names, const char *newschema) { Form_pg_depend pg_depend = (Form_pg_depend) GETSTRUCT(depTup); ObjectAddress dep; - Oid dep_oldNspOid; + Oid dep_oldNspOid; /* - * Ignore non-membership dependencies. (Currently, the only other + * Ignore non-membership dependencies. (Currently, the only other * case we could see here is a normal dependency from another * extension.) */ @@ -2388,13 +2388,13 @@ void ExecAlterExtensionStmt(AlterExtensionStmt *stmt) { DefElem *d_new_version = NULL; - char *versionName; - char *oldVersionName; + char *versionName; + char *oldVersionName; ExtensionControlFile *control; Oid extensionOid; Relation extRel; - ScanKeyData key[1]; - SysScanDesc extScan; + ScanKeyData key[1]; + SysScanDesc extScan; HeapTuple extTup; List *updateVersions; Datum datum; @@ -2402,8 +2402,8 @@ ExecAlterExtensionStmt(AlterExtensionStmt *stmt) ListCell *lc; /* - * We use global variables to track the extension being created, so we - * can create/update only one extension at the same time. + * We use global variables to track the extension being created, so we can + * create/update only one extension at the same time. */ if (creating_extension) ereport(ERROR, @@ -2426,10 +2426,10 @@ ExecAlterExtensionStmt(AlterExtensionStmt *stmt) extTup = systable_getnext(extScan); if (!HeapTupleIsValid(extTup)) - ereport(ERROR, - (errcode(ERRCODE_UNDEFINED_OBJECT), - errmsg("extension \"%s\" does not exist", - stmt->extname))); + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_OBJECT), + errmsg("extension \"%s\" does not exist", + stmt->extname))); extensionOid = HeapTupleGetOid(extTup); @@ -2499,8 +2499,8 @@ ExecAlterExtensionStmt(AlterExtensionStmt *stmt) if (strcmp(oldVersionName, versionName) == 0) { ereport(NOTICE, - (errmsg("version \"%s\" of extension \"%s\" is already installed", - versionName, stmt->extname))); + (errmsg("version \"%s\" of extension \"%s\" is already installed", + versionName, stmt->extname))); return; } @@ -2545,8 +2545,8 @@ ApplyExtensionUpdates(Oid extensionOid, List *requiredExtensions; List *requiredSchemas; Relation extRel; - ScanKeyData key[1]; - SysScanDesc extScan; + ScanKeyData key[1]; + SysScanDesc extScan; HeapTuple extTup; Form_pg_extension extForm; Datum values[Natts_pg_extension]; @@ -2573,7 +2573,7 @@ ApplyExtensionUpdates(Oid extensionOid, extTup = systable_getnext(extScan); - if (!HeapTupleIsValid(extTup)) /* should not happen */ + if (!HeapTupleIsValid(extTup)) /* should not happen */ elog(ERROR, "extension with oid %u does not exist", extensionOid); @@ -2668,9 +2668,9 @@ ApplyExtensionUpdates(Oid extensionOid, schemaName, schemaOid); /* - * Update prior-version name and loop around. Since execute_sql_string - * did a final CommandCounterIncrement, we can update the pg_extension - * row again. + * Update prior-version name and loop around. Since + * execute_sql_string did a final CommandCounterIncrement, we can + * update the pg_extension row again. */ oldVersionName = versionName; } @@ -2682,10 +2682,10 @@ ApplyExtensionUpdates(Oid extensionOid, void ExecAlterExtensionContentsStmt(AlterExtensionContentsStmt *stmt) { - ObjectAddress extension; - ObjectAddress object; - Relation relation; - Oid oldExtension; + ObjectAddress extension; + ObjectAddress object; + Relation relation; + Oid oldExtension; extension.classId = ExtensionRelationId; extension.objectId = get_extension_oid(stmt->extname, false); @@ -2697,10 +2697,10 @@ ExecAlterExtensionContentsStmt(AlterExtensionContentsStmt *stmt) stmt->extname); /* - * Translate the parser representation that identifies the object into - * an ObjectAddress. get_object_address() will throw an error if the - * object does not exist, and will also acquire a lock on the object to - * guard against concurrent DROP and ALTER EXTENSION ADD/DROP operations. + * Translate the parser representation that identifies the object into an + * ObjectAddress. get_object_address() will throw an error if the object + * does not exist, and will also acquire a lock on the object to guard + * against concurrent DROP and ALTER EXTENSION ADD/DROP operations. */ object = get_object_address(stmt->objtype, stmt->objname, stmt->objargs, &relation, ShareUpdateExclusiveLock); diff --git a/src/backend/commands/foreigncmds.c b/src/backend/commands/foreigncmds.c index 13d6d882f88..21d52e06ba0 100644 --- a/src/backend/commands/foreigncmds.c +++ b/src/backend/commands/foreigncmds.c @@ -586,8 +586,8 @@ AlterForeignDataWrapper(AlterFdwStmt *stmt) */ if (OidIsValid(fdwvalidator)) ereport(WARNING, - (errmsg("changing the foreign-data wrapper validator can cause " - "the options for dependent objects to become invalid"))); + (errmsg("changing the foreign-data wrapper validator can cause " + "the options for dependent objects to become invalid"))); } else { @@ -643,8 +643,8 @@ AlterForeignDataWrapper(AlterFdwStmt *stmt) ObjectAddress referenced; /* - * Flush all existing dependency records of this FDW on functions; - * we assume there can be none other than the ones we are fixing. + * Flush all existing dependency records of this FDW on functions; we + * assume there can be none other than the ones we are fixing. */ deleteDependencyRecordsForClass(ForeignDataWrapperRelationId, fdwId, diff --git a/src/backend/commands/functioncmds.c b/src/backend/commands/functioncmds.c index c8cbe035f05..03da168ff2c 100644 --- a/src/backend/commands/functioncmds.c +++ b/src/backend/commands/functioncmds.c @@ -1665,7 +1665,7 @@ CreateCast(CreateCastStmt *stmt) * We also disallow creating binary-compatibility casts involving * domains. Casting from a domain to its base type is already * allowed, and casting the other way ought to go through domain - * coercion to permit constraint checking. Again, if you're intent on + * coercion to permit constraint checking. Again, if you're intent on * having your own semantics for that, create a no-op cast function. * * NOTE: if we were to relax this, the above checks for composites @@ -1830,7 +1830,7 @@ DropCast(DropCastStmt *stmt) Oid get_cast_oid(Oid sourcetypeid, Oid targettypeid, bool missing_ok) { - Oid oid; + Oid oid; oid = GetSysCacheOid2(CASTSOURCETARGET, ObjectIdGetDatum(sourcetypeid), diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c index cfcce559675..05e8234a0f2 100644 --- a/src/backend/commands/indexcmds.c +++ b/src/backend/commands/indexcmds.c @@ -395,7 +395,7 @@ DefineIndex(RangeVar *heapRelation, indexRelationId = index_create(rel, indexRelationName, indexRelationId, indexInfo, indexColNames, - accessMethodId, tablespaceId, collationObjectId, classObjectId, + accessMethodId, tablespaceId, collationObjectId, classObjectId, coloptions, reloptions, primary, isconstraint, deferrable, initdeferred, allowSystemTableMods, @@ -840,14 +840,14 @@ ComputeIndexAttrs(IndexInfo *indexInfo, else { /* Index expression */ - Node *expr = attribute->expr; + Node *expr = attribute->expr; Assert(expr != NULL); atttype = exprType(expr); attcollation = exprCollation(expr); /* - * Strip any top-level COLLATE clause. This ensures that we treat + * Strip any top-level COLLATE clause. This ensures that we treat * "x COLLATE y" and "(x COLLATE y)" alike. */ while (IsA(expr, CollateExpr)) @@ -864,7 +864,7 @@ ComputeIndexAttrs(IndexInfo *indexInfo, } else { - indexInfo->ii_KeyAttrNumbers[attn] = 0; /* marks expression */ + indexInfo->ii_KeyAttrNumbers[attn] = 0; /* marks expression */ indexInfo->ii_Expressions = lappend(indexInfo->ii_Expressions, expr); @@ -876,7 +876,7 @@ ComputeIndexAttrs(IndexInfo *indexInfo, if (contain_subplans(expr)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("cannot use subquery in index expression"))); + errmsg("cannot use subquery in index expression"))); if (contain_agg_clause(expr)) ereport(ERROR, (errcode(ERRCODE_GROUPING_ERROR), @@ -904,8 +904,8 @@ ComputeIndexAttrs(IndexInfo *indexInfo, /* * Check we have a collation iff it's a collatable type. The only * expected failures here are (1) COLLATE applied to a noncollatable - * type, or (2) index expression had an unresolved collation. But - * we might as well code this to be a complete consistency check. + * type, or (2) index expression had an unresolved collation. But we + * might as well code this to be a complete consistency check. */ if (type_is_collatable(atttype)) { diff --git a/src/backend/commands/opclasscmds.c b/src/backend/commands/opclasscmds.c index 68072dd4218..aff5ac6ec43 100644 --- a/src/backend/commands/opclasscmds.c +++ b/src/backend/commands/opclasscmds.c @@ -126,7 +126,7 @@ OpFamilyCacheLookup(Oid amID, List *opfamilyname, bool missing_ok) if (!HeapTupleIsValid(htup) && !missing_ok) { - HeapTuple amtup; + HeapTuple amtup; amtup = SearchSysCache1(AMOID, ObjectIdGetDatum(amID)); if (!HeapTupleIsValid(amtup)) @@ -134,8 +134,8 @@ OpFamilyCacheLookup(Oid amID, List *opfamilyname, bool missing_ok) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("operator family \"%s\" does not exist for access method \"%s\"", - NameListToString(opfamilyname), - NameStr(((Form_pg_am) GETSTRUCT(amtup))->amname)))); + NameListToString(opfamilyname), + NameStr(((Form_pg_am) GETSTRUCT(amtup))->amname)))); } return htup; @@ -143,7 +143,7 @@ OpFamilyCacheLookup(Oid amID, List *opfamilyname, bool missing_ok) /* * get_opfamily_oid - * find an opfamily OID by possibly qualified name + * find an opfamily OID by possibly qualified name * * If not found, returns InvalidOid if missing_ok, else throws error. */ @@ -202,7 +202,7 @@ OpClassCacheLookup(Oid amID, List *opclassname, bool missing_ok) if (!HeapTupleIsValid(htup) && !missing_ok) { - HeapTuple amtup; + HeapTuple amtup; amtup = SearchSysCache1(AMOID, ObjectIdGetDatum(amID)); if (!HeapTupleIsValid(amtup)) @@ -219,7 +219,7 @@ OpClassCacheLookup(Oid amID, List *opclassname, bool missing_ok) /* * get_opclass_oid - * find an opclass OID by possibly qualified name + * find an opclass OID by possibly qualified name * * If not found, returns InvalidOid if missing_ok, else throws error. */ @@ -1088,11 +1088,11 @@ assignOperTypes(OpFamilyMember *member, Oid amoid, Oid typeoid) if (OidIsValid(member->sortfamily)) { /* - * Ordering op, check index supports that. (We could perhaps also + * Ordering op, check index supports that. (We could perhaps also * check that the operator returns a type supported by the sortfamily, * but that seems more trouble than it's worth here. If it does not, - * the operator will never be matchable to any ORDER BY clause, but - * no worse consequences can ensue. Also, trying to check that would + * the operator will never be matchable to any ORDER BY clause, but no + * worse consequences can ensue. Also, trying to check that would * create an ordering hazard during dump/reload: it's possible that * the family has been created but not yet populated with the required * operators.) @@ -1108,8 +1108,8 @@ assignOperTypes(OpFamilyMember *member, Oid amoid, Oid typeoid) if (!pg_am->amcanorderbyop) ereport(ERROR, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), - errmsg("access method \"%s\" does not support ordering operators", - NameStr(pg_am->amname)))); + errmsg("access method \"%s\" does not support ordering operators", + NameStr(pg_am->amname)))); ReleaseSysCache(amtup); } @@ -1276,7 +1276,7 @@ storeOperators(List *opfamilyname, Oid amoid, foreach(l, operators) { OpFamilyMember *op = (OpFamilyMember *) lfirst(l); - char oppurpose; + char oppurpose; /* * If adding to an existing family, check for conflict with an @@ -1566,7 +1566,7 @@ RemoveOpClass(RemoveOpClassStmt *stmt) { ereport(NOTICE, (errmsg("operator class \"%s\" does not exist for access method \"%s\"", - NameListToString(stmt->opclassname), stmt->amname))); + NameListToString(stmt->opclassname), stmt->amname))); return; } @@ -1617,7 +1617,7 @@ RemoveOpFamily(RemoveOpFamilyStmt *stmt) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("operator family \"%s\" does not exist for access method \"%s\"", - NameListToString(stmt->opfamilyname), stmt->amname))); + NameListToString(stmt->opfamilyname), stmt->amname))); return; } @@ -2029,7 +2029,7 @@ AlterOpClassNamespace(List *name, char *access_method, const char *newschema) Oid AlterOpClassNamespace_oid(Oid opclassOid, Oid newNspOid) { - Oid oldNspOid; + Oid oldNspOid; Relation rel; rel = heap_open(OperatorClassRelationId, RowExclusiveLock); @@ -2238,7 +2238,7 @@ AlterOpFamilyNamespace(List *name, char *access_method, const char *newschema) Oid AlterOpFamilyNamespace_oid(Oid opfamilyOid, Oid newNspOid) { - Oid oldNspOid; + Oid oldNspOid; Relation rel; rel = heap_open(OperatorFamilyRelationId, RowExclusiveLock); diff --git a/src/backend/commands/operatorcmds.c b/src/backend/commands/operatorcmds.c index b4374a62f4f..c99de4b240f 100644 --- a/src/backend/commands/operatorcmds.c +++ b/src/backend/commands/operatorcmds.c @@ -464,7 +464,8 @@ AlterOperatorNamespace(List *names, List *argtypes, const char *newschema) List *operatorName = names; TypeName *typeName1 = (TypeName *) linitial(argtypes); TypeName *typeName2 = (TypeName *) lsecond(argtypes); - Oid operOid, nspOid; + Oid operOid, + nspOid; Relation rel; rel = heap_open(OperatorRelationId, RowExclusiveLock); @@ -490,7 +491,7 @@ AlterOperatorNamespace(List *names, List *argtypes, const char *newschema) Oid AlterOperatorNamespace_oid(Oid operOid, Oid newNspOid) { - Oid oldNspOid; + Oid oldNspOid; Relation rel; rel = heap_open(OperatorRelationId, RowExclusiveLock); diff --git a/src/backend/commands/portalcmds.c b/src/backend/commands/portalcmds.c index 60aca3ce8ec..89086aa3717 100644 --- a/src/backend/commands/portalcmds.c +++ b/src/backend/commands/portalcmds.c @@ -255,10 +255,10 @@ PortalCleanup(Portal portal) if (queryDesc) { /* - * Reset the queryDesc before anything else. This prevents us - * from trying to shut down the executor twice, in case of an - * error below. The transaction abort mechanisms will take care - * of resource cleanup in such a case. + * Reset the queryDesc before anything else. This prevents us from + * trying to shut down the executor twice, in case of an error below. + * The transaction abort mechanisms will take care of resource cleanup + * in such a case. */ portal->queryDesc = NULL; diff --git a/src/backend/commands/prepare.c b/src/backend/commands/prepare.c index adbf5872f38..dfa2ab00262 100644 --- a/src/backend/commands/prepare.c +++ b/src/backend/commands/prepare.c @@ -382,7 +382,7 @@ EvaluateParams(PreparedStatement *pstmt, List *params, /* sizeof(ParamListInfoData) includes the first array element */ paramLI = (ParamListInfo) palloc(sizeof(ParamListInfoData) + - (num_params - 1) *sizeof(ParamExternData)); + (num_params - 1) * sizeof(ParamExternData)); /* we have static list of params, so no hooks needed */ paramLI->paramFetch = NULL; paramLI->paramFetchArg = NULL; diff --git a/src/backend/commands/seclabel.c b/src/backend/commands/seclabel.c index 1c96b005d7f..7afb7139a63 100644 --- a/src/backend/commands/seclabel.c +++ b/src/backend/commands/seclabel.c @@ -1,7 +1,7 @@ /* ------------------------------------------------------------------------- * * seclabel.c - * routines to support security label feature. + * routines to support security label feature. * * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California @@ -28,7 +28,7 @@ typedef struct { const char *provider_name; - check_object_relabel_type hook; + check_object_relabel_type hook; } LabelProvider; static List *label_provider_list = NIL; @@ -42,9 +42,9 @@ void ExecSecLabelStmt(SecLabelStmt *stmt) { LabelProvider *provider = NULL; - ObjectAddress address; - Relation relation; - ListCell *lc; + ObjectAddress address; + Relation relation; + ListCell *lc; /* * Find the named label provider, or if none specified, check whether @@ -55,16 +55,16 @@ ExecSecLabelStmt(SecLabelStmt *stmt) if (label_provider_list == NIL) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("no security label providers have been loaded"))); + errmsg("no security label providers have been loaded"))); if (lnext(list_head(label_provider_list)) != NULL) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("must specify provider when multiple security label providers have been loaded"))); + errmsg("must specify provider when multiple security label providers have been loaded"))); provider = (LabelProvider *) linitial(label_provider_list); } else { - foreach (lc, label_provider_list) + foreach(lc, label_provider_list) { LabelProvider *lp = lfirst(lc); @@ -82,10 +82,10 @@ ExecSecLabelStmt(SecLabelStmt *stmt) } /* - * Translate the parser representation which identifies this object - * into an ObjectAddress. get_object_address() will throw an error if - * the object does not exist, and will also acquire a lock on the - * target to guard against concurrent modifications. + * Translate the parser representation which identifies this object into + * an ObjectAddress. get_object_address() will throw an error if the + * object does not exist, and will also acquire a lock on the target to + * guard against concurrent modifications. */ address = get_object_address(stmt->objtype, stmt->objname, stmt->objargs, &relation, ShareUpdateExclusiveLock); @@ -98,6 +98,7 @@ ExecSecLabelStmt(SecLabelStmt *stmt) switch (stmt->objtype) { case OBJECT_COLUMN: + /* * Allow security labels only on columns of tables, views, * composite types, and foreign tables (which are the only @@ -117,7 +118,7 @@ ExecSecLabelStmt(SecLabelStmt *stmt) } /* Provider gets control here, may throw ERROR to veto new label. */ - (*provider->hook)(&address, stmt->label); + (*provider->hook) (&address, stmt->label); /* Apply new label. */ SetSecurityLabel(&address, provider->provider_name, stmt->label); @@ -140,8 +141,8 @@ char * GetSecurityLabel(const ObjectAddress *object, const char *provider) { Relation pg_seclabel; - ScanKeyData keys[4]; - SysScanDesc scan; + ScanKeyData keys[4]; + SysScanDesc scan; HeapTuple tuple; Datum datum; bool isnull; @@ -196,8 +197,8 @@ SetSecurityLabel(const ObjectAddress *object, const char *provider, const char *label) { Relation pg_seclabel; - ScanKeyData keys[4]; - SysScanDesc scan; + ScanKeyData keys[4]; + SysScanDesc scan; HeapTuple oldtup; HeapTuple newtup = NULL; Datum values[Natts_pg_seclabel]; @@ -281,8 +282,8 @@ void DeleteSecurityLabel(const ObjectAddress *object) { Relation pg_seclabel; - ScanKeyData skey[3]; - SysScanDesc scan; + ScanKeyData skey[3]; + SysScanDesc scan; HeapTuple oldtup; int nkeys; @@ -323,8 +324,8 @@ DeleteSecurityLabel(const ObjectAddress *object) void register_label_provider(const char *provider_name, check_object_relabel_type hook) { - LabelProvider *provider; - MemoryContext oldcxt; + LabelProvider *provider; + MemoryContext oldcxt; oldcxt = MemoryContextSwitchTo(TopMemoryContext); provider = palloc(sizeof(LabelProvider)); diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c index bfa94a0c114..6a91a102dcd 100644 --- a/src/backend/commands/sequence.c +++ b/src/backend/commands/sequence.c @@ -287,7 +287,7 @@ ResetSequence(Oid seq_relid) seq->log_cnt = 1; /* - * Create a new storage file for the sequence. We want to keep the + * Create a new storage file for the sequence. We want to keep the * sequence's relfrozenxid at 0, since it won't contain any unfrozen XIDs. */ RelationSetNewRelfilenode(seq_rel, InvalidTransactionId); @@ -1037,7 +1037,7 @@ init_sequence(Oid relid, SeqTable *p_elm, Relation *p_rel) /* * If the sequence has been transactionally replaced since we last saw it, - * discard any cached-but-unissued values. We do not touch the currval() + * discard any cached-but-unissued values. We do not touch the currval() * state, however. */ if (seqrel->rd_rel->relfilenode != elm->filenode) diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index 886b656b437..790bc2a5215 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -286,9 +286,9 @@ static void ATWrongRelkindError(Relation rel, int allowed_targets); static void ATSimpleRecursion(List **wqueue, Relation rel, AlterTableCmd *cmd, bool recurse, LOCKMODE lockmode); static void ATTypedTableRecursion(List **wqueue, Relation rel, AlterTableCmd *cmd, - LOCKMODE lockmode); + LOCKMODE lockmode); static List *find_typed_table_dependencies(Oid typeOid, const char *typeName, - DropBehavior behavior); + DropBehavior behavior); static void ATPrepAddColumn(List **wqueue, Relation rel, bool recurse, bool recursing, AlterTableCmd *cmd, LOCKMODE lockmode); static void ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel, @@ -311,7 +311,7 @@ static void ATExecSetOptions(Relation rel, const char *colName, static void ATExecSetStorage(Relation rel, const char *colName, Node *newValue, LOCKMODE lockmode); static void ATPrepDropColumn(List **wqueue, Relation rel, bool recurse, bool recursing, - AlterTableCmd *cmd, LOCKMODE lockmode); + AlterTableCmd *cmd, LOCKMODE lockmode); static void ATExecDropColumn(List **wqueue, Relation rel, const char *colName, DropBehavior behavior, bool recurse, bool recursing, @@ -320,9 +320,9 @@ static void ATExecAddIndex(AlteredTableInfo *tab, Relation rel, IndexStmt *stmt, bool is_rebuild, LOCKMODE lockmode); static void ATExecAddConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, - Constraint *newConstraint, bool recurse, LOCKMODE lockmode); + Constraint *newConstraint, bool recurse, LOCKMODE lockmode); static void ATExecAddIndexConstraint(AlteredTableInfo *tab, Relation rel, - IndexStmt *stmt, LOCKMODE lockmode); + IndexStmt *stmt, LOCKMODE lockmode); static void ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, Constraint *constr, @@ -339,7 +339,7 @@ static void ATPrepAlterColumnType(List **wqueue, AlterTableCmd *cmd, LOCKMODE lockmode); static bool ATColumnChangeRequiresRewrite(Node *expr, AttrNumber varattno); static void ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel, - AlterTableCmd *cmd, LOCKMODE lockmode); + AlterTableCmd *cmd, LOCKMODE lockmode); static void ATPostAlterTypeCleanup(List **wqueue, AlteredTableInfo *tab, LOCKMODE lockmode); static void ATPostAlterTypeParse(char *cmd, List **wqueue, LOCKMODE lockmode); static void change_owner_recurse_to_sequences(Oid relationOid, @@ -351,7 +351,7 @@ static void ATPrepSetTableSpace(AlteredTableInfo *tab, Relation rel, static void ATExecSetTableSpace(Oid tableOid, Oid newTableSpace, LOCKMODE lockmode); static void ATExecSetRelOptions(Relation rel, List *defList, bool isReset, LOCKMODE lockmode); static void ATExecEnableDisableTrigger(Relation rel, char *trigname, - char fires_when, bool skip_system, LOCKMODE lockmode); + char fires_when, bool skip_system, LOCKMODE lockmode); static void ATExecEnableDisableRule(Relation rel, char *rulename, char fires_when, LOCKMODE lockmode); static void ATPrepAddInherit(Relation child_rel); @@ -412,7 +412,7 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId) /* * Check consistency of arguments */ - if (stmt->oncommit != ONCOMMIT_NOOP + if (stmt->oncommit != ONCOMMIT_NOOP && stmt->relation->relpersistence != RELPERSISTENCE_TEMP) ereport(ERROR, (errcode(ERRCODE_INVALID_TABLE_DEFINITION), @@ -547,7 +547,7 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId) if (relkind == RELKIND_FOREIGN_TABLE) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("default values on foreign tables are not supported"))); + errmsg("default values on foreign tables are not supported"))); Assert(colDef->cooked_default == NULL); @@ -706,7 +706,7 @@ DropErrorMsgWrongType(const char *relname, char wrongkind, char rightkind) /* * RemoveRelations * Implements DROP TABLE, DROP INDEX, DROP SEQUENCE, DROP VIEW, - * DROP FOREIGN TABLE + * DROP FOREIGN TABLE */ void RemoveRelations(DropStmt *drop) @@ -1454,11 +1454,11 @@ MergeAttributes(List *schema, List *supers, char relpersistence, if (defCollId != attribute->attcollation) ereport(ERROR, (errcode(ERRCODE_COLLATION_MISMATCH), - errmsg("inherited column \"%s\" has a collation conflict", - attributeName), + errmsg("inherited column \"%s\" has a collation conflict", + attributeName), errdetail("\"%s\" versus \"%s\"", get_collation_name(defCollId), - get_collation_name(attribute->attcollation)))); + get_collation_name(attribute->attcollation)))); /* Copy storage parameter */ if (def->storage == 0) @@ -2061,8 +2061,8 @@ renameatt_internal(Oid myrelid, relkind != RELKIND_FOREIGN_TABLE) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("\"%s\" is not a table, view, composite type, index or foreign table", - RelationGetRelationName(targetrelation)))); + errmsg("\"%s\" is not a table, view, composite type, index or foreign table", + RelationGetRelationName(targetrelation)))); /* * permissions checking. only the owner of a class can change its schema. @@ -2138,7 +2138,7 @@ renameatt_internal(Oid myrelid, ListCell *lo; child_oids = find_typed_table_dependencies(targetrelation->rd_rel->reltype, - RelationGetRelationName(targetrelation), + RelationGetRelationName(targetrelation), behavior); foreach(lo, child_oids) @@ -2211,11 +2211,11 @@ void renameatt(Oid myrelid, RenameStmt *stmt) { renameatt_internal(myrelid, - stmt->subname, /* old att name */ - stmt->newname, /* new att name */ - interpretInhOption(stmt->relation->inhOpt), /* recursive? */ - false, /* recursing? */ - 0, /* expected inhcount */ + stmt->subname, /* old att name */ + stmt->newname, /* new att name */ + interpretInhOption(stmt->relation->inhOpt), /* recursive? */ + false, /* recursing? */ + 0, /* expected inhcount */ stmt->behavior); } @@ -2460,7 +2460,7 @@ void AlterTable(AlterTableStmt *stmt) { Relation rel; - LOCKMODE lockmode = AlterTableGetLockLevel(stmt->cmds); + LOCKMODE lockmode = AlterTableGetLockLevel(stmt->cmds); /* * Acquire same level of lock as already acquired during parsing. @@ -2531,7 +2531,7 @@ AlterTable(AlterTableStmt *stmt) } ATController(rel, stmt->cmds, interpretInhOption(stmt->relation->inhOpt), - lockmode); + lockmode); } /* @@ -2549,7 +2549,7 @@ void AlterTableInternal(Oid relid, List *cmds, bool recurse) { Relation rel; - LOCKMODE lockmode = AlterTableGetLockLevel(cmds); + LOCKMODE lockmode = AlterTableGetLockLevel(cmds); rel = relation_open(relid, lockmode); @@ -2581,31 +2581,33 @@ LOCKMODE AlterTableGetLockLevel(List *cmds) { ListCell *lcmd; - LOCKMODE lockmode = ShareUpdateExclusiveLock; + LOCKMODE lockmode = ShareUpdateExclusiveLock; foreach(lcmd, cmds) { AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lcmd); - LOCKMODE cmd_lockmode = AccessExclusiveLock; /* default for compiler */ + LOCKMODE cmd_lockmode = AccessExclusiveLock; /* default for compiler */ switch (cmd->subtype) { - /* - * Need AccessExclusiveLock for these subcommands because they - * affect or potentially affect both read and write operations. - * - * New subcommand types should be added here by default. - */ - case AT_AddColumn: /* may rewrite heap, in some cases and visible to SELECT */ - case AT_DropColumn: /* change visible to SELECT */ + /* + * Need AccessExclusiveLock for these subcommands because they + * affect or potentially affect both read and write + * operations. + * + * New subcommand types should be added here by default. + */ + case AT_AddColumn: /* may rewrite heap, in some cases and visible + * to SELECT */ + case AT_DropColumn: /* change visible to SELECT */ case AT_AddColumnToView: /* CREATE VIEW */ case AT_AlterColumnType: /* must rewrite heap */ case AT_DropConstraint: /* as DROP INDEX */ - case AT_AddOids: /* must rewrite heap */ - case AT_DropOids: /* calls AT_DropColumn */ + case AT_AddOids: /* must rewrite heap */ + case AT_DropOids: /* calls AT_DropColumn */ case AT_EnableAlwaysRule: /* may change SELECT rules */ case AT_EnableReplicaRule: /* may change SELECT rules */ - case AT_EnableRule: /* may change SELECT rules */ + case AT_EnableRule: /* may change SELECT rules */ case AT_DisableRule: /* may change SELECT rules */ case AT_ChangeOwner: /* change visible to SELECT */ case AT_SetTableSpace: /* must rewrite heap */ @@ -2615,12 +2617,12 @@ AlterTableGetLockLevel(List *cmds) cmd_lockmode = AccessExclusiveLock; break; - /* - * These subcommands affect write operations only. - */ + /* + * These subcommands affect write operations only. + */ case AT_ColumnDefault: - case AT_ProcessedConstraint: /* becomes AT_AddConstraint */ - case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */ + case AT_ProcessedConstraint: /* becomes AT_AddConstraint */ + case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */ case AT_EnableTrig: case AT_EnableAlwaysTrig: case AT_EnableReplicaTrig: @@ -2629,7 +2631,7 @@ AlterTableGetLockLevel(List *cmds) case AT_DisableTrig: case AT_DisableTrigAll: case AT_DisableTrigUser: - case AT_AddIndex: /* from ADD CONSTRAINT */ + case AT_AddIndex: /* from ADD CONSTRAINT */ case AT_AddIndexConstraint: cmd_lockmode = ShareRowExclusiveLock; break; @@ -2644,14 +2646,17 @@ AlterTableGetLockLevel(List *cmds) case CONSTR_EXCLUSION: case CONSTR_PRIMARY: case CONSTR_UNIQUE: + /* * Cases essentially the same as CREATE INDEX. We - * could reduce the lock strength to ShareLock if we - * can work out how to allow concurrent catalog updates. + * could reduce the lock strength to ShareLock if + * we can work out how to allow concurrent catalog + * updates. */ cmd_lockmode = ShareRowExclusiveLock; break; case CONSTR_FOREIGN: + /* * We add triggers to both tables when we add a * Foreign Key, so the lock level must be at least @@ -2666,26 +2671,29 @@ AlterTableGetLockLevel(List *cmds) } break; - /* - * These subcommands affect inheritance behaviour. Queries started before us - * will continue to see the old inheritance behaviour, while queries started - * after we commit will see new behaviour. No need to prevent reads or writes - * to the subtable while we hook it up though. In both cases the parent table - * is locked with AccessShareLock. - */ + /* + * These subcommands affect inheritance behaviour. Queries + * started before us will continue to see the old inheritance + * behaviour, while queries started after we commit will see + * new behaviour. No need to prevent reads or writes to the + * subtable while we hook it up though. In both cases the + * parent table is locked with AccessShareLock. + */ case AT_AddInherit: case AT_DropInherit: cmd_lockmode = ShareUpdateExclusiveLock; break; - /* - * These subcommands affect general strategies for performance and maintenance, - * though don't change the semantic results from normal data reads and writes. - * Delaying an ALTER TABLE behind currently active writes only delays the point - * where the new strategy begins to take effect, so there is no benefit in waiting. - * In this case the minimum restriction applies: we don't currently allow - * concurrent catalog updates. - */ + /* + * These subcommands affect general strategies for performance + * and maintenance, though don't change the semantic results + * from normal data reads and writes. Delaying an ALTER TABLE + * behind currently active writes only delays the point where + * the new strategy begins to take effect, so there is no + * benefit in waiting. In this case the minimum restriction + * applies: we don't currently allow concurrent catalog + * updates. + */ case AT_SetStatistics: case AT_ClusterOn: case AT_DropCluster: @@ -2698,7 +2706,7 @@ AlterTableGetLockLevel(List *cmds) cmd_lockmode = ShareUpdateExclusiveLock; break; - default: /* oops */ + default: /* oops */ elog(ERROR, "unrecognized alter table type: %d", (int) cmd->subtype); break; @@ -2773,7 +2781,7 @@ ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd, { case AT_AddColumn: /* ADD COLUMN */ ATSimplePermissions(rel, - ATT_TABLE|ATT_COMPOSITE_TYPE|ATT_FOREIGN_TABLE); + ATT_TABLE | ATT_COMPOSITE_TYPE | ATT_FOREIGN_TABLE); ATPrepAddColumn(wqueue, rel, recurse, recursing, cmd, lockmode); /* Recursion occurs during execution phase */ pass = AT_PASS_ADD_COL; @@ -2793,19 +2801,19 @@ ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd, * substitutes default values into INSERTs before it expands * rules. */ - ATSimplePermissions(rel, ATT_TABLE|ATT_VIEW); + ATSimplePermissions(rel, ATT_TABLE | ATT_VIEW); ATSimpleRecursion(wqueue, rel, cmd, recurse, lockmode); /* No command-specific prep needed */ pass = cmd->def ? AT_PASS_ADD_CONSTR : AT_PASS_DROP; break; case AT_DropNotNull: /* ALTER COLUMN DROP NOT NULL */ - ATSimplePermissions(rel, ATT_TABLE|ATT_FOREIGN_TABLE); + ATSimplePermissions(rel, ATT_TABLE | ATT_FOREIGN_TABLE); ATSimpleRecursion(wqueue, rel, cmd, recurse, lockmode); /* No command-specific prep needed */ pass = AT_PASS_DROP; break; case AT_SetNotNull: /* ALTER COLUMN SET NOT NULL */ - ATSimplePermissions(rel, ATT_TABLE|ATT_FOREIGN_TABLE); + ATSimplePermissions(rel, ATT_TABLE | ATT_FOREIGN_TABLE); ATSimpleRecursion(wqueue, rel, cmd, recurse, lockmode); /* No command-specific prep needed */ pass = AT_PASS_ADD_CONSTR; @@ -2818,7 +2826,7 @@ ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd, break; case AT_SetOptions: /* ALTER COLUMN SET ( options ) */ case AT_ResetOptions: /* ALTER COLUMN RESET ( options ) */ - ATSimplePermissions(rel, ATT_TABLE|ATT_INDEX); + ATSimplePermissions(rel, ATT_TABLE | ATT_INDEX); /* This command never recurses */ pass = AT_PASS_MISC; break; @@ -2830,7 +2838,7 @@ ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd, break; case AT_DropColumn: /* DROP COLUMN */ ATSimplePermissions(rel, - ATT_TABLE|ATT_COMPOSITE_TYPE|ATT_FOREIGN_TABLE); + ATT_TABLE | ATT_COMPOSITE_TYPE | ATT_FOREIGN_TABLE); ATPrepDropColumn(wqueue, rel, recurse, recursing, cmd, lockmode); /* Recursion occurs during execution phase */ pass = AT_PASS_DROP; @@ -2849,7 +2857,7 @@ ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd, cmd->subtype = AT_AddConstraintRecurse; pass = AT_PASS_ADD_CONSTR; break; - case AT_AddIndexConstraint: /* ADD CONSTRAINT USING INDEX */ + case AT_AddIndexConstraint: /* ADD CONSTRAINT USING INDEX */ ATSimplePermissions(rel, ATT_TABLE); /* This command never recurses */ /* No command-specific prep needed */ @@ -2865,7 +2873,7 @@ ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd, break; case AT_AlterColumnType: /* ALTER COLUMN TYPE */ ATSimplePermissions(rel, - ATT_TABLE|ATT_COMPOSITE_TYPE|ATT_FOREIGN_TABLE); + ATT_TABLE | ATT_COMPOSITE_TYPE | ATT_FOREIGN_TABLE); /* Performs own recursion */ ATPrepAlterColumnType(wqueue, tab, rel, recurse, recursing, cmd, lockmode); pass = AT_PASS_ALTER_TYPE; @@ -2904,14 +2912,14 @@ ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd, pass = AT_PASS_DROP; break; case AT_SetTableSpace: /* SET TABLESPACE */ - ATSimplePermissions(rel, ATT_TABLE|ATT_INDEX); + ATSimplePermissions(rel, ATT_TABLE | ATT_INDEX); /* This command never recurses */ ATPrepSetTableSpace(tab, rel, cmd->name, lockmode); pass = AT_PASS_MISC; /* doesn't actually matter */ break; case AT_SetRelOptions: /* SET (...) */ case AT_ResetRelOptions: /* RESET (...) */ - ATSimplePermissions(rel, ATT_TABLE|ATT_INDEX); + ATSimplePermissions(rel, ATT_TABLE | ATT_INDEX); /* This command never recurses */ /* No command-specific prep needed */ pass = AT_PASS_MISC; @@ -3072,11 +3080,11 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel, break; case AT_DropColumn: /* DROP COLUMN */ ATExecDropColumn(wqueue, rel, cmd->name, - cmd->behavior, false, false, cmd->missing_ok, lockmode); + cmd->behavior, false, false, cmd->missing_ok, lockmode); break; case AT_DropColumnRecurse: /* DROP COLUMN with recursion */ ATExecDropColumn(wqueue, rel, cmd->name, - cmd->behavior, true, false, cmd->missing_ok, lockmode); + cmd->behavior, true, false, cmd->missing_ok, lockmode); break; case AT_AddIndex: /* ADD INDEX */ ATExecAddIndex(tab, rel, (IndexStmt *) cmd->def, false, lockmode); @@ -3092,7 +3100,7 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel, ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def, true, lockmode); break; - case AT_AddIndexConstraint: /* ADD CONSTRAINT USING INDEX */ + case AT_AddIndexConstraint: /* ADD CONSTRAINT USING INDEX */ ATExecAddIndexConstraint(tab, rel, (IndexStmt *) cmd->def, lockmode); break; case AT_ValidateConstraint: @@ -3156,7 +3164,7 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel, case AT_EnableTrig: /* ENABLE TRIGGER name */ ATExecEnableDisableTrigger(rel, cmd->name, - TRIGGER_FIRES_ON_ORIGIN, false, lockmode); + TRIGGER_FIRES_ON_ORIGIN, false, lockmode); break; case AT_EnableAlwaysTrig: /* ENABLE ALWAYS TRIGGER name */ ATExecEnableDisableTrigger(rel, cmd->name, @@ -3164,7 +3172,7 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel, break; case AT_EnableReplicaTrig: /* ENABLE REPLICA TRIGGER name */ ATExecEnableDisableTrigger(rel, cmd->name, - TRIGGER_FIRES_ON_REPLICA, false, lockmode); + TRIGGER_FIRES_ON_REPLICA, false, lockmode); break; case AT_DisableTrig: /* DISABLE TRIGGER name */ ATExecEnableDisableTrigger(rel, cmd->name, @@ -3172,7 +3180,7 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel, break; case AT_EnableTrigAll: /* ENABLE TRIGGER ALL */ ATExecEnableDisableTrigger(rel, NULL, - TRIGGER_FIRES_ON_ORIGIN, false, lockmode); + TRIGGER_FIRES_ON_ORIGIN, false, lockmode); break; case AT_DisableTrigAll: /* DISABLE TRIGGER ALL */ ATExecEnableDisableTrigger(rel, NULL, @@ -3180,7 +3188,7 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel, break; case AT_EnableTrigUser: /* ENABLE TRIGGER USER */ ATExecEnableDisableTrigger(rel, NULL, - TRIGGER_FIRES_ON_ORIGIN, true, lockmode); + TRIGGER_FIRES_ON_ORIGIN, true, lockmode); break; case AT_DisableTrigUser: /* DISABLE TRIGGER USER */ ATExecEnableDisableTrigger(rel, NULL, @@ -3254,8 +3262,8 @@ ATRewriteTables(List **wqueue, LOCKMODE lockmode) * (Eventually we'll probably need to check for composite type * dependencies even when we're just scanning the table without a * rewrite, but at the moment a composite type does not enforce any - * constraints, so it's not necessary/appropriate to enforce them - * just during ALTER.) + * constraints, so it's not necessary/appropriate to enforce them just + * during ALTER.) */ if (tab->newvals != NIL || tab->rewrite) { @@ -3386,8 +3394,8 @@ ATRewriteTables(List **wqueue, LOCKMODE lockmode) con->conid); /* - * No need to mark the constraint row as validated, - * we did that when we inserted the row earlier. + * No need to mark the constraint row as validated, we did + * that when we inserted the row earlier. */ heap_close(refrel, NoLock); @@ -3723,7 +3731,7 @@ ATGetQueueEntry(List **wqueue, Relation rel) static void ATSimplePermissions(Relation rel, int allowed_targets) { - int actual_target; + int actual_target; switch (rel->rd_rel->relkind) { @@ -3779,16 +3787,16 @@ ATWrongRelkindError(Relation rel, int allowed_targets) case ATT_TABLE: msg = _("\"%s\" is not a table"); break; - case ATT_TABLE|ATT_INDEX: + case ATT_TABLE | ATT_INDEX: msg = _("\"%s\" is not a table or index"); break; - case ATT_TABLE|ATT_VIEW: + case ATT_TABLE | ATT_VIEW: msg = _("\"%s\" is not a table or view"); break; - case ATT_TABLE|ATT_FOREIGN_TABLE: + case ATT_TABLE | ATT_FOREIGN_TABLE: msg = _("\"%s\" is not a table or foreign table"); break; - case ATT_TABLE|ATT_COMPOSITE_TYPE|ATT_FOREIGN_TABLE: + case ATT_TABLE | ATT_COMPOSITE_TYPE | ATT_FOREIGN_TABLE: msg = _("\"%s\" is not a table, composite type, or foreign table"); break; case ATT_VIEW: @@ -4032,7 +4040,7 @@ find_typed_table_dependencies(Oid typeOid, const char *typeName, DropBehavior be (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST), errmsg("cannot alter type \"%s\" because it is the type of a typed table", typeName), - errhint("Use ALTER ... CASCADE to alter the typed tables too."))); + errhint("Use ALTER ... CASCADE to alter the typed tables too."))); else result = lappend_oid(result, HeapTupleGetOid(tuple)); } @@ -4103,9 +4111,9 @@ ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel, /* * Are we adding the column to a recursion child? If so, check whether to - * merge with an existing definition for the column. If we do merge, - * we must not recurse. Children will already have the column, and - * recursing into them would mess up attinhcount. + * merge with an existing definition for the column. If we do merge, we + * must not recurse. Children will already have the column, and recursing + * into them would mess up attinhcount. */ if (colDef->inhcount > 0) { @@ -4133,10 +4141,10 @@ ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel, ereport(ERROR, (errcode(ERRCODE_COLLATION_MISMATCH), errmsg("child table \"%s\" has different collation for column \"%s\"", - RelationGetRelationName(rel), colDef->colname), + RelationGetRelationName(rel), colDef->colname), errdetail("\"%s\" versus \"%s\"", get_collation_name(ccollid), - get_collation_name(childatt->attcollation)))); + get_collation_name(childatt->attcollation)))); /* If it's OID, child column must actually be OID */ if (isOid && childatt->attnum != ObjectIdAttributeNumber) @@ -4265,7 +4273,7 @@ ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel, if (relkind == RELKIND_FOREIGN_TABLE) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("default values on foreign tables are not supported"))); + errmsg("default values on foreign tables are not supported"))); rawEnt = (RawColumnDefault *) palloc(sizeof(RawColumnDefault)); rawEnt->attnum = attribute.attnum; @@ -5170,10 +5178,11 @@ ATExecAddIndexConstraint(AlteredTableInfo *tab, Relation rel, elog(ERROR, "index \"%s\" is not unique", indexName); /* - * Determine name to assign to constraint. We require a constraint to + * Determine name to assign to constraint. We require a constraint to * have the same name as the underlying index; therefore, use the index's - * existing name as the default constraint name, and if the user explicitly - * gives some other name for the constraint, rename the index to match. + * existing name as the default constraint name, and if the user + * explicitly gives some other name for the constraint, rename the index + * to match. */ constraintName = stmt->idxname; if (constraintName == NULL) @@ -5216,7 +5225,7 @@ ATExecAddIndexConstraint(AlteredTableInfo *tab, Relation rel, */ static void ATExecAddConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, - Constraint *newConstraint, bool recurse, LOCKMODE lockmode) + Constraint *newConstraint, bool recurse, LOCKMODE lockmode) { Assert(IsA(newConstraint, Constraint)); @@ -5337,9 +5346,9 @@ ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, /* * If the constraint got merged with an existing constraint, we're done. - * We mustn't recurse to child tables in this case, because they've already - * got the constraint, and visiting them again would lead to an incorrect - * value for coninhcount. + * We mustn't recurse to child tables in this case, because they've + * already got the constraint, and visiting them again would lead to an + * incorrect value for coninhcount. */ if (newcons == NIL) return; @@ -5655,8 +5664,8 @@ ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel, /* * Tell Phase 3 to check that the constraint is satisfied by existing rows - * We can skip this during table creation or if requested explicitly - * by specifying NOT VALID on an alter table statement. + * We can skip this during table creation or if requested explicitly by + * specifying NOT VALID on an alter table statement. */ if (!fkconstraint->skip_validation) { @@ -5718,8 +5727,8 @@ ATExecValidateConstraint(Relation rel, const char *constrName) if (!found) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), - errmsg("foreign key constraint \"%s\" of relation \"%s\" does not exist", - constrName, RelationGetRelationName(rel)))); + errmsg("foreign key constraint \"%s\" of relation \"%s\" does not exist", + constrName, RelationGetRelationName(rel)))); if (!con->convalidated) { @@ -5729,17 +5738,16 @@ ATExecValidateConstraint(Relation rel, const char *constrName) Relation refrel; /* - * Triggers are already in place on both tables, so a - * concurrent write that alters the result here is not - * possible. Normally we can run a query here to do the - * validation, which would only require AccessShareLock. - * In some cases, it is possible that we might need to - * fire triggers to perform the check, so we take a lock - * at RowShareLock level just in case. + * Triggers are already in place on both tables, so a concurrent write + * that alters the result here is not possible. Normally we can run a + * query here to do the validation, which would only require + * AccessShareLock. In some cases, it is possible that we might need + * to fire triggers to perform the check, so we take a lock at + * RowShareLock level just in case. */ refrel = heap_open(con->confrelid, RowShareLock); - validateForeignKeyConstraint((char *)constrName, rel, refrel, + validateForeignKeyConstraint((char *) constrName, rel, refrel, con->conindid, conid); @@ -6571,12 +6579,12 @@ ATPrepAlterColumnType(List **wqueue, if (tab->relkind == RELKIND_RELATION) { /* - * Set up an expression to transform the old data value to the new type. - * If a USING option was given, transform and use that expression, else - * just take the old value and try to coerce it. We do this first so that - * type incompatibility can be detected before we waste effort, and - * because we need the expression to be parsed against the original table - * rowtype. + * Set up an expression to transform the old data value to the new + * type. If a USING option was given, transform and use that + * expression, else just take the old value and try to coerce it. We + * do this first so that type incompatibility can be detected before + * we waste effort, and because we need the expression to be parsed + * against the original table rowtype. */ if (transform) { @@ -6596,13 +6604,13 @@ ATPrepAlterColumnType(List **wqueue, if (expression_returns_set(transform)) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), - errmsg("transform expression must not return a set"))); + errmsg("transform expression must not return a set"))); /* No subplans or aggregates, either... */ if (pstate->p_hasSubLinks) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("cannot use subquery in transform expression"))); + errmsg("cannot use subquery in transform expression"))); if (pstate->p_hasAggs) ereport(ERROR, (errcode(ERRCODE_GROUPING_ERROR), @@ -6615,7 +6623,7 @@ ATPrepAlterColumnType(List **wqueue, else { transform = (Node *) makeVar(1, attnum, - attTup->atttypid, attTup->atttypmod, attTup->attcollation, + attTup->atttypid, attTup->atttypmod, attTup->attcollation, 0); } @@ -6649,14 +6657,14 @@ ATPrepAlterColumnType(List **wqueue, else if (transform) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("ALTER TYPE USING is only supported on plain tables"))); + errmsg("ALTER TYPE USING is only supported on plain tables"))); if (tab->relkind == RELKIND_COMPOSITE_TYPE || tab->relkind == RELKIND_FOREIGN_TABLE) { /* - * For composite types, do this check now. Tables will check - * it later when the table is being rewritten. + * For composite types, do this check now. Tables will check it later + * when the table is being rewritten. */ find_composite_type_dependencies(rel->rd_rel->reltype, rel, NULL); } @@ -6699,7 +6707,7 @@ ATColumnChangeRequiresRewrite(Node *expr, AttrNumber varattno) for (;;) { /* only one varno, so no need to check that */ - if (IsA(expr, Var) && ((Var *) expr)->varattno == varattno) + if (IsA(expr, Var) &&((Var *) expr)->varattno == varattno) return false; else if (IsA(expr, RelabelType)) expr = (Node *) ((RelabelType *) expr)->arg; @@ -6924,13 +6932,14 @@ ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel, break; case OCLASS_TRIGGER: + /* * A trigger can depend on a column because the column is * specified as an update target, or because the column is * used in the trigger's WHEN condition. The first case would * not require any extra work, but the second case would * require updating the WHEN expression, which will take a - * significant amount of new code. Since we can't easily tell + * significant amount of new code. Since we can't easily tell * which case applies, we punt for both. FIXME someday. */ ereport(ERROR, @@ -7940,7 +7949,7 @@ copy_relation_data(SMgrRelation src, SMgrRelation dst, */ static void ATExecEnableDisableTrigger(Relation rel, char *trigname, - char fires_when, bool skip_system, LOCKMODE lockmode) + char fires_when, bool skip_system, LOCKMODE lockmode) { EnableDisableTrigger(rel, trigname, fires_when, skip_system); } @@ -8558,18 +8567,18 @@ ATExecDropInherit(Relation rel, RangeVar *parent, LOCKMODE lockmode) static void ATExecGenericOptions(Relation rel, List *options) { - Relation ftrel; - ForeignServer *server; + Relation ftrel; + ForeignServer *server; ForeignDataWrapper *fdw; - HeapTuple tuple; - bool isnull; - Datum repl_val[Natts_pg_foreign_table]; - bool repl_null[Natts_pg_foreign_table]; - bool repl_repl[Natts_pg_foreign_table]; - Datum datum; - Form_pg_foreign_table tableform; - - if (options == NIL) + HeapTuple tuple; + bool isnull; + Datum repl_val[Natts_pg_foreign_table]; + bool repl_null[Natts_pg_foreign_table]; + bool repl_repl[Natts_pg_foreign_table]; + Datum datum; + Form_pg_foreign_table tableform; + + if (options == NIL) return; ftrel = heap_open(ForeignTableRelationId, RowExclusiveLock); @@ -8579,7 +8588,7 @@ ATExecGenericOptions(Relation rel, List *options) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("foreign table \"%s\" does not exist", - RelationGetRelationName(rel)))); + RelationGetRelationName(rel)))); tableform = (Form_pg_foreign_table) GETSTRUCT(tuple); server = GetForeignServer(tableform->ftserver); fdw = GetForeignDataWrapper(server->fdwid); @@ -8718,8 +8727,8 @@ AlterTableNamespace(RangeVar *relation, const char *newschema, default: ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("\"%s\" is not a table, view, sequence, or foreign table", - RelationGetRelationName(rel)))); + errmsg("\"%s\" is not a table, view, sequence, or foreign table", + RelationGetRelationName(rel)))); } /* get schema OID and check its permissions */ @@ -8836,7 +8845,7 @@ AlterIndexNamespaces(Relation classRel, Relation rel, */ static void AlterSeqNamespaces(Relation classRel, Relation rel, - Oid oldNspOid, Oid newNspOid, const char *newNspName, LOCKMODE lockmode) + Oid oldNspOid, Oid newNspOid, const char *newNspName, LOCKMODE lockmode) { Relation depRel; SysScanDesc scan; diff --git a/src/backend/commands/tablespace.c b/src/backend/commands/tablespace.c index 42a704beb16..3024dc4b646 100644 --- a/src/backend/commands/tablespace.c +++ b/src/backend/commands/tablespace.c @@ -559,7 +559,7 @@ create_tablespace_directories(const char *location, const Oid tablespaceoid) (errcode(ERRCODE_UNDEFINED_FILE), errmsg("directory \"%s\" does not exist", location), InRecovery ? errhint("Create this directory for the tablespace before " - "restarting the server."): 0)); + "restarting the server.") : 0)); else ereport(ERROR, (errcode_for_file_access(), @@ -573,8 +573,8 @@ create_tablespace_directories(const char *location, const Oid tablespaceoid) /* * Our theory for replaying a CREATE is to forcibly drop the target - * subdirectory if present, and then recreate it. This may be - * more work than needed, but it is simple to implement. + * subdirectory if present, and then recreate it. This may be more + * work than needed, but it is simple to implement. */ if (stat(location_with_version_dir, &st) == 0 && S_ISDIR(st.st_mode)) { @@ -1353,10 +1353,10 @@ get_tablespace_oid(const char *tablespacename, bool missing_ok) heap_close(rel, AccessShareLock); if (!OidIsValid(result) && !missing_ok) - ereport(ERROR, - (errcode(ERRCODE_UNDEFINED_OBJECT), - errmsg("tablespace \"%s\" does not exist", - tablespacename))); + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_OBJECT), + errmsg("tablespace \"%s\" does not exist", + tablespacename))); return result; } diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c index 329d4d95f15..6b1ade89903 100644 --- a/src/backend/commands/trigger.c +++ b/src/backend/commands/trigger.c @@ -144,11 +144,11 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString, referenced; /* - * ShareRowExclusiveLock is sufficient to prevent concurrent write activity - * to the relation, and thus to lock out any operations that might want to - * fire triggers on the relation. If we had ON SELECT triggers we would - * need to take an AccessExclusiveLock to add one of those, just as we do - * with ON SELECT rules. + * ShareRowExclusiveLock is sufficient to prevent concurrent write + * activity to the relation, and thus to lock out any operations that + * might want to fire triggers on the relation. If we had ON SELECT + * triggers we would need to take an AccessExclusiveLock to add one of + * those, just as we do with ON SELECT rules. */ rel = heap_openrv(stmt->relation, ShareRowExclusiveLock); @@ -244,7 +244,7 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString, if (stmt->whenClause) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("INSTEAD OF triggers cannot have WHEN conditions"))); + errmsg("INSTEAD OF triggers cannot have WHEN conditions"))); if (stmt->columns != NIL) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), @@ -480,8 +480,8 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString, * can skip this for internally generated triggers, since the name * modification above should be sufficient. * - * NOTE that this is cool only because we have ShareRowExclusiveLock on the - * relation, so the trigger set won't be changing underneath us. + * NOTE that this is cool only because we have ShareRowExclusiveLock on + * the relation, so the trigger set won't be changing underneath us. */ if (!isInternal) { @@ -1036,8 +1036,8 @@ DropTrigger(Oid relid, const char *trigname, DropBehavior behavior, if (!OidIsValid(object.objectId)) { ereport(NOTICE, - (errmsg("trigger \"%s\" for table \"%s\" does not exist, skipping", - trigname, get_rel_name(relid)))); + (errmsg("trigger \"%s\" for table \"%s\" does not exist, skipping", + trigname, get_rel_name(relid)))); return; } @@ -1083,9 +1083,9 @@ RemoveTriggerById(Oid trigOid) /* * Open and lock the relation the trigger belongs to. As in - * CreateTrigger, this is sufficient to lock out all operations that - * could fire or add triggers; but it would need to be revisited if - * we had ON SELECT triggers. + * CreateTrigger, this is sufficient to lock out all operations that could + * fire or add triggers; but it would need to be revisited if we had ON + * SELECT triggers. */ relid = ((Form_pg_trigger) GETSTRUCT(tup))->tgrelid; @@ -1960,7 +1960,7 @@ ExecBRInsertTriggers(EState *estate, ResultRelInfo *relinfo, if (newtuple != slottuple) { /* - * Return the modified tuple using the es_trig_tuple_slot. We assume + * Return the modified tuple using the es_trig_tuple_slot. We assume * the tuple was allocated in per-tuple memory context, and therefore * will go away by itself. The tuple table slot should not try to * clear it. @@ -2035,7 +2035,7 @@ ExecIRInsertTriggers(EState *estate, ResultRelInfo *relinfo, if (newtuple != slottuple) { /* - * Return the modified tuple using the es_trig_tuple_slot. We assume + * Return the modified tuple using the es_trig_tuple_slot. We assume * the tuple was allocated in per-tuple memory context, and therefore * will go away by itself. The tuple table slot should not try to * clear it. @@ -2378,7 +2378,7 @@ ExecBRUpdateTriggers(EState *estate, EPQState *epqstate, if (newtuple != slottuple) { /* - * Return the modified tuple using the es_trig_tuple_slot. We assume + * Return the modified tuple using the es_trig_tuple_slot. We assume * the tuple was allocated in per-tuple memory context, and therefore * will go away by itself. The tuple table slot should not try to * clear it. @@ -2461,7 +2461,7 @@ ExecIRUpdateTriggers(EState *estate, ResultRelInfo *relinfo, if (newtuple != slottuple) { /* - * Return the modified tuple using the es_trig_tuple_slot. We assume + * Return the modified tuple using the es_trig_tuple_slot. We assume * the tuple was allocated in per-tuple memory context, and therefore * will go away by itself. The tuple table slot should not try to * clear it. @@ -2891,7 +2891,7 @@ typedef struct AfterTriggerEventDataOneCtid { TriggerFlags ate_flags; /* status bits and offset to shared data */ ItemPointerData ate_ctid1; /* inserted, deleted, or old updated tuple */ -} AfterTriggerEventDataOneCtid; +} AfterTriggerEventDataOneCtid; #define SizeofTriggerEvent(evt) \ (((evt)->ate_flags & AFTER_TRIGGER_2CTIDS) ? \ diff --git a/src/backend/commands/tsearchcmds.c b/src/backend/commands/tsearchcmds.c index 81f129dff6b..80a30e180dc 100644 --- a/src/backend/commands/tsearchcmds.c +++ b/src/backend/commands/tsearchcmds.c @@ -407,7 +407,8 @@ RenameTSParser(List *oldname, const char *newname) void AlterTSParserNamespace(List *name, const char *newschema) { - Oid prsId, nspOid; + Oid prsId, + nspOid; Relation rel; rel = heap_open(TSParserRelationId, RowExclusiveLock); @@ -429,7 +430,7 @@ AlterTSParserNamespace(List *name, const char *newschema) Oid AlterTSParserNamespace_oid(Oid prsId, Oid newNspOid) { - Oid oldNspOid; + Oid oldNspOid; Relation rel; rel = heap_open(TSParserRelationId, RowExclusiveLock); @@ -685,7 +686,8 @@ RenameTSDictionary(List *oldname, const char *newname) void AlterTSDictionaryNamespace(List *name, const char *newschema) { - Oid dictId, nspOid; + Oid dictId, + nspOid; Relation rel; rel = heap_open(TSDictionaryRelationId, RowExclusiveLock); @@ -708,7 +710,7 @@ AlterTSDictionaryNamespace(List *name, const char *newschema) Oid AlterTSDictionaryNamespace_oid(Oid dictId, Oid newNspOid) { - Oid oldNspOid; + Oid oldNspOid; Relation rel; rel = heap_open(TSDictionaryRelationId, RowExclusiveLock); @@ -1218,7 +1220,8 @@ RenameTSTemplate(List *oldname, const char *newname) void AlterTSTemplateNamespace(List *name, const char *newschema) { - Oid tmplId, nspOid; + Oid tmplId, + nspOid; Relation rel; rel = heap_open(TSTemplateRelationId, RowExclusiveLock); @@ -1240,7 +1243,7 @@ AlterTSTemplateNamespace(List *name, const char *newschema) Oid AlterTSTemplateNamespace_oid(Oid tmplId, Oid newNspOid) { - Oid oldNspOid; + Oid oldNspOid; Relation rel; rel = heap_open(TSTemplateRelationId, RowExclusiveLock); @@ -1668,7 +1671,8 @@ RenameTSConfiguration(List *oldname, const char *newname) void AlterTSConfigurationNamespace(List *name, const char *newschema) { - Oid cfgId, nspOid; + Oid cfgId, + nspOid; Relation rel; rel = heap_open(TSConfigRelationId, RowExclusiveLock); @@ -1691,7 +1695,7 @@ AlterTSConfigurationNamespace(List *name, const char *newschema) Oid AlterTSConfigurationNamespace_oid(Oid cfgId, Oid newNspOid) { - Oid oldNspOid; + Oid oldNspOid; Relation rel; rel = heap_open(TSConfigRelationId, RowExclusiveLock); diff --git a/src/backend/commands/typecmds.c b/src/backend/commands/typecmds.c index 4c06d898a88..1a20b0d91be 100644 --- a/src/backend/commands/typecmds.c +++ b/src/backend/commands/typecmds.c @@ -138,7 +138,7 @@ DefineType(List *names, List *parameters) DefElem *byValueEl = NULL; DefElem *alignmentEl = NULL; DefElem *storageEl = NULL; - DefElem *collatableEl = NULL; + DefElem *collatableEl = NULL; Oid inputOid; Oid outputOid; Oid receiveOid = InvalidOid; @@ -537,7 +537,7 @@ DefineType(List *names, List *parameters) * now have TypeCreate do all the real work. * * Note: the pg_type.oid is stored in user tables as array elements (base - * types) in ArrayType and in composite types in DatumTupleFields. This + * types) in ArrayType and in composite types in DatumTupleFields. This * oid must be preserved by binary upgrades. */ typoid = @@ -1179,7 +1179,7 @@ DefineEnum(CreateEnumStmt *stmt) -1, /* typMod (Domains only) */ 0, /* Array dimensions of typbasetype */ false, /* Type NOT NULL */ - InvalidOid); /* typcollation */ + InvalidOid); /* typcollation */ /* Enter the enum's values into pg_enum */ EnumValuesCreate(enumTypeOid, stmt->vals); @@ -2416,7 +2416,7 @@ domainAddConstraint(Oid domainOid, Oid domainNamespace, Oid baseTypeOid, CONSTRAINT_CHECK, /* Constraint Type */ false, /* Is Deferrable */ false, /* Is Deferred */ - true, /* Is Validated */ + true, /* Is Validated */ InvalidOid, /* not a relation constraint */ NULL, 0, diff --git a/src/backend/commands/user.c b/src/backend/commands/user.c index f13eb2891e2..9c9164d3bc7 100644 --- a/src/backend/commands/user.c +++ b/src/backend/commands/user.c @@ -84,7 +84,7 @@ CreateRole(CreateRoleStmt *stmt) bool createrole = false; /* Can this user create roles? */ bool createdb = false; /* Can the user create databases? */ bool canlogin = false; /* Can this user login? */ - bool isreplication = false; /* Is this a replication role? */ + bool isreplication = false; /* Is this a replication role? */ int connlimit = -1; /* maximum connections allowed */ List *addroleto = NIL; /* roles to make this a member of */ List *rolemembers = NIL; /* roles to be members of this role */ @@ -98,7 +98,7 @@ CreateRole(CreateRoleStmt *stmt) DefElem *dcreaterole = NULL; DefElem *dcreatedb = NULL; DefElem *dcanlogin = NULL; - DefElem *disreplication = NULL; + DefElem *disreplication = NULL; DefElem *dconnlimit = NULL; DefElem *daddroleto = NULL; DefElem *drolemembers = NULL; @@ -240,9 +240,10 @@ CreateRole(CreateRoleStmt *stmt) if (dissuper) { issuper = intVal(dissuper->arg) != 0; + /* - * Superusers get replication by default, but only if - * NOREPLICATION wasn't explicitly mentioned + * Superusers get replication by default, but only if NOREPLICATION + * wasn't explicitly mentioned */ if (!(disreplication && intVal(disreplication->arg) == 0)) isreplication = 1; @@ -287,7 +288,7 @@ CreateRole(CreateRoleStmt *stmt) if (!superuser()) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), - errmsg("must be superuser to create replication users"))); + errmsg("must be superuser to create replication users"))); } else { @@ -384,8 +385,8 @@ CreateRole(CreateRoleStmt *stmt) tuple = heap_form_tuple(pg_authid_dsc, new_record, new_record_nulls); /* - * pg_largeobject_metadata contains pg_authid.oid's, so we - * use the binary-upgrade override, if specified. + * pg_largeobject_metadata contains pg_authid.oid's, so we use the + * binary-upgrade override, if specified. */ if (OidIsValid(binary_upgrade_next_pg_authid_oid)) { @@ -467,7 +468,7 @@ AlterRole(AlterRoleStmt *stmt) int createrole = -1; /* Can this user create roles? */ int createdb = -1; /* Can the user create databases? */ int canlogin = -1; /* Can this user login? */ - int isreplication = -1; /* Is this a replication role? */ + int isreplication = -1; /* Is this a replication role? */ int connlimit = -1; /* maximum connections allowed */ List *rolemembers = NIL; /* roles to be added/removed */ char *validUntil = NULL; /* time the login is valid until */ @@ -479,7 +480,7 @@ AlterRole(AlterRoleStmt *stmt) DefElem *dcreaterole = NULL; DefElem *dcreatedb = NULL; DefElem *dcanlogin = NULL; - DefElem *disreplication = NULL; + DefElem *disreplication = NULL; DefElem *dconnlimit = NULL; DefElem *drolemembers = NULL; DefElem *dvalidUntil = NULL; diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c index 1651aa94dc2..90c413a9880 100644 --- a/src/backend/commands/vacuum.c +++ b/src/backend/commands/vacuum.c @@ -527,7 +527,7 @@ vac_update_relstats(Relation relation, /* * If we have discovered that there are no indexes, then there's no - * primary key either. This could be done more thoroughly... + * primary key either. This could be done more thoroughly... */ if (pgcform->relhaspkey && !hasindex) { @@ -839,8 +839,8 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, bool for_wraparound, * There's a race condition here: the rel may have gone away since the * last time we saw it. If so, we don't need to vacuum it. * - * If we've been asked not to wait for the relation lock, acquire it - * first in non-blocking mode, before calling try_relation_open(). + * If we've been asked not to wait for the relation lock, acquire it first + * in non-blocking mode, before calling try_relation_open(). */ if (!(vacstmt->options & VACOPT_NOWAIT)) onerel = try_relation_open(relid, lmode); @@ -852,8 +852,8 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, bool for_wraparound, if (IsAutoVacuumWorkerProcess() && Log_autovacuum_min_duration >= 0) ereport(LOG, (errcode(ERRCODE_LOCK_NOT_AVAILABLE), - errmsg("skipping vacuum of \"%s\" --- lock not available", - vacstmt->relation->relname))); + errmsg("skipping vacuum of \"%s\" --- lock not available", + vacstmt->relation->relname))); } if (!onerel) diff --git a/src/backend/commands/vacuumlazy.c b/src/backend/commands/vacuumlazy.c index a5c024cc19b..9393fa0727a 100644 --- a/src/backend/commands/vacuumlazy.c +++ b/src/backend/commands/vacuumlazy.c @@ -705,15 +705,16 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats, PageSetAllVisible(page); SetBufferCommitInfoNeedsSave(buf); } + /* * It's possible for the value returned by GetOldestXmin() to move * backwards, so it's not wrong for us to see tuples that appear to * not be visible to everyone yet, while PD_ALL_VISIBLE is already * set. The real safe xmin value never moves backwards, but * GetOldestXmin() is conservative and sometimes returns a value - * that's unnecessarily small, so if we see that contradiction it - * just means that the tuples that we think are not visible to - * everyone yet actually are, and the PD_ALL_VISIBLE flag is correct. + * that's unnecessarily small, so if we see that contradiction it just + * means that the tuples that we think are not visible to everyone yet + * actually are, and the PD_ALL_VISIBLE flag is correct. * * There should never be dead tuples on a page with PD_ALL_VISIBLE * set, however. diff --git a/src/backend/commands/variable.c b/src/backend/commands/variable.c index 2cec7130896..5d0fbdfb40f 100644 --- a/src/backend/commands/variable.c +++ b/src/backend/commands/variable.c @@ -132,8 +132,8 @@ check_datestyle(char **newval, void **extra, GucSource source) * We can't simply "return check_datestyle(...)" because we need * to handle constructs like "DEFAULT, ISO". */ - char *subval; - void *subextra = NULL; + char *subval; + void *subextra = NULL; subval = strdup(GetConfigOptionResetString("datestyle")); if (!subval) @@ -262,9 +262,9 @@ check_timezone(char **newval, void **extra, GucSource source) { /* * The boot_val given for TimeZone in guc.c is NULL. When we see this - * we just do nothing. If this isn't overridden from the config file + * we just do nothing. If this isn't overridden from the config file * then pg_timezone_initialize() will eventually select a default - * value from the environment. This hack has two purposes: to avoid + * value from the environment. This hack has two purposes: to avoid * wasting cycles loading values that might soon be overridden from * the config file, and to avoid trying to read the timezone files * during InitializeGUCOptions(). The latter doesn't work in an @@ -289,7 +289,7 @@ check_timezone(char **newval, void **extra, GucSource source) if (pg_strncasecmp(*newval, "interval", 8) == 0) { /* - * Support INTERVAL 'foo'. This is for SQL spec compliance, not + * Support INTERVAL 'foo'. This is for SQL spec compliance, not * because it has any actual real-world usefulness. */ const char *valueptr = *newval; @@ -391,13 +391,13 @@ check_timezone(char **newval, void **extra, GucSource source) * * Note: the result string should be something that we'd accept as input. * We use the numeric format for interval cases, because it's simpler to - * reload. In the named-timezone case, *newval is already OK and need not + * reload. In the named-timezone case, *newval is already OK and need not * be changed; it might not have the canonical casing, but that's taken * care of by show_timezone. */ if (myextra.HasCTZSet) { - char *result = (char *) malloc(64); + char *result = (char *) malloc(64); if (!result) return false; @@ -567,7 +567,7 @@ show_log_timezone(void) * We allow idempotent changes (r/w -> r/w and r/o -> r/o) at any time, and * we also always allow changes from read-write to read-only. However, * read-only may be changed to read-write only when in a top-level transaction - * that has not yet taken an initial snapshot. Can't do it in a hot standby + * that has not yet taken an initial snapshot. Can't do it in a hot standby * slave, either. */ bool @@ -719,7 +719,7 @@ check_transaction_deferrable(bool *newval, void **extra, GucSource source) * * We can't roll back the random sequence on error, and we don't want * config file reloads to affect it, so we only want interactive SET SEED - * commands to set it. We use the "extra" storage to ensure that rollbacks + * commands to set it. We use the "extra" storage to ensure that rollbacks * don't try to do the operation again. */ @@ -851,8 +851,8 @@ check_session_authorization(char **newval, void **extra, GucSource source) { /* * Can't do catalog lookups, so fail. The result of this is that - * session_authorization cannot be set in postgresql.conf, which - * seems like a good thing anyway, so we don't work hard to avoid it. + * session_authorization cannot be set in postgresql.conf, which seems + * like a good thing anyway, so we don't work hard to avoid it. */ return false; } @@ -977,7 +977,7 @@ const char * show_role(void) { /* - * Check whether SET ROLE is active; if not return "none". This is a + * Check whether SET ROLE is active; if not return "none". This is a * kluge to deal with the fact that SET SESSION AUTHORIZATION logically * resets SET ROLE to NONE, but we cannot set the GUC role variable from * assign_session_authorization (because we haven't got enough info to diff --git a/src/backend/commands/view.c b/src/backend/commands/view.c index 508fb23c9ac..be681e3fd4f 100644 --- a/src/backend/commands/view.c +++ b/src/backend/commands/view.c @@ -120,7 +120,7 @@ DefineVirtualRelation(const RangeVar *relation, List *tlist, bool replace) def->colname = pstrdup(tle->resname); def->typeName = makeTypeNameFromOid(exprType((Node *) tle->expr), - exprTypmod((Node *) tle->expr)); + exprTypmod((Node *) tle->expr)); def->inhcount = 0; def->is_local = true; def->is_not_null = false; @@ -130,6 +130,7 @@ DefineVirtualRelation(const RangeVar *relation, List *tlist, bool replace) def->cooked_default = NULL; def->collClause = NULL; def->collOid = exprCollation((Node *) tle->expr); + /* * It's possible that the column is of a collatable type but the * collation could not be resolved, so double-check. @@ -240,7 +241,7 @@ DefineVirtualRelation(const RangeVar *relation, List *tlist, bool replace) } else { - Oid relid; + Oid relid; /* * now set the parameters for keys/inheritance etc. All of these are @@ -437,8 +438,8 @@ DefineView(ViewStmt *stmt, const char *queryString) /* * Check for unsupported cases. These tests are redundant with ones in - * DefineQueryRewrite(), but that function will complain about a bogus - * ON SELECT rule, and we'd rather the message complain about a view. + * DefineQueryRewrite(), but that function will complain about a bogus ON + * SELECT rule, and we'd rather the message complain about a view. */ if (viewParse->intoClause != NULL) ereport(ERROR, @@ -447,7 +448,7 @@ DefineView(ViewStmt *stmt, const char *queryString) if (viewParse->hasModifyingCTE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("views must not contain data-modifying statements in WITH"))); + errmsg("views must not contain data-modifying statements in WITH"))); /* * If a list of column names was given, run through and insert these into @@ -500,7 +501,7 @@ DefineView(ViewStmt *stmt, const char *queryString) if (view->relpersistence == RELPERSISTENCE_UNLOGGED) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), - errmsg("views cannot be unlogged because they do not have storage"))); + errmsg("views cannot be unlogged because they do not have storage"))); /* * Create the view relation diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c index caa9faea87f..86ec9870198 100644 --- a/src/backend/executor/execMain.c +++ b/src/backend/executor/execMain.c @@ -19,7 +19,7 @@ * ExecutorRun accepts direction and count arguments that specify whether * the plan is to be executed forwards, backwards, and for how many tuples. * In some cases ExecutorRun may be called multiple times to process all - * the tuples for a plan. It is also acceptable to stop short of executing + * the tuples for a plan. It is also acceptable to stop short of executing * the whole plan (but only if it is a SELECT). * * ExecutorFinish must be called after the final ExecutorRun call and @@ -168,6 +168,7 @@ standard_ExecutorStart(QueryDesc *queryDesc, int eflags) switch (queryDesc->operation) { case CMD_SELECT: + /* * SELECT INTO, SELECT FOR UPDATE/SHARE and modifying CTEs need to * mark tuples @@ -332,12 +333,12 @@ standard_ExecutorRun(QueryDesc *queryDesc, * ExecutorFinish * * This routine must be called after the last ExecutorRun call. - * It performs cleanup such as firing AFTER triggers. It is + * It performs cleanup such as firing AFTER triggers. It is * separate from ExecutorEnd because EXPLAIN ANALYZE needs to * include these actions in the total runtime. * * We provide a function hook variable that lets loadable plugins - * get control when ExecutorFinish is called. Such a plugin would + * get control when ExecutorFinish is called. Such a plugin would * normally call standard_ExecutorFinish(). * * ---------------------------------------------------------------- @@ -425,9 +426,9 @@ standard_ExecutorEnd(QueryDesc *queryDesc) Assert(estate != NULL); /* - * Check that ExecutorFinish was called, unless in EXPLAIN-only mode. - * This Assert is needed because ExecutorFinish is new as of 9.1, and - * callers might forget to call it. + * Check that ExecutorFinish was called, unless in EXPLAIN-only mode. This + * Assert is needed because ExecutorFinish is new as of 9.1, and callers + * might forget to call it. */ Assert(estate->es_finished || (estate->es_top_eflags & EXEC_FLAG_EXPLAIN_ONLY)); @@ -519,7 +520,7 @@ ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation) foreach(l, rangeTable) { - RangeTblEntry *rte = (RangeTblEntry *) lfirst(l); + RangeTblEntry *rte = (RangeTblEntry *) lfirst(l); result = ExecCheckRTEPerms(rte); if (!result) @@ -533,8 +534,8 @@ ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation) } if (ExecutorCheckPerms_hook) - result = (*ExecutorCheckPerms_hook)(rangeTable, - ereport_on_violation); + result = (*ExecutorCheckPerms_hook) (rangeTable, + ereport_on_violation); return result; } @@ -980,7 +981,7 @@ InitPlan(QueryDesc *queryDesc, int eflags) void CheckValidResultRel(Relation resultRel, CmdType operation) { - TriggerDesc *trigDesc = resultRel->trigdesc; + TriggerDesc *trigDesc = resultRel->trigdesc; switch (resultRel->rd_rel->relkind) { @@ -1005,26 +1006,26 @@ CheckValidResultRel(Relation resultRel, CmdType operation) case CMD_INSERT: if (!trigDesc || !trigDesc->trig_insert_instead_row) ereport(ERROR, - (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), - errmsg("cannot insert into view \"%s\"", - RelationGetRelationName(resultRel)), - errhint("You need an unconditional ON INSERT DO INSTEAD rule or an INSTEAD OF INSERT trigger."))); + (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), + errmsg("cannot insert into view \"%s\"", + RelationGetRelationName(resultRel)), + errhint("You need an unconditional ON INSERT DO INSTEAD rule or an INSTEAD OF INSERT trigger."))); break; case CMD_UPDATE: if (!trigDesc || !trigDesc->trig_update_instead_row) ereport(ERROR, - (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), - errmsg("cannot update view \"%s\"", - RelationGetRelationName(resultRel)), - errhint("You need an unconditional ON UPDATE DO INSTEAD rule or an INSTEAD OF UPDATE trigger."))); + (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), + errmsg("cannot update view \"%s\"", + RelationGetRelationName(resultRel)), + errhint("You need an unconditional ON UPDATE DO INSTEAD rule or an INSTEAD OF UPDATE trigger."))); break; case CMD_DELETE: if (!trigDesc || !trigDesc->trig_delete_instead_row) ereport(ERROR, - (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), - errmsg("cannot delete from view \"%s\"", - RelationGetRelationName(resultRel)), - errhint("You need an unconditional ON DELETE DO INSTEAD rule or an INSTEAD OF DELETE trigger."))); + (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), + errmsg("cannot delete from view \"%s\"", + RelationGetRelationName(resultRel)), + errhint("You need an unconditional ON DELETE DO INSTEAD rule or an INSTEAD OF DELETE trigger."))); break; default: elog(ERROR, "unrecognized CmdType: %d", (int) operation); @@ -1137,8 +1138,8 @@ ExecGetTriggerResultRel(EState *estate, Oid relid) /* * Open the target relation's relcache entry. We assume that an * appropriate lock is still held by the backend from whenever the trigger - * event got queued, so we need take no new lock here. Also, we need - * not recheck the relkind, so no need for CheckValidResultRel. + * event got queued, so we need take no new lock here. Also, we need not + * recheck the relkind, so no need for CheckValidResultRel. */ rel = heap_open(relid, NoLock); @@ -1238,12 +1239,12 @@ ExecPostprocessPlan(EState *estate) /* * Run any secondary ModifyTable nodes to completion, in case the main - * query did not fetch all rows from them. (We do this to ensure that + * query did not fetch all rows from them. (We do this to ensure that * such nodes have predictable results.) */ foreach(lc, estate->es_auxmodifytables) { - PlanState *ps = (PlanState *) lfirst(lc); + PlanState *ps = (PlanState *) lfirst(lc); for (;;) { @@ -2220,9 +2221,9 @@ EvalPlanQualStart(EPQState *epqstate, EState *parentestate, Plan *planTree) * ExecInitSubPlan expects to be able to find these entries. Some of the * SubPlans might not be used in the part of the plan tree we intend to * run, but since it's not easy to tell which, we just initialize them - * all. (However, if the subplan is headed by a ModifyTable node, then - * it must be a data-modifying CTE, which we will certainly not need to - * re-run, so we can skip initializing it. This is just an efficiency + * all. (However, if the subplan is headed by a ModifyTable node, then it + * must be a data-modifying CTE, which we will certainly not need to + * re-run, so we can skip initializing it. This is just an efficiency * hack; it won't skip data-modifying CTEs for which the ModifyTable node * is not at the top.) */ diff --git a/src/backend/executor/execQual.c b/src/backend/executor/execQual.c index c153ca00dbf..5f0b58f43b7 100644 --- a/src/backend/executor/execQual.c +++ b/src/backend/executor/execQual.c @@ -79,9 +79,9 @@ static Datum ExecEvalWholeRowSlow(ExprState *exprstate, ExprContext *econtext, static Datum ExecEvalConst(ExprState *exprstate, ExprContext *econtext, bool *isNull, ExprDoneCond *isDone); static Datum ExecEvalParamExec(ExprState *exprstate, ExprContext *econtext, - bool *isNull, ExprDoneCond *isDone); + bool *isNull, ExprDoneCond *isDone); static Datum ExecEvalParamExtern(ExprState *exprstate, ExprContext *econtext, - bool *isNull, ExprDoneCond *isDone); + bool *isNull, ExprDoneCond *isDone); static void init_fcache(Oid foid, Oid input_collation, FuncExprState *fcache, MemoryContext fcacheCxt, bool needDescForSets); static void ShutdownFuncExpr(Datum arg); @@ -1043,7 +1043,7 @@ ExecEvalParamExtern(ExprState *exprstate, ExprContext *econtext, ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("no value found for parameter %d", thisParamId))); - return (Datum) 0; /* keep compiler quiet */ + return (Datum) 0; /* keep compiler quiet */ } diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c index 7e84ccdd9cd..0cbbe04d3bd 100644 --- a/src/backend/executor/execUtils.c +++ b/src/backend/executor/execUtils.c @@ -1319,9 +1319,9 @@ retry: /* * Ordinarily, at this point the search should have found the originally * inserted tuple, unless we exited the loop early because of conflict. - * However, it is possible to define exclusion constraints for which - * that wouldn't be true --- for instance, if the operator is <>. - * So we no longer complain if found_self is still false. + * However, it is possible to define exclusion constraints for which that + * wouldn't be true --- for instance, if the operator is <>. So we no + * longer complain if found_self is still false. */ econtext->ecxt_scantuple = save_scantuple; diff --git a/src/backend/executor/functions.c b/src/backend/executor/functions.c index 70d126c5213..9c867bbae20 100644 --- a/src/backend/executor/functions.c +++ b/src/backend/executor/functions.c @@ -81,7 +81,7 @@ typedef struct char *fname; /* function name (for error msgs) */ char *src; /* function body text (for error msgs) */ - SQLFunctionParseInfoPtr pinfo; /* data for parser callback hooks */ + SQLFunctionParseInfoPtr pinfo; /* data for parser callback hooks */ Oid rettype; /* actual return type */ int16 typlen; /* length of the return type */ @@ -119,7 +119,7 @@ typedef struct SQLFunctionParseInfo Oid *argtypes; /* resolved types of input arguments */ int nargs; /* number of input arguments */ Oid collation; /* function's input collation, if known */ -} SQLFunctionParseInfo; +} SQLFunctionParseInfo; /* non-export function prototypes */ @@ -255,7 +255,7 @@ sql_fn_param_ref(ParseState *pstate, ParamRef *pref) * Set up the per-query execution_state records for a SQL function. * * The input is a List of Lists of parsed and rewritten, but not planned, - * querytrees. The sublist structure denotes the original query boundaries. + * querytrees. The sublist structure denotes the original query boundaries. */ static List * init_execution_state(List *queryTree_list, @@ -299,8 +299,8 @@ init_execution_state(List *queryTree_list, ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), /* translator: %s is a SQL statement name */ - errmsg("%s is not allowed in a non-volatile function", - CreateCommandTag(stmt)))); + errmsg("%s is not allowed in a non-volatile function", + CreateCommandTag(stmt)))); /* OK, build the execution_state for this query */ newes = (execution_state *) palloc(sizeof(execution_state)); @@ -311,8 +311,8 @@ init_execution_state(List *queryTree_list, newes->next = NULL; newes->status = F_EXEC_START; - newes->setsResult = false; /* might change below */ - newes->lazyEval = false; /* might change below */ + newes->setsResult = false; /* might change below */ + newes->lazyEval = false; /* might change below */ newes->stmt = stmt; newes->qd = NULL; @@ -442,7 +442,7 @@ init_sql_fcache(FmgrInfo *finfo, bool lazyEvalOK) fcache->src = TextDatumGetCString(tmp); /* - * Parse and rewrite the queries in the function text. Use sublists to + * Parse and rewrite the queries in the function text. Use sublists to * keep track of the original query boundaries. But we also build a * "flat" list of the rewritten queries to pass to check_sql_fn_retval. * This is because the last canSetTag query determines the result type @@ -462,7 +462,7 @@ init_sql_fcache(FmgrInfo *finfo, bool lazyEvalOK) queryTree_sublist = pg_analyze_and_rewrite_params(parsetree, fcache->src, - (ParserSetupHook) sql_fn_parser_setup, + (ParserSetupHook) sql_fn_parser_setup, fcache->pinfo); queryTree_list = lappend(queryTree_list, queryTree_sublist); flat_query_list = list_concat(flat_query_list, @@ -657,7 +657,7 @@ postquel_sub_params(SQLFunctionCachePtr fcache, { /* sizeof(ParamListInfoData) includes the first array element */ paramLI = (ParamListInfo) palloc(sizeof(ParamListInfoData) + - (nargs - 1) *sizeof(ParamExternData)); + (nargs - 1) * sizeof(ParamExternData)); /* we have static list of params, so no hooks needed */ paramLI->paramFetch = NULL; paramLI->paramFetchArg = NULL; @@ -748,8 +748,8 @@ fmgr_sql(PG_FUNCTION_ARGS) execution_state *es; TupleTableSlot *slot; Datum result; - List *eslist; - ListCell *eslc; + List *eslist; + ListCell *eslc; /* * Switch to context in which the fcache lives. This ensures that @@ -847,10 +847,10 @@ fmgr_sql(PG_FUNCTION_ARGS) * * In a non-read-only function, we rely on the fact that we'll never * suspend execution between queries of the function: the only reason to - * suspend execution before completion is if we are returning a row from - * a lazily-evaluated SELECT. So, when first entering this loop, we'll + * suspend execution before completion is if we are returning a row from a + * lazily-evaluated SELECT. So, when first entering this loop, we'll * either start a new query (and push a fresh snapshot) or re-establish - * the active snapshot from the existing query descriptor. If we need to + * the active snapshot from the existing query descriptor. If we need to * start a new query in a subsequent execution of the loop, either we need * a fresh snapshot (and pushed_snapshot is false) or the existing * snapshot is on the active stack and we can just bump its command ID. @@ -927,10 +927,10 @@ fmgr_sql(PG_FUNCTION_ARGS) es = (execution_state *) lfirst(eslc); /* - * Flush the current snapshot so that we will take a new one - * for the new query list. This ensures that new snaps are - * taken at original-query boundaries, matching the behavior - * of interactive execution. + * Flush the current snapshot so that we will take a new one for + * the new query list. This ensures that new snaps are taken at + * original-query boundaries, matching the behavior of interactive + * execution. */ if (pushed_snapshot) { @@ -1183,7 +1183,7 @@ ShutdownSQLFunction(Datum arg) { SQLFunctionCachePtr fcache = (SQLFunctionCachePtr) DatumGetPointer(arg); execution_state *es; - ListCell *lc; + ListCell *lc; foreach(lc, fcache->func_state) { @@ -1415,7 +1415,7 @@ check_sql_fn_retval(Oid func_id, Oid rettype, List *queryTreeList, * the function that's calling it. * * XXX Note that if rettype is RECORD, the IsBinaryCoercible check - * will succeed for any composite restype. For the moment we rely on + * will succeed for any composite restype. For the moment we rely on * runtime type checking to catch any discrepancy, but it'd be nice to * do better at parse time. */ @@ -1432,7 +1432,7 @@ check_sql_fn_retval(Oid func_id, Oid rettype, List *queryTreeList, tle->expr = (Expr *) makeRelabelType(tle->expr, rettype, -1, - get_typcollation(rettype), + get_typcollation(rettype), COERCE_DONTCARE); /* Relabel is dangerous if sort/group or setop column */ if (tle->ressortgroupref != 0 || parse->setOperations) @@ -1536,7 +1536,7 @@ check_sql_fn_retval(Oid func_id, Oid rettype, List *queryTreeList, tle->expr = (Expr *) makeRelabelType(tle->expr, atttype, -1, - get_typcollation(atttype), + get_typcollation(atttype), COERCE_DONTCARE); /* Relabel is dangerous if sort/group or setop column */ if (tle->ressortgroupref != 0 || parse->setOperations) diff --git a/src/backend/executor/nodeAgg.c b/src/backend/executor/nodeAgg.c index 51b1228c26f..47555bab55b 100644 --- a/src/backend/executor/nodeAgg.c +++ b/src/backend/executor/nodeAgg.c @@ -199,7 +199,7 @@ typedef struct AggStatePerAggData */ Tuplesortstate *sortstate; /* sort object, if DISTINCT or ORDER BY */ -} AggStatePerAggData; +} AggStatePerAggData; /* * AggStatePerGroupData - per-aggregate-per-group working state @@ -246,7 +246,7 @@ typedef struct AggHashEntryData TupleHashEntryData shared; /* common header for hash table entries */ /* per-aggregate transition status array - must be last! */ AggStatePerGroupData pergroup[1]; /* VARIABLE LENGTH ARRAY */ -} AggHashEntryData; /* VARIABLE LENGTH STRUCT */ +} AggHashEntryData; /* VARIABLE LENGTH STRUCT */ static void initialize_aggregates(AggState *aggstate, @@ -827,7 +827,7 @@ build_hash_table(AggState *aggstate) Assert(node->numGroups > 0); entrysize = sizeof(AggHashEntryData) + - (aggstate->numaggs - 1) *sizeof(AggStatePerGroupData); + (aggstate->numaggs - 1) * sizeof(AggStatePerGroupData); aggstate->hashtable = BuildTupleHashTable(node->numCols, node->grpColIdx, @@ -899,7 +899,7 @@ hash_agg_entry_size(int numAggs) /* This must match build_hash_table */ entrysize = sizeof(AggHashEntryData) + - (numAggs - 1) *sizeof(AggStatePerGroupData); + (numAggs - 1) * sizeof(AggStatePerGroupData); entrysize = MAXALIGN(entrysize); /* Account for hashtable overhead (assuming fill factor = 1) */ entrysize += 3 * sizeof(void *); diff --git a/src/backend/executor/nodeBitmapIndexscan.c b/src/backend/executor/nodeBitmapIndexscan.c index 90ff0403ab0..4de54ea55f6 100644 --- a/src/backend/executor/nodeBitmapIndexscan.c +++ b/src/backend/executor/nodeBitmapIndexscan.c @@ -307,8 +307,8 @@ ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate, int eflags) indexstate->biss_NumScanKeys); /* - * If no run-time keys to calculate, go ahead and pass the scankeys to - * the index AM. + * If no run-time keys to calculate, go ahead and pass the scankeys to the + * index AM. */ if (indexstate->biss_NumRuntimeKeys == 0 && indexstate->biss_NumArrayKeys == 0) diff --git a/src/backend/executor/nodeForeignscan.c b/src/backend/executor/nodeForeignscan.c index c4309a981e2..d50489c7f4c 100644 --- a/src/backend/executor/nodeForeignscan.c +++ b/src/backend/executor/nodeForeignscan.c @@ -40,7 +40,7 @@ static TupleTableSlot * ForeignNext(ForeignScanState *node) { TupleTableSlot *slot; - ForeignScan *plan = (ForeignScan *) node->ss.ps.plan; + ForeignScan *plan = (ForeignScan *) node->ss.ps.plan; ExprContext *econtext = node->ss.ps.ps_ExprContext; MemoryContext oldcontext; diff --git a/src/backend/executor/nodeHash.c b/src/backend/executor/nodeHash.c index 295563011fe..1af98c81a69 100644 --- a/src/backend/executor/nodeHash.c +++ b/src/backend/executor/nodeHash.c @@ -960,13 +960,11 @@ void ExecPrepHashTableForUnmatched(HashJoinState *hjstate) { /* - *---------- - * During this scan we use the HashJoinState fields as follows: + * ---------- During this scan we use the HashJoinState fields as follows: * - * hj_CurBucketNo: next regular bucket to scan - * hj_CurSkewBucketNo: next skew bucket (an index into skewBucketNums) - * hj_CurTuple: last tuple returned, or NULL to start next bucket - *---------- + * hj_CurBucketNo: next regular bucket to scan hj_CurSkewBucketNo: next + * skew bucket (an index into skewBucketNums) hj_CurTuple: last tuple + * returned, or NULL to start next bucket ---------- */ hjstate->hj_CurBucketNo = 0; hjstate->hj_CurSkewBucketNo = 0; @@ -1003,7 +1001,7 @@ ExecScanHashTableForUnmatched(HashJoinState *hjstate, ExprContext *econtext) } else if (hjstate->hj_CurSkewBucketNo < hashtable->nSkewBuckets) { - int j = hashtable->skewBucketNums[hjstate->hj_CurSkewBucketNo]; + int j = hashtable->skewBucketNums[hjstate->hj_CurSkewBucketNo]; hashTuple = hashtable->skewBucket[j]->tuples; hjstate->hj_CurSkewBucketNo++; @@ -1020,7 +1018,7 @@ ExecScanHashTableForUnmatched(HashJoinState *hjstate, ExprContext *econtext) /* insert hashtable's tuple into exec slot */ inntuple = ExecStoreMinimalTuple(HJTUPLE_MINTUPLE(hashTuple), hjstate->hj_HashTupleSlot, - false); /* do not pfree */ + false); /* do not pfree */ econtext->ecxt_innertuple = inntuple; /* @@ -1091,7 +1089,7 @@ ExecHashTableResetMatchFlags(HashJoinTable hashtable) /* ... and the same for the skew buckets, if any */ for (i = 0; i < hashtable->nSkewBuckets; i++) { - int j = hashtable->skewBucketNums[i]; + int j = hashtable->skewBucketNums[i]; HashSkewBucket *skewBucket = hashtable->skewBucket[j]; for (tuple = skewBucket->tuples; tuple != NULL; tuple = tuple->next) diff --git a/src/backend/executor/nodeHashjoin.c b/src/backend/executor/nodeHashjoin.c index a6847c956f4..7c02db94adb 100644 --- a/src/backend/executor/nodeHashjoin.c +++ b/src/backend/executor/nodeHashjoin.c @@ -113,6 +113,7 @@ ExecHashJoin(HashJoinState *node) switch (node->hj_JoinState) { case HJ_BUILD_HASHTABLE: + /* * First time through: build hash table for inner relation. */ @@ -123,12 +124,12 @@ ExecHashJoin(HashJoinState *node) * right/full join, we can quit without building the hash * table. However, for an inner join it is only a win to * check this when the outer relation's startup cost is less - * than the projected cost of building the hash - * table. Otherwise it's best to build the hash table first - * and see if the inner relation is empty. (When it's a left - * join, we should always make this check, since we aren't - * going to be able to skip the join on the strength of an - * empty inner relation anyway.) + * than the projected cost of building the hash table. + * Otherwise it's best to build the hash table first and see + * if the inner relation is empty. (When it's a left join, we + * should always make this check, since we aren't going to be + * able to skip the join on the strength of an empty inner + * relation anyway.) * * If we are rescanning the join, we make use of information * gained on the previous scan: don't bother to try the @@ -185,8 +186,8 @@ ExecHashJoin(HashJoinState *node) return NULL; /* - * need to remember whether nbatch has increased since we began - * scanning the outer relation + * need to remember whether nbatch has increased since we + * began scanning the outer relation */ hashtable->nbatch_outstart = hashtable->nbatch; @@ -202,6 +203,7 @@ ExecHashJoin(HashJoinState *node) /* FALL THRU */ case HJ_NEED_NEW_OUTER: + /* * We don't have an outer tuple, try to get the next one */ @@ -250,7 +252,7 @@ ExecHashJoin(HashJoinState *node) Assert(batchno > hashtable->curbatch); ExecHashJoinSaveTuple(ExecFetchSlotMinimalTuple(outerTupleSlot), hashvalue, - &hashtable->outerBatchFile[batchno]); + &hashtable->outerBatchFile[batchno]); /* Loop around, staying in HJ_NEED_NEW_OUTER state */ continue; } @@ -261,6 +263,7 @@ ExecHashJoin(HashJoinState *node) /* FALL THRU */ case HJ_SCAN_BUCKET: + /* * Scan the selected hash bucket for matches to current outer */ @@ -296,8 +299,8 @@ ExecHashJoin(HashJoinState *node) } /* - * In a semijoin, we'll consider returning the first match, - * but after that we're done with this outer tuple. + * In a semijoin, we'll consider returning the first + * match, but after that we're done with this outer tuple. */ if (node->js.jointype == JOIN_SEMI) node->hj_JoinState = HJ_NEED_NEW_OUTER; @@ -320,10 +323,11 @@ ExecHashJoin(HashJoinState *node) break; case HJ_FILL_OUTER_TUPLE: + /* * The current outer tuple has run out of matches, so check - * whether to emit a dummy outer-join tuple. Whether we - * emit one or not, the next state is NEED_NEW_OUTER. + * whether to emit a dummy outer-join tuple. Whether we emit + * one or not, the next state is NEED_NEW_OUTER. */ node->hj_JoinState = HJ_NEED_NEW_OUTER; @@ -354,6 +358,7 @@ ExecHashJoin(HashJoinState *node) break; case HJ_FILL_INNER_TUPLES: + /* * We have finished a batch, but we are doing right/full join, * so any unmatched inner tuples in the hashtable have to be @@ -389,11 +394,12 @@ ExecHashJoin(HashJoinState *node) break; case HJ_NEED_NEW_BATCH: + /* * Try to advance to next batch. Done if there are no more. */ if (!ExecHashJoinNewBatch(node)) - return NULL; /* end of join */ + return NULL; /* end of join */ node->hj_JoinState = HJ_NEED_NEW_OUTER; break; @@ -783,7 +789,7 @@ ExecHashJoinNewBatch(HashJoinState *hjstate) } if (curbatch >= nbatch) - return false; /* no more batches */ + return false; /* no more batches */ hashtable->curbatch = curbatch; @@ -829,7 +835,7 @@ ExecHashJoinNewBatch(HashJoinState *hjstate) if (BufFileSeek(hashtable->outerBatchFile[curbatch], 0, 0L, SEEK_SET)) ereport(ERROR, (errcode_for_file_access(), - errmsg("could not rewind hash-join temporary file: %m"))); + errmsg("could not rewind hash-join temporary file: %m"))); } return true; @@ -944,14 +950,13 @@ ExecReScanHashJoin(HashJoinState *node) ExecHashTableResetMatchFlags(node->hj_HashTable); /* - * Also, we need to reset our state about the emptiness of - * the outer relation, so that the new scan of the outer will - * update it correctly if it turns out to be empty this time. - * (There's no harm in clearing it now because ExecHashJoin won't - * need the info. In the other cases, where the hash table - * doesn't exist or we are destroying it, we leave this state - * alone because ExecHashJoin will need it the first time - * through.) + * Also, we need to reset our state about the emptiness of the + * outer relation, so that the new scan of the outer will update + * it correctly if it turns out to be empty this time. (There's no + * harm in clearing it now because ExecHashJoin won't need the + * info. In the other cases, where the hash table doesn't exist + * or we are destroying it, we leave this state alone because + * ExecHashJoin will need it the first time through.) */ node->hj_OuterNotEmpty = false; diff --git a/src/backend/executor/nodeIndexscan.c b/src/backend/executor/nodeIndexscan.c index 3b8741fc21b..d8e59ca39e5 100644 --- a/src/backend/executor/nodeIndexscan.c +++ b/src/backend/executor/nodeIndexscan.c @@ -212,7 +212,7 @@ ExecIndexEvalRuntimeKeys(ExprContext *econtext, /* * For each run-time key, extract the run-time expression and evaluate - * it with respect to the current context. We then stick the result + * it with respect to the current context. We then stick the result * into the proper scan key. * * Note: the result of the eval could be a pass-by-ref value that's @@ -605,16 +605,16 @@ ExecInitIndexScan(IndexScan *node, EState *estate, int eflags) indexstate->iss_RelationDesc, estate->es_snapshot, indexstate->iss_NumScanKeys, - indexstate->iss_NumOrderByKeys); + indexstate->iss_NumOrderByKeys); /* - * If no run-time keys to calculate, go ahead and pass the scankeys to - * the index AM. + * If no run-time keys to calculate, go ahead and pass the scankeys to the + * index AM. */ if (indexstate->iss_NumRuntimeKeys == 0) index_rescan(indexstate->iss_ScanDesc, indexstate->iss_ScanKeys, indexstate->iss_NumScanKeys, - indexstate->iss_OrderByKeys, indexstate->iss_NumOrderByKeys); + indexstate->iss_OrderByKeys, indexstate->iss_NumOrderByKeys); /* * all done. @@ -703,11 +703,11 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index, Index scanrelid, scan_keys = (ScanKey) palloc(n_scan_keys * sizeof(ScanKeyData)); /* - * runtime_keys array is dynamically resized as needed. We handle it - * this way so that the same runtime keys array can be shared between - * indexquals and indexorderbys, which will be processed in separate - * calls of this function. Caller must be sure to pass in NULL/0 for - * first call. + * runtime_keys array is dynamically resized as needed. We handle it this + * way so that the same runtime keys array can be shared between + * indexquals and indexorderbys, which will be processed in separate calls + * of this function. Caller must be sure to pass in NULL/0 for first + * call. */ runtime_keys = *runtimeKeys; n_runtime_keys = max_runtime_keys = *numRuntimeKeys; diff --git a/src/backend/executor/nodeLimit.c b/src/backend/executor/nodeLimit.c index edbe0558b70..85d1a6e27f1 100644 --- a/src/backend/executor/nodeLimit.c +++ b/src/backend/executor/nodeLimit.c @@ -346,14 +346,14 @@ pass_down_bound(LimitState *node, PlanState *child_node) else if (IsA(child_node, ResultState)) { /* - * An extra consideration here is that if the Result is projecting - * a targetlist that contains any SRFs, we can't assume that every - * input tuple generates an output tuple, so a Sort underneath - * might need to return more than N tuples to satisfy LIMIT N. - * So we cannot use bounded sort. + * An extra consideration here is that if the Result is projecting a + * targetlist that contains any SRFs, we can't assume that every input + * tuple generates an output tuple, so a Sort underneath might need to + * return more than N tuples to satisfy LIMIT N. So we cannot use + * bounded sort. * - * If Result supported qual checking, we'd have to punt on seeing - * a qual, too. Note that having a resconstantqual is not a + * If Result supported qual checking, we'd have to punt on seeing a + * qual, too. Note that having a resconstantqual is not a * showstopper: if that fails we're not getting any rows at all. */ if (outerPlanState(child_node) && diff --git a/src/backend/executor/nodeLockRows.c b/src/backend/executor/nodeLockRows.c index 2e080088071..d71278ebd72 100644 --- a/src/backend/executor/nodeLockRows.c +++ b/src/backend/executor/nodeLockRows.c @@ -291,7 +291,7 @@ ExecInitLockRows(LockRows *node, EState *estate, int eflags) /* * Locate the ExecRowMark(s) that this node is responsible for, and - * construct ExecAuxRowMarks for them. (InitPlan should already have + * construct ExecAuxRowMarks for them. (InitPlan should already have * built the global list of ExecRowMarks.) */ lrstate->lr_arowMarks = NIL; diff --git a/src/backend/executor/nodeMergeAppend.c b/src/backend/executor/nodeMergeAppend.c index 73920f21c8c..4ebe0cbe033 100644 --- a/src/backend/executor/nodeMergeAppend.c +++ b/src/backend/executor/nodeMergeAppend.c @@ -48,8 +48,8 @@ * contains integers which index into the slots array. These typedefs try to * clear it up, but they're only documentation. */ -typedef int SlotNumber; -typedef int HeapPosition; +typedef int SlotNumber; +typedef int HeapPosition; static void heap_insert_slot(MergeAppendState *node, SlotNumber new_slot); static void heap_siftup_slot(MergeAppendState *node); @@ -128,13 +128,13 @@ ExecInitMergeAppend(MergeAppend *node, EState *estate, int eflags) * initialize sort-key information */ mergestate->ms_nkeys = node->numCols; - mergestate->ms_scankeys = palloc0(sizeof(ScanKeyData) * node->numCols); + mergestate->ms_scankeys = palloc0(sizeof(ScanKeyData) * node->numCols); for (i = 0; i < node->numCols; i++) { - Oid sortFunction; - bool reverse; - int flags; + Oid sortFunction; + bool reverse; + int flags; if (!get_compare_function_for_ordering_op(node->sortOperators[i], &sortFunction, &reverse)) @@ -187,8 +187,8 @@ ExecMergeAppend(MergeAppendState *node) if (!node->ms_initialized) { /* - * First time through: pull the first tuple from each subplan, - * and set up the heap. + * First time through: pull the first tuple from each subplan, and set + * up the heap. */ for (i = 0; i < node->ms_nplans; i++) { @@ -243,7 +243,7 @@ heap_insert_slot(MergeAppendState *node, SlotNumber new_slot) j = node->ms_heap_size++; /* j is where the "hole" is */ while (j > 0) { - int i = (j-1)/2; + int i = (j - 1) / 2; if (heap_compare_slots(node, new_slot, node->ms_heap[i]) >= 0) break; @@ -269,11 +269,11 @@ heap_siftup_slot(MergeAppendState *node) i = 0; /* i is where the "hole" is */ for (;;) { - int j = 2 * i + 1; + int j = 2 * i + 1; if (j >= n) break; - if (j+1 < n && heap_compare_slots(node, heap[j], heap[j+1]) > 0) + if (j + 1 < n && heap_compare_slots(node, heap[j], heap[j + 1]) > 0) j++; if (heap_compare_slots(node, heap[n], heap[j]) <= 0) break; @@ -298,13 +298,13 @@ heap_compare_slots(MergeAppendState *node, SlotNumber slot1, SlotNumber slot2) for (nkey = 0; nkey < node->ms_nkeys; nkey++) { - ScanKey scankey = node->ms_scankeys + nkey; - AttrNumber attno = scankey->sk_attno; - Datum datum1, - datum2; - bool isNull1, - isNull2; - int32 compare; + ScanKey scankey = node->ms_scankeys + nkey; + AttrNumber attno = scankey->sk_attno; + Datum datum1, + datum2; + bool isNull1, + isNull2; + int32 compare; datum1 = slot_getattr(s1, attno, &isNull1); datum2 = slot_getattr(s2, attno, &isNull2); diff --git a/src/backend/executor/nodeMergejoin.c b/src/backend/executor/nodeMergejoin.c index 75c3a645359..ce5462e961e 100644 --- a/src/backend/executor/nodeMergejoin.c +++ b/src/backend/executor/nodeMergejoin.c @@ -143,7 +143,7 @@ typedef struct MergeJoinClauseData bool reverse; /* if true, negate the cmpfn's output */ bool nulls_first; /* if true, nulls sort low */ FmgrInfo cmpfinfo; -} MergeJoinClauseData; +} MergeJoinClauseData; /* Result type for MJEvalOuterValues and MJEvalInnerValues */ typedef enum diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f10f70a17d3..c0eab4bf0db 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -544,7 +544,7 @@ ExecUpdate(ItemPointer tupleid, * * If we generate a new candidate tuple after EvalPlanQual testing, we * must loop back here and recheck constraints. (We don't need to - * redo triggers, however. If there are any BEFORE triggers then + * redo triggers, however. If there are any BEFORE triggers then * trigger.c will have done heap_lock_tuple to lock the correct tuple, * so there's no need to do them again.) */ @@ -608,11 +608,10 @@ lreplace:; /* * Note: instead of having to update the old index tuples associated - * with the heap tuple, all we do is form and insert new index - * tuples. This is because UPDATEs are actually DELETEs and INSERTs, - * and index tuple deletion is done later by VACUUM (see notes in - * ExecDelete). All we do here is insert new index tuples. -cim - * 9/27/89 + * with the heap tuple, all we do is form and insert new index tuples. + * This is because UPDATEs are actually DELETEs and INSERTs, and index + * tuple deletion is done later by VACUUM (see notes in ExecDelete). + * All we do here is insert new index tuples. -cim 9/27/89 */ /* @@ -713,7 +712,7 @@ ExecModifyTable(ModifyTableState *node) TupleTableSlot *planSlot; ItemPointer tupleid = NULL; ItemPointerData tuple_ctid; - HeapTupleHeader oldtuple = NULL; + HeapTupleHeader oldtuple = NULL; /* * If we've already completed processing, don't try to do more. We need @@ -740,7 +739,7 @@ ExecModifyTable(ModifyTableState *node) /* * es_result_relation_info must point to the currently active result - * relation while we are within this ModifyTable node. Even though + * relation while we are within this ModifyTable node. Even though * ModifyTable nodes can't be nested statically, they can be nested * dynamically (since our subplan could include a reference to a modifying * CTE). So we have to save and restore the caller's value. @@ -756,7 +755,7 @@ ExecModifyTable(ModifyTableState *node) for (;;) { /* - * Reset the per-output-tuple exprcontext. This is needed because + * Reset the per-output-tuple exprcontext. This is needed because * triggers expect to use that context as workspace. It's a bit ugly * to do this below the top level of the plan, however. We might need * to rethink this later. @@ -806,7 +805,8 @@ ExecModifyTable(ModifyTableState *node) elog(ERROR, "ctid is NULL"); tupleid = (ItemPointer) DatumGetPointer(datum); - tuple_ctid = *tupleid; /* be sure we don't free ctid!! */ + tuple_ctid = *tupleid; /* be sure we don't free + * ctid!! */ tupleid = &tuple_ctid; } else @@ -836,11 +836,11 @@ ExecModifyTable(ModifyTableState *node) break; case CMD_UPDATE: slot = ExecUpdate(tupleid, oldtuple, slot, planSlot, - &node->mt_epqstate, estate, node->canSetTag); + &node->mt_epqstate, estate, node->canSetTag); break; case CMD_DELETE: slot = ExecDelete(tupleid, oldtuple, planSlot, - &node->mt_epqstate, estate, node->canSetTag); + &node->mt_epqstate, estate, node->canSetTag); break; default: elog(ERROR, "unknown operation"); @@ -922,9 +922,9 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) /* * call ExecInitNode on each of the plans to be executed and save the - * results into the array "mt_plans". This is also a convenient place - * to verify that the proposed target relations are valid and open their - * indexes for insertion of new index entries. Note we *must* set + * results into the array "mt_plans". This is also a convenient place to + * verify that the proposed target relations are valid and open their + * indexes for insertion of new index entries. Note we *must* set * estate->es_result_relation_info correctly while we initialize each * sub-plan; ExecContextForcesOids depends on that! */ @@ -944,7 +944,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) /* * If there are indices on the result relation, open them and save * descriptors in the result relation info, so that we can add new - * index entries for the tuples we add/update. We need not do this + * index entries for the tuples we add/update. We need not do this * for a DELETE, however, since deletion doesn't affect indexes. */ if (resultRelInfo->ri_RelationDesc->rd_rel->relhasindex && @@ -1147,10 +1147,10 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) * Lastly, if this is not the primary (canSetTag) ModifyTable node, add it * to estate->es_auxmodifytables so that it will be run to completion by * ExecPostprocessPlan. (It'd actually work fine to add the primary - * ModifyTable node too, but there's no need.) Note the use of lcons - * not lappend: we need later-initialized ModifyTable nodes to be shut - * down before earlier ones. This ensures that we don't throw away - * RETURNING rows that need to be seen by a later CTE subplan. + * ModifyTable node too, but there's no need.) Note the use of lcons not + * lappend: we need later-initialized ModifyTable nodes to be shut down + * before earlier ones. This ensures that we don't throw away RETURNING + * rows that need to be seen by a later CTE subplan. */ if (!mtstate->canSetTag) estate->es_auxmodifytables = lcons(mtstate, diff --git a/src/backend/executor/nodeNestloop.c b/src/backend/executor/nodeNestloop.c index 4893a6ea6d6..e98bc0f5a30 100644 --- a/src/backend/executor/nodeNestloop.c +++ b/src/backend/executor/nodeNestloop.c @@ -137,9 +137,8 @@ ExecNestLoop(NestLoopState *node) node->nl_MatchedOuter = false; /* - * fetch the values of any outer Vars that must be passed to - * the inner scan, and store them in the appropriate PARAM_EXEC - * slots. + * fetch the values of any outer Vars that must be passed to the + * inner scan, and store them in the appropriate PARAM_EXEC slots. */ foreach(lc, nl->nestParams) { @@ -330,9 +329,9 @@ ExecInitNestLoop(NestLoop *node, EState *estate, int eflags) * * If we have no parameters to pass into the inner rel from the outer, * tell the inner child that cheap rescans would be good. If we do have - * such parameters, then there is no point in REWIND support at all in - * the inner child, because it will always be rescanned with fresh - * parameter values. + * such parameters, then there is no point in REWIND support at all in the + * inner child, because it will always be rescanned with fresh parameter + * values. */ outerPlanState(nlstate) = ExecInitNode(outerPlan(node), estate, eflags); if (node->nestParams == NIL) diff --git a/src/backend/executor/nodeRecursiveunion.c b/src/backend/executor/nodeRecursiveunion.c index 84c051854bb..12e1b9a5857 100644 --- a/src/backend/executor/nodeRecursiveunion.c +++ b/src/backend/executor/nodeRecursiveunion.c @@ -29,7 +29,7 @@ typedef struct RUHashEntryData *RUHashEntry; typedef struct RUHashEntryData { TupleHashEntryData shared; /* common header for hash table entries */ -} RUHashEntryData; +} RUHashEntryData; /* diff --git a/src/backend/executor/nodeSetOp.c b/src/backend/executor/nodeSetOp.c index aa352d7822e..9106f148730 100644 --- a/src/backend/executor/nodeSetOp.c +++ b/src/backend/executor/nodeSetOp.c @@ -76,7 +76,7 @@ typedef struct SetOpHashEntryData { TupleHashEntryData shared; /* common header for hash table entries */ SetOpStatePerGroupData pergroup; -} SetOpHashEntryData; +} SetOpHashEntryData; static TupleTableSlot *setop_retrieve_direct(SetOpState *setopstate); diff --git a/src/backend/executor/nodeWindowAgg.c b/src/backend/executor/nodeWindowAgg.c index 5680efeb69e..25d9298cefc 100644 --- a/src/backend/executor/nodeWindowAgg.c +++ b/src/backend/executor/nodeWindowAgg.c @@ -92,7 +92,7 @@ typedef struct WindowStatePerFuncData int aggno; /* if so, index of its PerAggData */ WindowObject winobj; /* object used in window function API */ -} WindowStatePerFuncData; +} WindowStatePerFuncData; /* * For plain aggregate window functions, we also have one of these. diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c index a717a0deead..6e723ca092b 100644 --- a/src/backend/executor/spi.c +++ b/src/backend/executor/spi.c @@ -1787,8 +1787,8 @@ _SPI_execute_plan(SPIPlanPtr plan, ParamListInfo paramLI, * snapshot != InvalidSnapshot, read_only = true: use exactly the given * snapshot. * - * snapshot != InvalidSnapshot, read_only = false: use the given - * snapshot, modified by advancing its command ID before each querytree. + * snapshot != InvalidSnapshot, read_only = false: use the given snapshot, + * modified by advancing its command ID before each querytree. * * snapshot == InvalidSnapshot, read_only = true: use the entry-time * ActiveSnapshot, if any (if there isn't one, we run with no snapshot). @@ -1797,8 +1797,8 @@ _SPI_execute_plan(SPIPlanPtr plan, ParamListInfo paramLI, * snapshot for each user command, and advance its command ID before each * querytree within the command. * - * In the first two cases, we can just push the snap onto the stack - * once for the whole plan list. + * In the first two cases, we can just push the snap onto the stack once + * for the whole plan list. */ if (snapshot != InvalidSnapshot) { @@ -2028,7 +2028,7 @@ _SPI_convert_params(int nargs, Oid *argtypes, /* sizeof(ParamListInfoData) includes the first array element */ paramLI = (ParamListInfo) palloc(sizeof(ParamListInfoData) + - (nargs - 1) *sizeof(ParamExternData)); + (nargs - 1) * sizeof(ParamExternData)); /* we have static list of params, so no hooks needed */ paramLI->paramFetch = NULL; paramLI->paramFetchArg = NULL; diff --git a/src/backend/libpq/auth.c b/src/backend/libpq/auth.c index 151ec5613b4..d003b1206a1 100644 --- a/src/backend/libpq/auth.c +++ b/src/backend/libpq/auth.c @@ -61,6 +61,7 @@ static int recv_and_check_password_packet(Port *port); #define IDENT_PORT 113 static int ident_inet(hbaPort *port); + #ifdef HAVE_UNIX_SOCKETS static int auth_peer(hbaPort *port); #endif @@ -182,7 +183,7 @@ static int pg_GSS_recvauth(Port *port); *---------------------------------------------------------------- */ #ifdef ENABLE_SSPI -typedef SECURITY_STATUS +typedef SECURITY_STATUS (WINAPI * QUERY_SECURITY_CONTEXT_TOKEN_FN) ( PCtxtHandle, void **); static int pg_SSPI_recvauth(Port *port); @@ -543,7 +544,7 @@ ClientAuthentication(Port *port) } #endif status = auth_peer(port); -#else /* HAVE_UNIX_SOCKETS */ +#else /* HAVE_UNIX_SOCKETS */ Assert(false); #endif break; @@ -598,7 +599,7 @@ ClientAuthentication(Port *port) } if (ClientAuthentication_hook) - (*ClientAuthentication_hook)(port, status); + (*ClientAuthentication_hook) (port, status); if (status == STATUS_OK) sendAuthRequest(port, AUTH_REQ_OK); @@ -844,7 +845,7 @@ pg_krb5_recvauth(Port *port) return ret; retval = krb5_recvauth(pg_krb5_context, &auth_context, - (krb5_pointer) & port->sock, pg_krb_srvnam, + (krb5_pointer) &port->sock, pg_krb_srvnam, pg_krb5_server, 0, pg_krb5_keytab, &ticket); if (retval) { @@ -1814,7 +1815,6 @@ auth_peer(hbaPort *port) } strlcpy(ident_user, pass->pw_name, IDENT_USERNAME_MAX + 1); - #elif defined(SO_PEERCRED) /* Linux style: use getsockopt(SO_PEERCRED) */ struct ucred peercred; @@ -1843,7 +1843,6 @@ auth_peer(hbaPort *port) } strlcpy(ident_user, pass->pw_name, IDENT_USERNAME_MAX + 1); - #elif defined(HAVE_GETPEERUCRED) /* Solaris > 10 */ uid_t uid; @@ -1879,7 +1878,6 @@ auth_peer(hbaPort *port) } strlcpy(ident_user, pass->pw_name, IDENT_USERNAME_MAX + 1); - #elif defined(HAVE_STRUCT_CMSGCRED) || defined(HAVE_STRUCT_FCRED) || (defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS)) struct msghdr msg; @@ -1947,7 +1945,6 @@ auth_peer(hbaPort *port) } strlcpy(ident_user, pw->pw_name, IDENT_USERNAME_MAX + 1); - #else ereport(LOG, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), @@ -2768,10 +2765,10 @@ CheckRADIUSAuth(Port *port) pg_freeaddrinfo_all(hint.ai_family, serveraddrs); /* - * Figure out at what time we should time out. We can't just use - * a single call to select() with a timeout, since somebody can - * be sending invalid packets to our port thus causing us to - * retry in a loop and never time out. + * Figure out at what time we should time out. We can't just use a single + * call to select() with a timeout, since somebody can be sending invalid + * packets to our port thus causing us to retry in a loop and never time + * out. */ gettimeofday(&endtime, NULL); endtime.tv_sec += RADIUS_TIMEOUT; @@ -2780,7 +2777,7 @@ CheckRADIUSAuth(Port *port) { struct timeval timeout; struct timeval now; - int64 timeoutval; + int64 timeoutval; gettimeofday(&now, NULL); timeoutval = (endtime.tv_sec * 1000000 + endtime.tv_usec) - (now.tv_sec * 1000000 + now.tv_usec); @@ -2820,12 +2817,12 @@ CheckRADIUSAuth(Port *port) /* * Attempt to read the response packet, and verify the contents. * - * Any packet that's not actually a RADIUS packet, or otherwise - * does not validate as an explicit reject, is just ignored and - * we retry for another packet (until we reach the timeout). This - * is to avoid the possibility to denial-of-service the login by - * flooding the server with invalid packets on the port that - * we're expecting the RADIUS response on. + * Any packet that's not actually a RADIUS packet, or otherwise does + * not validate as an explicit reject, is just ignored and we retry + * for another packet (until we reach the timeout). This is to avoid + * the possibility to denial-of-service the login by flooding the + * server with invalid packets on the port that we're expecting the + * RADIUS response on. */ addrsize = sizeof(remoteaddr); @@ -2846,12 +2843,12 @@ CheckRADIUSAuth(Port *port) { #ifdef HAVE_IPV6 ereport(LOG, - (errmsg("RADIUS response was sent from incorrect port: %i", - ntohs(remoteaddr.sin6_port)))); + (errmsg("RADIUS response was sent from incorrect port: %i", + ntohs(remoteaddr.sin6_port)))); #else ereport(LOG, - (errmsg("RADIUS response was sent from incorrect port: %i", - ntohs(remoteaddr.sin_port)))); + (errmsg("RADIUS response was sent from incorrect port: %i", + ntohs(remoteaddr.sin_port)))); #endif continue; } @@ -2885,12 +2882,12 @@ CheckRADIUSAuth(Port *port) */ cryptvector = palloc(packetlength + strlen(port->hba->radiussecret)); - memcpy(cryptvector, receivepacket, 4); /* code+id+length */ - memcpy(cryptvector + 4, packet->vector, RADIUS_VECTOR_LENGTH); /* request - * authenticator, from - * original packet */ - if (packetlength > RADIUS_HEADER_LENGTH) /* there may be no attributes - * at all */ + memcpy(cryptvector, receivepacket, 4); /* code+id+length */ + memcpy(cryptvector + 4, packet->vector, RADIUS_VECTOR_LENGTH); /* request + * authenticator, from + * original packet */ + if (packetlength > RADIUS_HEADER_LENGTH) /* there may be no + * attributes at all */ memcpy(cryptvector + RADIUS_HEADER_LENGTH, receive_buffer + RADIUS_HEADER_LENGTH, packetlength - RADIUS_HEADER_LENGTH); memcpy(cryptvector + packetlength, port->hba->radiussecret, strlen(port->hba->radiussecret)); @@ -2899,7 +2896,7 @@ CheckRADIUSAuth(Port *port) encryptedpassword)) { ereport(LOG, - (errmsg("could not perform MD5 encryption of received packet"))); + (errmsg("could not perform MD5 encryption of received packet"))); pfree(cryptvector); continue; } @@ -2925,9 +2922,9 @@ CheckRADIUSAuth(Port *port) else { ereport(LOG, - (errmsg("RADIUS response has invalid code (%i) for user \"%s\"", - receivepacket->code, port->user_name))); + (errmsg("RADIUS response has invalid code (%i) for user \"%s\"", + receivepacket->code, port->user_name))); continue; } - } /* while (true) */ + } /* while (true) */ } diff --git a/src/backend/libpq/hba.c b/src/backend/libpq/hba.c index 2def6cea894..fdc29aaa72d 100644 --- a/src/backend/libpq/hba.c +++ b/src/backend/libpq/hba.c @@ -543,7 +543,7 @@ check_db(const char *dbname, const char *role, Oid roleid, char *param_str) } static bool -ipv4eq(struct sockaddr_in *a, struct sockaddr_in *b) +ipv4eq(struct sockaddr_in * a, struct sockaddr_in * b) { return (a->sin_addr.s_addr == b->sin_addr.s_addr); } @@ -551,9 +551,9 @@ ipv4eq(struct sockaddr_in *a, struct sockaddr_in *b) #ifdef HAVE_IPV6 static bool -ipv6eq(struct sockaddr_in6 *a, struct sockaddr_in6 *b) +ipv6eq(struct sockaddr_in6 * a, struct sockaddr_in6 * b) { - int i; + int i; for (i = 0; i < 16; i++) if (a->sin6_addr.s6_addr[i] != b->sin6_addr.s6_addr[i]) @@ -561,8 +561,7 @@ ipv6eq(struct sockaddr_in6 *a, struct sockaddr_in6 *b) return true; } - -#endif /* HAVE_IPV6 */ +#endif /* HAVE_IPV6 */ /* * Check whether host name matches pattern. @@ -572,8 +571,8 @@ hostname_match(const char *pattern, const char *actual_hostname) { if (pattern[0] == '.') /* suffix match */ { - size_t plen = strlen(pattern); - size_t hlen = strlen(actual_hostname); + size_t plen = strlen(pattern); + size_t hlen = strlen(actual_hostname); if (hlen < plen) return false; @@ -590,7 +589,8 @@ hostname_match(const char *pattern, const char *actual_hostname) static bool check_hostname(hbaPort *port, const char *hostname) { - struct addrinfo *gai_result, *gai; + struct addrinfo *gai_result, + *gai; int ret; bool found; @@ -632,7 +632,7 @@ check_hostname(hbaPort *port, const char *hostname) if (gai->ai_addr->sa_family == AF_INET) { if (ipv4eq((struct sockaddr_in *) gai->ai_addr, - (struct sockaddr_in *) &port->raddr.addr)) + (struct sockaddr_in *) & port->raddr.addr)) { found = true; break; @@ -642,7 +642,7 @@ check_hostname(hbaPort *port, const char *hostname) else if (gai->ai_addr->sa_family == AF_INET6) { if (ipv6eq((struct sockaddr_in6 *) gai->ai_addr, - (struct sockaddr_in6 *) &port->raddr.addr)) + (struct sockaddr_in6 *) & port->raddr.addr)) { found = true; break; @@ -974,8 +974,8 @@ parse_hba_line(List *line, int line_num, HbaLine *parsedline) (errcode(ERRCODE_CONFIG_FILE_ERROR), errmsg("specifying both host name and CIDR mask is invalid: \"%s\"", token), - errcontext("line %d of configuration file \"%s\"", - line_num, HbaFileName))); + errcontext("line %d of configuration file \"%s\"", + line_num, HbaFileName))); pfree(token); return false; } diff --git a/src/backend/libpq/pqcomm.c b/src/backend/libpq/pqcomm.c index 3232e64d4ad..b83a2efb698 100644 --- a/src/backend/libpq/pqcomm.c +++ b/src/backend/libpq/pqcomm.c @@ -85,7 +85,7 @@ #ifdef HAVE_UTIME_H #include <utime.h> #endif -#ifdef WIN32_ONLY_COMPILER /* mstcpip.h is missing on mingw */ +#ifdef WIN32_ONLY_COMPILER /* mstcpip.h is missing on mingw */ #include <mstcpip.h> #endif @@ -745,7 +745,7 @@ TouchSocketFile(void) */ /* -------------------------------- - * pq_set_nonblocking - set socket blocking/non-blocking + * pq_set_nonblocking - set socket blocking/non-blocking * * Sets the socket non-blocking if nonblocking is TRUE, or sets it * blocking otherwise. @@ -760,16 +760,17 @@ pq_set_nonblocking(bool nonblocking) #ifdef WIN32 pgwin32_noblock = nonblocking ? 1 : 0; #else + /* - * Use COMMERROR on failure, because ERROR would try to send the error - * to the client, which might require changing the mode again, leading - * to infinite recursion. + * Use COMMERROR on failure, because ERROR would try to send the error to + * the client, which might require changing the mode again, leading to + * infinite recursion. */ if (nonblocking) { if (!pg_set_noblock(MyProcPort->sock)) ereport(COMMERROR, - (errmsg("could not set socket to non-blocking mode: %m"))); + (errmsg("could not set socket to non-blocking mode: %m"))); } else { @@ -903,18 +904,17 @@ pq_getbyte_if_available(unsigned char *c) { /* * Ok if no data available without blocking or interrupted (though - * EINTR really shouldn't happen with a non-blocking socket). - * Report other errors. + * EINTR really shouldn't happen with a non-blocking socket). Report + * other errors. */ if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) r = 0; else { /* - * Careful: an ereport() that tries to write to the client - * would cause recursion to here, leading to stack overflow - * and core dump! This message must go *only* to the - * postmaster log. + * Careful: an ereport() that tries to write to the client would + * cause recursion to here, leading to stack overflow and core + * dump! This message must go *only* to the postmaster log. */ ereport(COMMERROR, (errcode_for_socket_access(), @@ -1219,8 +1219,8 @@ internal_flush(void) continue; /* Ok if we were interrupted */ /* - * Ok if no data writable without blocking, and the socket - * is in non-blocking mode. + * Ok if no data writable without blocking, and the socket is in + * non-blocking mode. */ if (errno == EAGAIN || errno == EWOULDBLOCK) @@ -1369,8 +1369,8 @@ fail: void pq_putmessage_noblock(char msgtype, const char *s, size_t len) { - int res; - int required; + int res; + int required; /* * Ensure we have enough space in the output buffer for the message header @@ -1383,7 +1383,8 @@ pq_putmessage_noblock(char msgtype, const char *s, size_t len) PqSendBufferSize = required; } res = pq_putmessage(msgtype, s, len); - Assert(res == 0); /* should not fail when the message fits in buffer */ + Assert(res == 0); /* should not fail when the message fits in + * buffer */ } @@ -1434,13 +1435,13 @@ pq_endcopyout(bool errorAbort) static int pq_setkeepaliveswin32(Port *port, int idle, int interval) { - struct tcp_keepalive ka; - DWORD retsize; + struct tcp_keepalive ka; + DWORD retsize; if (idle <= 0) - idle = 2 * 60 * 60; /* default = 2 hours */ + idle = 2 * 60 * 60; /* default = 2 hours */ if (interval <= 0) - interval = 1; /* default = 1 second */ + interval = 1; /* default = 1 second */ ka.onoff = 1; ka.keepalivetime = idle * 1000; @@ -1500,11 +1501,11 @@ pq_getkeepalivesidle(Port *port) elog(LOG, "getsockopt(TCP_KEEPALIVE) failed: %m"); port->default_keepalives_idle = -1; /* don't know */ } -#endif /* TCP_KEEPIDLE */ -#else /* WIN32 */ +#endif /* TCP_KEEPIDLE */ +#else /* WIN32 */ /* We can't get the defaults on Windows, so return "don't know" */ port->default_keepalives_idle = -1; -#endif /* WIN32 */ +#endif /* WIN32 */ } return port->default_keepalives_idle; @@ -1555,10 +1556,10 @@ pq_setkeepalivesidle(int idle, Port *port) #endif port->keepalives_idle = idle; -#else /* WIN32 */ +#else /* WIN32 */ return pq_setkeepaliveswin32(port, idle, port->keepalives_interval); #endif -#else /* TCP_KEEPIDLE || SIO_KEEPALIVE_VALS */ +#else /* TCP_KEEPIDLE || SIO_KEEPALIVE_VALS */ if (idle != 0) { elog(LOG, "setting the keepalive idle time is not supported"); @@ -1593,7 +1594,7 @@ pq_getkeepalivesinterval(Port *port) #else /* We can't get the defaults on Windows, so return "don't know" */ port->default_keepalives_interval = -1; -#endif /* WIN32 */ +#endif /* WIN32 */ } return port->default_keepalives_interval; @@ -1635,7 +1636,7 @@ pq_setkeepalivesinterval(int interval, Port *port) } port->keepalives_interval = interval; -#else /* WIN32 */ +#else /* WIN32 */ return pq_setkeepaliveswin32(port, port->keepalives_idle, interval); #endif #else diff --git a/src/backend/main/main.c b/src/backend/main/main.c index 43d182b4dba..c4ef56dc6c6 100644 --- a/src/backend/main/main.c +++ b/src/backend/main/main.c @@ -204,7 +204,7 @@ main(int argc, char *argv[]) /* * Place platform-specific startup hacks here. This is the right * place to put code that must be executed early in the launch of any new - * server process. Note that this code will NOT be executed when a backend + * server process. Note that this code will NOT be executed when a backend * or sub-bootstrap process is forked, unless we are in a fork/exec * environment (ie EXEC_BACKEND is defined). * @@ -218,8 +218,8 @@ startup_hacks(const char *progname) /* * On some platforms, unaligned memory accesses result in a kernel trap; * the default kernel behavior is to emulate the memory access, but this - * results in a significant performance penalty. We want PG never to - * make such unaligned memory accesses, so this code disables the kernel + * results in a significant performance penalty. We want PG never to make + * such unaligned memory accesses, so this code disables the kernel * emulation: unaligned accesses will result in SIGBUS instead. */ #ifdef NOFIXADE @@ -230,7 +230,7 @@ startup_hacks(const char *progname) #if defined(__alpha) /* no __alpha__ ? */ { - int buffer[] = {SSIN_UACPROC, UAC_SIGBUS | UAC_NOPRINT}; + int buffer[] = {SSIN_UACPROC, UAC_SIGBUS | UAC_NOPRINT}; if (setsysinfo(SSI_NVPAIRS, buffer, 1, (caddr_t) NULL, (unsigned long) NULL) < 0) @@ -238,7 +238,6 @@ startup_hacks(const char *progname) progname, strerror(errno)); } #endif /* __alpha */ - #endif /* NOFIXADE */ /* diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c index 0eac9826a4e..c0d2294317e 100644 --- a/src/backend/nodes/copyfuncs.c +++ b/src/backend/nodes/copyfuncs.c @@ -581,7 +581,7 @@ _copyForeignScan(ForeignScan *from) static FdwPlan * _copyFdwPlan(FdwPlan *from) { - FdwPlan *newnode = makeNode(FdwPlan); + FdwPlan *newnode = makeNode(FdwPlan); COPY_SCALAR_FIELD(startup_cost); COPY_SCALAR_FIELD(total_cost); @@ -1468,7 +1468,7 @@ _copyConvertRowtypeExpr(ConvertRowtypeExpr *from) static CollateExpr * _copyCollateExpr(CollateExpr *from) { - CollateExpr *newnode = makeNode(CollateExpr); + CollateExpr *newnode = makeNode(CollateExpr); COPY_NODE_FIELD(arg); COPY_SCALAR_FIELD(collOid); @@ -2269,7 +2269,7 @@ _copyTypeCast(TypeCast *from) static CollateClause * _copyCollateClause(CollateClause *from) { - CollateClause *newnode = makeNode(CollateClause); + CollateClause *newnode = makeNode(CollateClause); COPY_NODE_FIELD(arg); COPY_NODE_FIELD(collname); diff --git a/src/backend/nodes/nodeFuncs.c b/src/backend/nodes/nodeFuncs.c index af1ccb7efec..0e57f6c6d7d 100644 --- a/src/backend/nodes/nodeFuncs.c +++ b/src/backend/nodes/nodeFuncs.c @@ -675,10 +675,10 @@ exprCollation(Node *expr) coll = ((NullIfExpr *) expr)->opcollid; break; case T_ScalarArrayOpExpr: - coll = InvalidOid; /* result is always boolean */ + coll = InvalidOid; /* result is always boolean */ break; case T_BoolExpr: - coll = InvalidOid; /* result is always boolean */ + coll = InvalidOid; /* result is always boolean */ break; case T_SubLink: { @@ -736,7 +736,7 @@ exprCollation(Node *expr) coll = ((FieldSelect *) expr)->resultcollid; break; case T_FieldStore: - coll = InvalidOid; /* result is always composite */ + coll = InvalidOid; /* result is always composite */ break; case T_RelabelType: coll = ((RelabelType *) expr)->resultcollid; @@ -748,7 +748,7 @@ exprCollation(Node *expr) coll = ((ArrayCoerceExpr *) expr)->resultcollid; break; case T_ConvertRowtypeExpr: - coll = InvalidOid; /* result is always composite */ + coll = InvalidOid; /* result is always composite */ break; case T_CollateExpr: coll = ((CollateExpr *) expr)->collOid; @@ -763,10 +763,10 @@ exprCollation(Node *expr) coll = ((ArrayExpr *) expr)->array_collid; break; case T_RowExpr: - coll = InvalidOid; /* result is always composite */ + coll = InvalidOid; /* result is always composite */ break; case T_RowCompareExpr: - coll = InvalidOid; /* result is always boolean */ + coll = InvalidOid; /* result is always boolean */ break; case T_CoalesceExpr: coll = ((CoalesceExpr *) expr)->coalescecollid; @@ -775,10 +775,11 @@ exprCollation(Node *expr) coll = ((MinMaxExpr *) expr)->minmaxcollid; break; case T_XmlExpr: + /* * XMLSERIALIZE returns text from non-collatable inputs, so its - * collation is always default. The other cases return boolean - * or XML, which are non-collatable. + * collation is always default. The other cases return boolean or + * XML, which are non-collatable. */ if (((XmlExpr *) expr)->op == IS_XMLSERIALIZE) coll = DEFAULT_COLLATION_OID; @@ -786,10 +787,10 @@ exprCollation(Node *expr) coll = InvalidOid; break; case T_NullTest: - coll = InvalidOid; /* result is always boolean */ + coll = InvalidOid; /* result is always boolean */ break; case T_BooleanTest: - coll = InvalidOid; /* result is always boolean */ + coll = InvalidOid; /* result is always boolean */ break; case T_CoerceToDomain: coll = ((CoerceToDomain *) expr)->resultcollid; @@ -801,7 +802,7 @@ exprCollation(Node *expr) coll = ((SetToDefault *) expr)->collation; break; case T_CurrentOfExpr: - coll = InvalidOid; /* result is always boolean */ + coll = InvalidOid; /* result is always boolean */ break; case T_PlaceHolderVar: coll = exprCollation((Node *) ((PlaceHolderVar *) expr)->phexpr); @@ -907,10 +908,10 @@ exprSetCollation(Node *expr, Oid collation) ((NullIfExpr *) expr)->opcollid = collation; break; case T_ScalarArrayOpExpr: - Assert(!OidIsValid(collation)); /* result is always boolean */ + Assert(!OidIsValid(collation)); /* result is always boolean */ break; case T_BoolExpr: - Assert(!OidIsValid(collation)); /* result is always boolean */ + Assert(!OidIsValid(collation)); /* result is always boolean */ break; case T_SubLink: #ifdef USE_ASSERT_CHECKING @@ -937,13 +938,13 @@ exprSetCollation(Node *expr, Oid collation) Assert(!OidIsValid(collation)); } } -#endif /* USE_ASSERT_CHECKING */ +#endif /* USE_ASSERT_CHECKING */ break; case T_FieldSelect: ((FieldSelect *) expr)->resultcollid = collation; break; case T_FieldStore: - Assert(!OidIsValid(collation)); /* result is always composite */ + Assert(!OidIsValid(collation)); /* result is always composite */ break; case T_RelabelType: ((RelabelType *) expr)->resultcollid = collation; @@ -955,7 +956,7 @@ exprSetCollation(Node *expr, Oid collation) ((ArrayCoerceExpr *) expr)->resultcollid = collation; break; case T_ConvertRowtypeExpr: - Assert(!OidIsValid(collation)); /* result is always composite */ + Assert(!OidIsValid(collation)); /* result is always composite */ break; case T_CaseExpr: ((CaseExpr *) expr)->casecollid = collation; @@ -964,10 +965,10 @@ exprSetCollation(Node *expr, Oid collation) ((ArrayExpr *) expr)->array_collid = collation; break; case T_RowExpr: - Assert(!OidIsValid(collation)); /* result is always composite */ + Assert(!OidIsValid(collation)); /* result is always composite */ break; case T_RowCompareExpr: - Assert(!OidIsValid(collation)); /* result is always boolean */ + Assert(!OidIsValid(collation)); /* result is always boolean */ break; case T_CoalesceExpr: ((CoalesceExpr *) expr)->coalescecollid = collation; @@ -981,10 +982,10 @@ exprSetCollation(Node *expr, Oid collation) (collation == InvalidOid)); break; case T_NullTest: - Assert(!OidIsValid(collation)); /* result is always boolean */ + Assert(!OidIsValid(collation)); /* result is always boolean */ break; case T_BooleanTest: - Assert(!OidIsValid(collation)); /* result is always boolean */ + Assert(!OidIsValid(collation)); /* result is always boolean */ break; case T_CoerceToDomain: ((CoerceToDomain *) expr)->resultcollid = collation; @@ -996,7 +997,7 @@ exprSetCollation(Node *expr, Oid collation) ((SetToDefault *) expr)->collation = collation; break; case T_CurrentOfExpr: - Assert(!OidIsValid(collation)); /* result is always boolean */ + Assert(!OidIsValid(collation)); /* result is always boolean */ break; default: elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr)); diff --git a/src/backend/nodes/params.c b/src/backend/nodes/params.c index d6e6e6a2bda..62d766a2827 100644 --- a/src/backend/nodes/params.c +++ b/src/backend/nodes/params.c @@ -43,7 +43,7 @@ copyParamList(ParamListInfo from) /* sizeof(ParamListInfoData) includes the first array element */ size = sizeof(ParamListInfoData) + - (from->numParams - 1) *sizeof(ParamExternData); + (from->numParams - 1) * sizeof(ParamExternData); retval = (ParamListInfo) palloc(size); retval->paramFetch = NULL; diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c index dc2a23bb273..47ab08e502e 100644 --- a/src/backend/optimizer/path/allpaths.c +++ b/src/backend/optimizer/path/allpaths.c @@ -66,7 +66,7 @@ static void set_cte_pathlist(PlannerInfo *root, RelOptInfo *rel, static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte); static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel, - RangeTblEntry *rte); + RangeTblEntry *rte); static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist); static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery, bool *differentTypes); @@ -413,11 +413,11 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, /* * We have to make child entries in the EquivalenceClass data - * structures as well. This is needed either if the parent - * participates in some eclass joins (because we will want to - * consider inner-indexscan joins on the individual children) - * or if the parent has useful pathkeys (because we should try - * to build MergeAppend paths that produce those sort orderings). + * structures as well. This is needed either if the parent + * participates in some eclass joins (because we will want to consider + * inner-indexscan joins on the individual children) or if the parent + * has useful pathkeys (because we should try to build MergeAppend + * paths that produce those sort orderings). */ if (rel->has_eclass_joins || has_useful_pathkeys(root, rel)) add_child_rel_equivalences(root, appinfo, rel, childrel); @@ -462,7 +462,7 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, /* Have we already seen this ordering? */ foreach(lpk, all_child_pathkeys) { - List *existing_pathkeys = (List *) lfirst(lpk); + List *existing_pathkeys = (List *) lfirst(lpk); if (compare_pathkeys(existing_pathkeys, childkeys) == PATHKEYS_EQUAL) @@ -540,18 +540,18 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, /* * Next, build MergeAppend paths based on the collected list of child - * pathkeys. We consider both cheapest-startup and cheapest-total - * cases, ie, for each interesting ordering, collect all the cheapest - * startup subpaths and all the cheapest total paths, and build a - * MergeAppend path for each list. + * pathkeys. We consider both cheapest-startup and cheapest-total cases, + * ie, for each interesting ordering, collect all the cheapest startup + * subpaths and all the cheapest total paths, and build a MergeAppend path + * for each list. */ foreach(l, all_child_pathkeys) { - List *pathkeys = (List *) lfirst(l); - List *startup_subpaths = NIL; - List *total_subpaths = NIL; - bool startup_neq_total = false; - ListCell *lcr; + List *pathkeys = (List *) lfirst(l); + List *startup_subpaths = NIL; + List *total_subpaths = NIL; + bool startup_neq_total = false; + ListCell *lcr; /* Select the child paths for this ordering... */ foreach(lcr, live_childrels) @@ -581,8 +581,8 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, /* * Notice whether we actually have different paths for the - * "cheapest" and "total" cases; frequently there will be no - * point in two create_merge_append_path() calls. + * "cheapest" and "total" cases; frequently there will be no point + * in two create_merge_append_path() calls. */ if (cheapest_startup != cheapest_total) startup_neq_total = true; @@ -623,7 +623,7 @@ accumulate_append_subpath(List *subpaths, Path *path) { if (IsA(path, AppendPath)) { - AppendPath *apath = (AppendPath *) path; + AppendPath *apath = (AppendPath *) path; /* list_copy is important here to avoid sharing list substructure */ return list_concat(subpaths, list_copy(apath->subpaths)); diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c index 8f763b43695..e200dcf4728 100644 --- a/src/backend/optimizer/path/costsize.c +++ b/src/backend/optimizer/path/costsize.c @@ -1096,7 +1096,7 @@ cost_recursive_union(Plan *runion, Plan *nrterm, Plan *rterm) * accesses (XXX can't we refine that guess?) * * By default, we charge two operator evals per tuple comparison, which should - * be in the right ballpark in most cases. The caller can tweak this by + * be in the right ballpark in most cases. The caller can tweak this by * specifying nonzero comparison_cost; typically that's used for any extra * work that has to be done to prepare the inputs to the comparison operators. * @@ -1218,7 +1218,7 @@ cost_sort(Path *path, PlannerInfo *root, * Determines and returns the cost of a MergeAppend node. * * MergeAppend merges several pre-sorted input streams, using a heap that - * at any given instant holds the next tuple from each stream. If there + * at any given instant holds the next tuple from each stream. If there * are N streams, we need about N*log2(N) tuple comparisons to construct * the heap at startup, and then for each output tuple, about log2(N) * comparisons to delete the top heap entry and another log2(N) comparisons @@ -2909,7 +2909,7 @@ adjust_semi_join(PlannerInfo *root, JoinPath *path, SpecialJoinInfo *sjinfo, List *nrclauses; nrclauses = select_nonredundant_join_clauses(root, - path->joinrestrictinfo, + path->joinrestrictinfo, path->innerjoinpath); *indexed_join_quals = (nrclauses == NIL); } @@ -3185,7 +3185,7 @@ set_subquery_size_estimates(PlannerInfo *root, RelOptInfo *rel, /* * Compute per-output-column width estimates by examining the subquery's - * targetlist. For any output that is a plain Var, get the width estimate + * targetlist. For any output that is a plain Var, get the width estimate * that was made while planning the subquery. Otherwise, fall back on a * datatype-based estimate. */ @@ -3210,7 +3210,7 @@ set_subquery_size_estimates(PlannerInfo *root, RelOptInfo *rel, if (IsA(texpr, Var) && subroot->parse->setOperations == NULL) { - Var *var = (Var *) texpr; + Var *var = (Var *) texpr; RelOptInfo *subrel = find_base_rel(subroot, var->varno); item_width = subrel->attr_widths[var->varattno - subrel->min_attr]; @@ -3332,7 +3332,7 @@ set_cte_size_estimates(PlannerInfo *root, RelOptInfo *rel, Plan *cteplan) * of estimating baserestrictcost, so we set that, and we also set up width * using what will be purely datatype-driven estimates from the targetlist. * There is no way to do anything sane with the rows value, so we just put - * a default estimate and hope that the wrapper can improve on it. The + * a default estimate and hope that the wrapper can improve on it. The * wrapper's PlanForeignScan function will be called momentarily. * * The rel's targetlist and restrictinfo list must have been constructed @@ -3396,8 +3396,8 @@ set_rel_width(PlannerInfo *root, RelOptInfo *rel) ndx = var->varattno - rel->min_attr; /* - * If it's a whole-row Var, we'll deal with it below after we - * have already cached as many attr widths as possible. + * If it's a whole-row Var, we'll deal with it below after we have + * already cached as many attr widths as possible. */ if (var->varattno == 0) { @@ -3406,8 +3406,8 @@ set_rel_width(PlannerInfo *root, RelOptInfo *rel) } /* - * The width may have been cached already (especially if it's - * a subquery), so don't duplicate effort. + * The width may have been cached already (especially if it's a + * subquery), so don't duplicate effort. */ if (rel->attr_widths[ndx] > 0) { @@ -3464,13 +3464,13 @@ set_rel_width(PlannerInfo *root, RelOptInfo *rel) */ if (have_wholerow_var) { - int32 wholerow_width = sizeof(HeapTupleHeaderData); + int32 wholerow_width = sizeof(HeapTupleHeaderData); if (reloid != InvalidOid) { /* Real relation, so estimate true tuple width */ wholerow_width += get_relation_data_width(reloid, - rel->attr_widths - rel->min_attr); + rel->attr_widths - rel->min_attr); } else { @@ -3484,8 +3484,8 @@ set_rel_width(PlannerInfo *root, RelOptInfo *rel) rel->attr_widths[0 - rel->min_attr] = wholerow_width; /* - * Include the whole-row Var as part of the output tuple. Yes, - * that really is what happens at runtime. + * Include the whole-row Var as part of the output tuple. Yes, that + * really is what happens at runtime. */ tuple_width += wholerow_width; } diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c index 9a32e16940b..a365beecd8a 100644 --- a/src/backend/optimizer/path/equivclass.c +++ b/src/backend/optimizer/path/equivclass.c @@ -385,7 +385,7 @@ process_equivalence(PlannerInfo *root, RestrictInfo *restrictinfo, * Also, the expression's exposed collation must match the EC's collation. * This is important because in comparisons like "foo < bar COLLATE baz", * only one of the expressions has the correct exposed collation as we receive - * it from the parser. Forcing both of them to have it ensures that all + * it from the parser. Forcing both of them to have it ensures that all * variant spellings of such a construct behave the same. Again, we can * stick on a RelabelType to force the right exposed collation. (It might * work to not label the collation at all in EC members, but this is risky @@ -414,13 +414,13 @@ canonicalize_ec_expression(Expr *expr, Oid req_type, Oid req_collation) exprCollation((Node *) expr) != req_collation) { /* - * Strip any existing RelabelType, then add a new one if needed. - * This is to preserve the invariant of no redundant RelabelTypes. + * Strip any existing RelabelType, then add a new one if needed. This + * is to preserve the invariant of no redundant RelabelTypes. * * If we have to change the exposed type of the stripped expression, * set typmod to -1 (since the new type may not have the same typmod - * interpretation). If we only have to change collation, preserve - * the exposed typmod. + * interpretation). If we only have to change collation, preserve the + * exposed typmod. */ while (expr && IsA(expr, RelabelType)) expr = (Expr *) ((RelabelType *) expr)->arg; @@ -1784,8 +1784,8 @@ add_child_rel_equivalences(PlannerInfo *root, ListCell *lc2; /* - * If this EC contains a constant, then it's not useful for sorting - * or driving an inner index-scan, so we skip generating child EMs. + * If this EC contains a constant, then it's not useful for sorting or + * driving an inner index-scan, so we skip generating child EMs. * * If this EC contains a volatile expression, then generating child * EMs would be downright dangerous. We rely on a volatile EC having diff --git a/src/backend/optimizer/path/indxpath.c b/src/backend/optimizer/path/indxpath.c index 76f842631fa..ef65cf22244 100644 --- a/src/backend/optimizer/path/indxpath.c +++ b/src/backend/optimizer/path/indxpath.c @@ -119,7 +119,7 @@ static bool match_special_index_operator(Expr *clause, static Expr *expand_boolean_index_clause(Node *clause, int indexcol, IndexOptInfo *index); static List *expand_indexqual_opclause(RestrictInfo *rinfo, - Oid opfamily, Oid idxcollation); + Oid opfamily, Oid idxcollation); static RestrictInfo *expand_indexqual_rowcompare(RestrictInfo *rinfo, IndexOptInfo *index, int indexcol); @@ -1159,8 +1159,8 @@ group_clauses_by_indexkey(IndexOptInfo *index, * (2) must contain an operator which is in the same family as the index * operator for this column, or is a "special" operator as recognized * by match_special_index_operator(); - * and - * (3) must match the collation of the index, if collation is relevant. + * and + * (3) must match the collation of the index, if collation is relevant. * * Our definition of "const" is pretty liberal: we allow Vars belonging * to the caller-specified outer_relids relations (which had better not @@ -1312,7 +1312,7 @@ match_clause_to_indexcol(IndexOptInfo *index, * is a "special" indexable operator. */ if (plain_op && - match_special_index_operator(clause, opfamily, idxcollation, true)) + match_special_index_operator(clause, opfamily, idxcollation, true)) return true; return false; } @@ -1438,7 +1438,7 @@ match_rowcompare_to_indexcol(IndexOptInfo *index, /**************************************************************************** - * ---- ROUTINES TO CHECK ORDERING OPERATORS ---- + * ---- ROUTINES TO CHECK ORDERING OPERATORS ---- ****************************************************************************/ /* @@ -1461,7 +1461,7 @@ match_index_to_pathkeys(IndexOptInfo *index, List *pathkeys) foreach(lc1, pathkeys) { - PathKey *pathkey = (PathKey *) lfirst(lc1); + PathKey *pathkey = (PathKey *) lfirst(lc1); bool found = false; ListCell *lc2; @@ -1483,7 +1483,7 @@ match_index_to_pathkeys(IndexOptInfo *index, List *pathkeys) foreach(lc2, pathkey->pk_eclass->ec_members) { EquivalenceMember *member = (EquivalenceMember *) lfirst(lc2); - int indexcol; + int indexcol; /* No possibility of match if it references other relations */ if (!bms_equal(member->em_relids, index->rel->relids)) @@ -1491,7 +1491,7 @@ match_index_to_pathkeys(IndexOptInfo *index, List *pathkeys) for (indexcol = 0; indexcol < index->ncolumns; indexcol++) { - Expr *expr; + Expr *expr; expr = match_clause_to_ordering_op(index, indexcol, @@ -1535,7 +1535,7 @@ match_index_to_pathkeys(IndexOptInfo *index, List *pathkeys) * Note that we currently do not consider the collation of the ordering * operator's result. In practical cases the result type will be numeric * and thus have no collation, and it's not very clear what to match to - * if it did have a collation. The index's collation should match the + * if it did have a collation. The index's collation should match the * ordering operator's input collation, not its result. * * If successful, return 'clause' as-is if the indexkey is on the left, @@ -1598,8 +1598,8 @@ match_clause_to_ordering_op(IndexOptInfo *index, return NULL; /* - * Is the (commuted) operator an ordering operator for the opfamily? - * And if so, does it yield the right sorting semantics? + * Is the (commuted) operator an ordering operator for the opfamily? And + * if so, does it yield the right sorting semantics? */ sortfamily = get_op_opfamily_sortfamily(expr_op, opfamily); if (sortfamily != pk_opfamily) @@ -2198,9 +2198,9 @@ relation_has_unique_index_for(PlannerInfo *root, RelOptInfo *rel, continue; /* - * XXX at some point we may need to check collations here - * too. For the moment we assume all collations reduce to - * the same notion of equality. + * XXX at some point we may need to check collations here too. + * For the moment we assume all collations reduce to the same + * notion of equality. */ /* OK, see if the condition operand matches the index key */ @@ -2544,10 +2544,10 @@ match_special_index_operator(Expr *clause, Oid opfamily, Oid idxcollation, * * The non-pattern opclasses will not sort the way we need in most non-C * locales. We can use such an index anyway for an exact match (simple - * equality), but not for prefix-match cases. Note that we are looking - * at the index's collation, not the expression's collation -- this test - * is not dependent on the LIKE/regex operator's collation (which would - * only affect case folding behavior of ILIKE, anyway). + * equality), but not for prefix-match cases. Note that we are looking at + * the index's collation, not the expression's collation -- this test is + * not dependent on the LIKE/regex operator's collation (which would only + * affect case folding behavior of ILIKE, anyway). */ switch (expr_op) { @@ -2657,7 +2657,7 @@ expand_indexqual_conditions(IndexOptInfo *index, List *clausegroups) resultquals = list_concat(resultquals, expand_indexqual_opclause(rinfo, curFamily, - curCollation)); + curCollation)); } else if (IsA(clause, ScalarArrayOpExpr)) { @@ -3254,7 +3254,7 @@ network_prefix_quals(Node *leftop, Oid expr_op, Oid opfamily, Datum rightop) expr = make_opclause(opr1oid, BOOLOID, false, (Expr *) leftop, (Expr *) makeConst(datatype, -1, - InvalidOid, /* not collatable */ + InvalidOid, /* not collatable */ -1, opr1right, false, false), InvalidOid, InvalidOid); @@ -3272,7 +3272,7 @@ network_prefix_quals(Node *leftop, Oid expr_op, Oid opfamily, Datum rightop) expr = make_opclause(opr2oid, BOOLOID, false, (Expr *) leftop, (Expr *) makeConst(datatype, -1, - InvalidOid, /* not collatable */ + InvalidOid, /* not collatable */ -1, opr2right, false, false), InvalidOid, InvalidOid); diff --git a/src/backend/optimizer/path/joinpath.c b/src/backend/optimizer/path/joinpath.c index 740dc32dc78..7d3cf425da5 100644 --- a/src/backend/optimizer/path/joinpath.c +++ b/src/backend/optimizer/path/joinpath.c @@ -97,11 +97,11 @@ add_paths_to_joinrel(PlannerInfo *root, /* * 1. Consider mergejoin paths where both relations must be explicitly - * sorted. Skip this if we can't mergejoin. + * sorted. Skip this if we can't mergejoin. */ if (mergejoin_allowed) sort_inner_and_outer(root, joinrel, outerrel, innerrel, - restrictlist, mergeclause_list, jointype, sjinfo); + restrictlist, mergeclause_list, jointype, sjinfo); /* * 2. Consider paths where the outer relation need not be explicitly @@ -112,7 +112,7 @@ add_paths_to_joinrel(PlannerInfo *root, */ if (mergejoin_allowed) match_unsorted_outer(root, joinrel, outerrel, innerrel, - restrictlist, mergeclause_list, jointype, sjinfo); + restrictlist, mergeclause_list, jointype, sjinfo); #ifdef NOT_USED @@ -129,7 +129,7 @@ add_paths_to_joinrel(PlannerInfo *root, */ if (mergejoin_allowed) match_unsorted_inner(root, joinrel, outerrel, innerrel, - restrictlist, mergeclause_list, jointype, sjinfo); + restrictlist, mergeclause_list, jointype, sjinfo); #endif /* diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c index 42618649fb9..bbb79c582de 100644 --- a/src/backend/optimizer/path/joinrels.c +++ b/src/backend/optimizer/path/joinrels.c @@ -30,7 +30,7 @@ static bool has_legal_joinclause(PlannerInfo *root, RelOptInfo *rel); static bool is_dummy_rel(RelOptInfo *rel); static void mark_dummy_rel(RelOptInfo *rel); static bool restriction_is_constant_false(List *restrictlist, - bool only_pushed_down); + bool only_pushed_down); /* @@ -604,10 +604,10 @@ make_join_rel(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2) * * Also, a provably constant-false join restriction typically means that * we can skip evaluating one or both sides of the join. We do this by - * marking the appropriate rel as dummy. For outer joins, a constant-false - * restriction that is pushed down still means the whole join is dummy, - * while a non-pushed-down one means that no inner rows will join so we - * can treat the inner rel as dummy. + * marking the appropriate rel as dummy. For outer joins, a + * constant-false restriction that is pushed down still means the whole + * join is dummy, while a non-pushed-down one means that no inner rows + * will join so we can treat the inner rel as dummy. * * We need only consider the jointypes that appear in join_info_list, plus * JOIN_INNER. diff --git a/src/backend/optimizer/path/pathkeys.c b/src/backend/optimizer/path/pathkeys.c index 47597a5d35b..e5228a81c63 100644 --- a/src/backend/optimizer/path/pathkeys.c +++ b/src/backend/optimizer/path/pathkeys.c @@ -253,7 +253,7 @@ make_pathkey_from_sortinfo(PlannerInfo *root, /* * EquivalenceClasses need to contain opfamily lists based on the family * membership of mergejoinable equality operators, which could belong to - * more than one opfamily. So we have to look up the opfamily's equality + * more than one opfamily. So we have to look up the opfamily's equality * operator and get its membership. */ equality_op = get_opfamily_member(opfamily, @@ -558,9 +558,9 @@ build_index_pathkeys(PlannerInfo *root, true); /* - * If the sort key isn't already present in any EquivalenceClass, - * then it's not an interesting sort order for this query. So - * we can stop now --- lower-order sort keys aren't useful either. + * If the sort key isn't already present in any EquivalenceClass, then + * it's not an interesting sort order for this query. So we can stop + * now --- lower-order sort keys aren't useful either. */ if (!cpathkey) break; @@ -747,8 +747,8 @@ convert_subquery_pathkeys(PlannerInfo *root, RelOptInfo *rel, continue; /* - * Build a representation of this targetlist entry as - * an outer Var. + * Build a representation of this targetlist entry as an + * outer Var. */ outer_expr = (Expr *) makeVarFromTargetEntry(rel->relid, tle); @@ -923,7 +923,7 @@ make_pathkeys_for_sortclauses(PlannerInfo *root, * right sides. * * Note this is called before EC merging is complete, so the links won't - * necessarily point to canonical ECs. Before they are actually used for + * necessarily point to canonical ECs. Before they are actually used for * anything, update_mergeclause_eclasses must be called to ensure that * they've been updated to point to canonical ECs. */ diff --git a/src/backend/optimizer/plan/analyzejoins.c b/src/backend/optimizer/plan/analyzejoins.c index 80d42f3be60..1784ac2fc5b 100644 --- a/src/backend/optimizer/plan/analyzejoins.c +++ b/src/backend/optimizer/plan/analyzejoins.c @@ -31,7 +31,7 @@ /* local functions */ static bool join_is_removable(PlannerInfo *root, SpecialJoinInfo *sjinfo); static void remove_rel_from_query(PlannerInfo *root, int relid, - Relids joinrelids); + Relids joinrelids); static List *remove_rel_from_joinlist(List *joinlist, int relid, int *nremoved); @@ -238,10 +238,10 @@ join_is_removable(PlannerInfo *root, SpecialJoinInfo *sjinfo) !bms_equal(restrictinfo->required_relids, joinrelids)) { /* - * If such a clause actually references the inner rel then - * join removal has to be disallowed. We have to check this - * despite the previous attr_needed checks because of the - * possibility of pushed-down clauses referencing the rel. + * If such a clause actually references the inner rel then join + * removal has to be disallowed. We have to check this despite + * the previous attr_needed checks because of the possibility of + * pushed-down clauses referencing the rel. */ if (bms_is_member(innerrelid, restrictinfo->clause_relids)) return false; @@ -365,8 +365,8 @@ remove_rel_from_query(PlannerInfo *root, int relid, Relids joinrelids) * Likewise remove references from SpecialJoinInfo data structures. * * This is relevant in case the outer join we're deleting is nested inside - * other outer joins: the upper joins' relid sets have to be adjusted. - * The RHS of the target outer join will be made empty here, but that's OK + * other outer joins: the upper joins' relid sets have to be adjusted. The + * RHS of the target outer join will be made empty here, but that's OK * since caller will delete that SpecialJoinInfo entirely. */ foreach(l, root->join_info_list) @@ -426,6 +426,7 @@ remove_rel_from_query(PlannerInfo *root, int relid, Relids joinrelids) { /* Recheck that qual doesn't actually reference the target rel */ Assert(!bms_is_member(relid, rinfo->clause_relids)); + /* * The required_relids probably aren't shared with anything else, * but let's copy them just to be sure. diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c index f1308812515..1a9540ce068 100644 --- a/src/backend/optimizer/plan/createplan.c +++ b/src/backend/optimizer/plan/createplan.c @@ -108,7 +108,7 @@ static TidScan *make_tidscan(List *qptlist, List *qpqual, Index scanrelid, List *tidquals); static FunctionScan *make_functionscan(List *qptlist, List *qpqual, Index scanrelid, Node *funcexpr, List *funccolnames, - List *funccoltypes, List *funccoltypmods, List *funccolcollations); + List *funccoltypes, List *funccoltypmods, List *funccolcollations); static ValuesScan *make_valuesscan(List *qptlist, List *qpqual, Index scanrelid, List *values_lists); static CteScan *make_ctescan(List *qptlist, List *qpqual, @@ -143,24 +143,25 @@ static MergeJoin *make_mergejoin(List *tlist, bool *mergenullsfirst, Plan *lefttree, Plan *righttree, JoinType jointype); -static Sort *make_sort(PlannerInfo *root, Plan *lefttree, int numCols, - AttrNumber *sortColIdx, Oid *sortOperators, Oid *collations, bool *nullsFirst, +static Sort * +make_sort(PlannerInfo *root, Plan *lefttree, int numCols, +AttrNumber *sortColIdx, Oid *sortOperators, Oid *collations, bool *nullsFirst, double limit_tuples); static Plan *prepare_sort_from_pathkeys(PlannerInfo *root, - Plan *lefttree, List *pathkeys, - bool adjust_tlist_in_place, - int *p_numsortkeys, - AttrNumber **p_sortColIdx, - Oid **p_sortOperators, - Oid **p_collations, - bool **p_nullsFirst); + Plan *lefttree, List *pathkeys, + bool adjust_tlist_in_place, + int *p_numsortkeys, + AttrNumber **p_sortColIdx, + Oid **p_sortOperators, + Oid **p_collations, + bool **p_nullsFirst); static Material *make_material(Plan *lefttree); /* * create_plan * Creates the access plan for a query by recursively processing the - * desired tree of pathnodes, starting at the node 'best_path'. For + * desired tree of pathnodes, starting at the node 'best_path'. For * every pathnode found, we create a corresponding plan node containing * appropriate id, target list, and qualification information. * @@ -737,7 +738,7 @@ create_merge_append_plan(PlannerInfo *root, MergeAppendPath *best_path) /* Now, insert a Sort node if subplan isn't sufficiently ordered */ if (!pathkeys_contained_in(pathkeys, subpath->pathkeys)) subplan = (Plan *) make_sort(root, subplan, numsortkeys, - sortColIdx, sortOperators, collations, nullsFirst, + sortColIdx, sortOperators, collations, nullsFirst, best_path->limit_tuples); subplans = lappend(subplans, subplan); @@ -983,7 +984,7 @@ create_unique_plan(PlannerInfo *root, UniquePath *best_path) sortcl->eqop = eqop; sortcl->sortop = sortop; sortcl->nulls_first = false; - sortcl->hashable = false; /* no need to make this accurate */ + sortcl->hashable = false; /* no need to make this accurate */ sortList = lappend(sortList, sortcl); groupColPos++; } @@ -1153,8 +1154,8 @@ create_indexscan_plan(PlannerInfo *root, qpqual = extract_actual_clauses(qpqual, false); /* - * We have to replace any outer-relation variables with nestloop params - * in the indexqualorig, qpqual, and indexorderbyorig expressions. A bit + * We have to replace any outer-relation variables with nestloop params in + * the indexqualorig, qpqual, and indexorderbyorig expressions. A bit * annoying to have to do this separately from the processing in * fix_indexqual_references --- rethink this when generalizing the inner * indexscan support. But note we can't really do this earlier because @@ -1465,6 +1466,7 @@ create_bitmap_subplan(PlannerInfo *root, Path *bitmapqual, *indexqual = lappend(*indexqual, pred); } } + /* * Replace outer-relation variables with nestloop params, but only * after doing the above comparisons to index predicates. @@ -2330,10 +2332,10 @@ replace_nestloop_params_mutator(Node *node, PlannerInfo *root) return NULL; if (IsA(node, Var)) { - Var *var = (Var *) node; - Param *param; + Var *var = (Var *) node; + Param *param; NestLoopParam *nlp; - ListCell *lc; + ListCell *lc; /* Upper-level Vars should be long gone at this point */ Assert(var->varlevelsup == 0); @@ -2493,7 +2495,7 @@ fix_indexqual_references(PlannerInfo *root, IndexPath *index_path, * * This is a simplified version of fix_indexqual_references. The input does * not have RestrictInfo nodes, and we assume that indxqual.c already - * commuted the clauses to put the index keys on the left. Also, we don't + * commuted the clauses to put the index keys on the left. Also, we don't * bother to support any cases except simple OpExprs, since nothing else * is allowed for ordering operators. */ @@ -3082,8 +3084,8 @@ make_append(List *appendplans, List *tlist) * If you change this, see also create_append_path(). Also, the size * calculations should match set_append_rel_pathlist(). It'd be better * not to duplicate all this logic, but some callers of this function - * aren't working from an appendrel or AppendPath, so there's noplace - * to copy the data from. + * aren't working from an appendrel or AppendPath, so there's noplace to + * copy the data from. */ plan->startup_cost = 0; plan->total_cost = 0; @@ -3320,7 +3322,7 @@ make_mergejoin(List *tlist, */ static Sort * make_sort(PlannerInfo *root, Plan *lefttree, int numCols, - AttrNumber *sortColIdx, Oid *sortOperators, Oid *collations, bool *nullsFirst, +AttrNumber *sortColIdx, Oid *sortOperators, Oid *collations, bool *nullsFirst, double limit_tuples) { Sort *node = makeNode(Sort); @@ -3398,7 +3400,7 @@ add_sort_column(AttrNumber colIdx, Oid sortOp, Oid coll, bool nulls_first, * prepare_sort_from_pathkeys * Prepare to sort according to given pathkeys * - * This is used to set up for both Sort and MergeAppend nodes. It calculates + * This is used to set up for both Sort and MergeAppend nodes. It calculates * the executor's representation of the sort key information, and adjusts the * plan targetlist if needed to add resjunk sort columns. * @@ -3608,7 +3610,7 @@ prepare_sort_from_pathkeys(PlannerInfo *root, Plan *lefttree, List *pathkeys, pathkey->pk_eclass->ec_collation, pathkey->pk_nulls_first, numsortkeys, - sortColIdx, sortOperators, collations, nullsFirst); + sortColIdx, sortOperators, collations, nullsFirst); } Assert(numsortkeys > 0); @@ -3653,7 +3655,7 @@ make_sort_from_pathkeys(PlannerInfo *root, Plan *lefttree, List *pathkeys, /* Now build the Sort node */ return make_sort(root, lefttree, numsortkeys, - sortColIdx, sortOperators, collations, nullsFirst, limit_tuples); + sortColIdx, sortOperators, collations, nullsFirst, limit_tuples); } /* @@ -3699,7 +3701,7 @@ make_sort_from_sortclauses(PlannerInfo *root, List *sortcls, Plan *lefttree) exprCollation((Node *) tle->expr), sortcl->nulls_first, numsortkeys, - sortColIdx, sortOperators, collations, nullsFirst); + sortColIdx, sortOperators, collations, nullsFirst); } Assert(numsortkeys > 0); @@ -3761,7 +3763,7 @@ make_sort_from_groupcols(PlannerInfo *root, exprCollation((Node *) tle->expr), grpcl->nulls_first, numsortkeys, - sortColIdx, sortOperators, collations, nullsFirst); + sortColIdx, sortOperators, collations, nullsFirst); grpno++; } diff --git a/src/backend/optimizer/plan/initsplan.c b/src/backend/optimizer/plan/initsplan.c index 0e00df64335..333ede218ea 100644 --- a/src/backend/optimizer/plan/initsplan.c +++ b/src/backend/optimizer/plan/initsplan.c @@ -188,10 +188,11 @@ add_vars_to_targetlist(PlannerInfo *root, List *vars, Relids where_needed) phinfo->ph_needed = bms_add_members(phinfo->ph_needed, where_needed); + /* - * Update ph_may_need too. This is currently only necessary - * when being called from build_base_rel_tlists, but we may as - * well do it always. + * Update ph_may_need too. This is currently only necessary when + * being called from build_base_rel_tlists, but we may as well do + * it always. */ phinfo->ph_may_need = bms_add_members(phinfo->ph_may_need, where_needed); @@ -704,8 +705,8 @@ make_outerjoininfo(PlannerInfo *root, * this join's nullable side, and it may get used above this join, then * ensure that min_righthand contains the full eval_at set of the PHV. * This ensures that the PHV actually can be evaluated within the RHS. - * Note that this works only because we should already have determined - * the final eval_at level for any PHV syntactically within this join. + * Note that this works only because we should already have determined the + * final eval_at level for any PHV syntactically within this join. */ foreach(l, root->placeholder_list) { @@ -1070,7 +1071,7 @@ distribute_qual_to_rels(PlannerInfo *root, Node *clause, * * In all cases, it's important to initialize the left_ec and right_ec * fields of a mergejoinable clause, so that all possibly mergejoinable - * expressions have representations in EquivalenceClasses. If + * expressions have representations in EquivalenceClasses. If * process_equivalence is successful, it will take care of that; * otherwise, we have to call initialize_mergeclause_eclasses to do it. */ diff --git a/src/backend/optimizer/plan/planagg.c b/src/backend/optimizer/plan/planagg.c index f2ddf2a8442..7fce92c2f15 100644 --- a/src/backend/optimizer/plan/planagg.c +++ b/src/backend/optimizer/plan/planagg.c @@ -10,9 +10,9 @@ * ORDER BY col ASC/DESC * LIMIT 1) * Given a suitable index on tab.col, this can be much faster than the - * generic scan-all-the-rows aggregation plan. We can handle multiple + * generic scan-all-the-rows aggregation plan. We can handle multiple * MIN/MAX aggregates by generating multiple subqueries, and their - * orderings can be different. However, if the query contains any + * orderings can be different. However, if the query contains any * non-optimizable aggregates, there's no point since we'll have to * scan all the rows anyway. * @@ -87,10 +87,10 @@ preprocess_minmax_aggregates(PlannerInfo *root, List *tlist) * * We don't handle GROUP BY or windowing, because our current * implementations of grouping require looking at all the rows anyway, and - * so there's not much point in optimizing MIN/MAX. (Note: relaxing - * this would likely require some restructuring in grouping_planner(), - * since it performs assorted processing related to these features between - * calling preprocess_minmax_aggregates and optimize_minmax_aggregates.) + * so there's not much point in optimizing MIN/MAX. (Note: relaxing this + * would likely require some restructuring in grouping_planner(), since it + * performs assorted processing related to these features between calling + * preprocess_minmax_aggregates and optimize_minmax_aggregates.) */ if (parse->groupClause || parse->hasWindowFuncs) return; @@ -119,7 +119,7 @@ preprocess_minmax_aggregates(PlannerInfo *root, List *tlist) /* * Scan the tlist and HAVING qual to find all the aggregates and verify - * all are MIN/MAX aggregates. Stop as soon as we find one that isn't. + * all are MIN/MAX aggregates. Stop as soon as we find one that isn't. */ aggs_list = NIL; if (find_minmax_aggs_walker((Node *) tlist, &aggs_list)) @@ -146,7 +146,7 @@ preprocess_minmax_aggregates(PlannerInfo *root, List *tlist) * ordering operator. */ eqop = get_equality_op_for_ordering_op(mminfo->aggsortop, &reverse); - if (!OidIsValid(eqop)) /* shouldn't happen */ + if (!OidIsValid(eqop)) /* shouldn't happen */ elog(ERROR, "could not find equality operator for ordering operator %u", mminfo->aggsortop); @@ -154,7 +154,7 @@ preprocess_minmax_aggregates(PlannerInfo *root, List *tlist) * We can use either an ordering that gives NULLS FIRST or one that * gives NULLS LAST; furthermore there's unlikely to be much * performance difference between them, so it doesn't seem worth - * costing out both ways if we get a hit on the first one. NULLS + * costing out both ways if we get a hit on the first one. NULLS * FIRST is more likely to be available if the operator is a * reverse-sort operator, so try that first if reverse. */ @@ -169,8 +169,8 @@ preprocess_minmax_aggregates(PlannerInfo *root, List *tlist) /* * We're done until path generation is complete. Save info for later. - * (Setting root->minmax_aggs non-NIL signals we succeeded in making - * index access paths for all the aggregates.) + * (Setting root->minmax_aggs non-NIL signals we succeeded in making index + * access paths for all the aggregates.) */ root->minmax_aggs = aggs_list; } @@ -333,7 +333,7 @@ find_minmax_aggs_walker(Node *node, List **context) mminfo->aggfnoid = aggref->aggfnoid; mminfo->aggsortop = aggsortop; mminfo->target = curTarget->expr; - mminfo->subroot = NULL; /* don't compute path yet */ + mminfo->subroot = NULL; /* don't compute path yet */ mminfo->path = NULL; mminfo->pathcost = 0; mminfo->param = NULL; @@ -424,7 +424,7 @@ build_minmax_path(PlannerInfo *root, MinMaxAggInfo *mminfo, sortcl->eqop = eqop; sortcl->sortop = sortop; sortcl->nulls_first = nulls_first; - sortcl->hashable = false; /* no need to make this accurate */ + sortcl->hashable = false; /* no need to make this accurate */ parse->sortClause = list_make1(sortcl); /* set up expressions for LIMIT 1 */ @@ -450,8 +450,8 @@ build_minmax_path(PlannerInfo *root, MinMaxAggInfo *mminfo, subroot->query_pathkeys = subroot->sort_pathkeys; /* - * Generate the best paths for this query, telling query_planner that - * we have LIMIT 1. + * Generate the best paths for this query, telling query_planner that we + * have LIMIT 1. */ query_planner(subroot, parse->targetList, 1.0, 1.0, &cheapest_path, &sorted_path, &dNumGroups); @@ -527,11 +527,11 @@ make_agg_subplan(PlannerInfo *root, MinMaxAggInfo *mminfo) exprCollation((Node *) mminfo->target)); /* - * Make sure the initplan gets into the outer PlannerInfo, along with - * any other initplans generated by the sub-planning run. We had to - * include the outer PlannerInfo's pre-existing initplans into the - * inner one's init_plans list earlier, so make sure we don't put back - * any duplicate entries. + * Make sure the initplan gets into the outer PlannerInfo, along with any + * other initplans generated by the sub-planning run. We had to include + * the outer PlannerInfo's pre-existing initplans into the inner one's + * init_plans list earlier, so make sure we don't put back any duplicate + * entries. */ root->init_plans = list_concat_unique_ptr(root->init_plans, subroot->init_plans); diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c index 3dc23662e71..ff39d5754dc 100644 --- a/src/backend/optimizer/plan/planmain.c +++ b/src/backend/optimizer/plan/planmain.c @@ -179,12 +179,12 @@ query_planner(PlannerInfo *root, List *tlist, /* * Examine the targetlist and join tree, adding entries to baserel * targetlists for all referenced Vars, and generating PlaceHolderInfo - * entries for all referenced PlaceHolderVars. Restrict and join clauses - * are added to appropriate lists belonging to the mentioned relations. - * We also build EquivalenceClasses for provably equivalent expressions. - * The SpecialJoinInfo list is also built to hold information about join - * order restrictions. Finally, we form a target joinlist for - * make_one_rel() to work from. + * entries for all referenced PlaceHolderVars. Restrict and join clauses + * are added to appropriate lists belonging to the mentioned relations. We + * also build EquivalenceClasses for provably equivalent expressions. The + * SpecialJoinInfo list is also built to hold information about join order + * restrictions. Finally, we form a target joinlist for make_one_rel() to + * work from. */ build_base_rel_tlists(root, tlist); @@ -216,7 +216,7 @@ query_planner(PlannerInfo *root, List *tlist, /* * Examine any "placeholder" expressions generated during subquery pullup. * Make sure that the Vars they need are marked as needed at the relevant - * join level. This must be done before join removal because it might + * join level. This must be done before join removal because it might * cause Vars or placeholders to be needed above a join when they weren't * so marked before. */ diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index 56d25abc6d7..58a5bf8eceb 100644 --- a/src/backend/optimizer/plan/planner.c +++ b/src/backend/optimizer/plan/planner.c @@ -345,16 +345,16 @@ subquery_planner(PlannerGlobal *glob, Query *parse, inline_set_returning_functions(root); /* - * Check to see if any subqueries in the jointree can be merged into - * this query. + * Check to see if any subqueries in the jointree can be merged into this + * query. */ parse->jointree = (FromExpr *) pull_up_subqueries(root, (Node *) parse->jointree, NULL, NULL); /* - * If this is a simple UNION ALL query, flatten it into an appendrel. - * We do this now because it requires applying pull_up_subqueries to the - * leaf queries of the UNION ALL, which weren't touched above because they + * If this is a simple UNION ALL query, flatten it into an appendrel. We + * do this now because it requires applying pull_up_subqueries to the leaf + * queries of the UNION ALL, which weren't touched above because they * weren't referenced by the jointree (they will be after we do this). */ if (parse->setOperations) @@ -575,7 +575,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse, plan = (Plan *) make_modifytable(parse->commandType, parse->canSetTag, - list_make1_int(parse->resultRelation), + list_make1_int(parse->resultRelation), list_make1(plan), returningLists, rowMarks, @@ -3116,9 +3116,9 @@ plan_cluster_use_sort(Oid tableOid, Oid indexOid) /* * Determine eval cost of the index expressions, if any. We need to - * charge twice that amount for each tuple comparison that happens - * during the sort, since tuplesort.c will have to re-evaluate the - * index expressions each time. (XXX that's pretty inefficient...) + * charge twice that amount for each tuple comparison that happens during + * the sort, since tuplesort.c will have to re-evaluate the index + * expressions each time. (XXX that's pretty inefficient...) */ cost_qual_eval(&indexExprCost, indexInfo->indexprs, root); comparisonCost = 2.0 * (indexExprCost.startup + indexExprCost.per_tuple); diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c index bd678ac7ede..a40f116bf9a 100644 --- a/src/backend/optimizer/prep/prepjointree.c +++ b/src/backend/optimizer/prep/prepjointree.c @@ -1429,7 +1429,7 @@ pullup_replace_vars_callback(Var *var, * * If a query's setOperations tree consists entirely of simple UNION ALL * operations, flatten it into an append relation, which we can process more - * intelligently than the general setops case. Otherwise, do nothing. + * intelligently than the general setops case. Otherwise, do nothing. * * In most cases, this can succeed only for a top-level query, because for a * subquery in FROM, the parent query's invocation of pull_up_subqueries would @@ -1478,10 +1478,10 @@ flatten_simple_union_all(PlannerInfo *root) /* * Make a copy of the leftmost RTE and add it to the rtable. This copy - * will represent the leftmost leaf query in its capacity as a member - * of the appendrel. The original will represent the appendrel as a - * whole. (We must do things this way because the upper query's Vars - * have to be seen as referring to the whole appendrel.) + * will represent the leftmost leaf query in its capacity as a member of + * the appendrel. The original will represent the appendrel as a whole. + * (We must do things this way because the upper query's Vars have to be + * seen as referring to the whole appendrel.) */ childRTE = copyObject(leftmostRTE); parse->rtable = lappend(parse->rtable, childRTE); @@ -1503,8 +1503,8 @@ flatten_simple_union_all(PlannerInfo *root) parse->jointree->fromlist = list_make1(rtr); /* - * Now pretend the query has no setops. We must do this before trying - * to do subquery pullup, because of Assert in pull_up_simple_subquery. + * Now pretend the query has no setops. We must do this before trying to + * do subquery pullup, because of Assert in pull_up_simple_subquery. */ parse->setOperations = NULL; @@ -1842,9 +1842,9 @@ reduce_outer_joins_pass2(Node *jtnode, * never both, to the children of an outer join. * * Note that a SEMI join works like an inner join here: it's okay - * to pass down both local and upper constraints. (There can't - * be any upper constraints affecting its inner side, but it's - * not worth having a separate code path to avoid passing them.) + * to pass down both local and upper constraints. (There can't be + * any upper constraints affecting its inner side, but it's not + * worth having a separate code path to avoid passing them.) * * At a FULL join we just punt and pass nothing down --- is it * possible to be smarter? @@ -1882,7 +1882,7 @@ reduce_outer_joins_pass2(Node *jtnode, pass_nonnullable_vars = local_nonnullable_vars; pass_forced_null_vars = local_forced_null_vars; } - else if (jointype != JOIN_FULL) /* ie, LEFT or ANTI */ + else if (jointype != JOIN_FULL) /* ie, LEFT or ANTI */ { /* can't pass local constraints to non-nullable side */ pass_nonnullable_rels = nonnullable_rels; diff --git a/src/backend/optimizer/prep/prepqual.c b/src/backend/optimizer/prep/prepqual.c index 10e00d90dda..f6f00c4ee91 100644 --- a/src/backend/optimizer/prep/prepqual.c +++ b/src/backend/optimizer/prep/prepqual.c @@ -54,12 +54,12 @@ static Expr *process_duplicate_ors(List *orlist); * Although this can be invoked on its own, it's mainly intended as a helper * for eval_const_expressions(), and that context drives several design * decisions. In particular, if the input is already AND/OR flat, we must - * preserve that property. We also don't bother to recurse in situations + * preserve that property. We also don't bother to recurse in situations * where we can assume that lower-level executions of eval_const_expressions * would already have simplified sub-clauses of the input. * * The difference between this and a simple make_notclause() is that this - * tries to get rid of the NOT node by logical simplification. It's clearly + * tries to get rid of the NOT node by logical simplification. It's clearly * always a win if the NOT node can be eliminated altogether. However, our * use of DeMorgan's laws could result in having more NOT nodes rather than * fewer. We do that unconditionally anyway, because in WHERE clauses it's @@ -141,21 +141,21 @@ negate_clause(Node *node) switch (expr->boolop) { - /*-------------------- - * Apply DeMorgan's Laws: - * (NOT (AND A B)) => (OR (NOT A) (NOT B)) - * (NOT (OR A B)) => (AND (NOT A) (NOT B)) - * i.e., swap AND for OR and negate each subclause. - * - * If the input is already AND/OR flat and has no NOT - * directly above AND or OR, this transformation preserves - * those properties. For example, if no direct child of - * the given AND clause is an AND or a NOT-above-OR, then - * the recursive calls of negate_clause() can't return any - * OR clauses. So we needn't call pull_ors() before - * building a new OR clause. Similarly for the OR case. - *-------------------- - */ + /*-------------------- + * Apply DeMorgan's Laws: + * (NOT (AND A B)) => (OR (NOT A) (NOT B)) + * (NOT (OR A B)) => (AND (NOT A) (NOT B)) + * i.e., swap AND for OR and negate each subclause. + * + * If the input is already AND/OR flat and has no NOT + * directly above AND or OR, this transformation preserves + * those properties. For example, if no direct child of + * the given AND clause is an AND or a NOT-above-OR, then + * the recursive calls of negate_clause() can't return any + * OR clauses. So we needn't call pull_ors() before + * building a new OR clause. Similarly for the OR case. + *-------------------- + */ case AND_EXPR: { List *nargs = NIL; @@ -183,6 +183,7 @@ negate_clause(Node *node) } break; case NOT_EXPR: + /* * NOT underneath NOT: they cancel. We assume the * input is already simplified, so no need to recurse. @@ -218,8 +219,8 @@ negate_clause(Node *node) break; case T_BooleanTest: { - BooleanTest *expr = (BooleanTest *) node; - BooleanTest *newexpr = makeNode(BooleanTest); + BooleanTest *expr = (BooleanTest *) node; + BooleanTest *newexpr = makeNode(BooleanTest); newexpr->arg = expr->arg; switch (expr->booltesttype) diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c index 4ba8921528f..c97150c6f74 100644 --- a/src/backend/optimizer/prep/preptlist.c +++ b/src/backend/optimizer/prep/preptlist.c @@ -4,7 +4,7 @@ * Routines to preprocess the parse tree target list * * For INSERT and UPDATE queries, the targetlist must contain an entry for - * each attribute of the target relation in the correct order. For all query + * each attribute of the target relation in the correct order. For all query * types, we may need to add junk tlist entries for Vars used in the RETURNING * list and row ID information needed for EvalPlanQual checking. * @@ -80,7 +80,7 @@ preprocess_targetlist(PlannerInfo *root, List *tlist) /* * Add necessary junk columns for rowmarked rels. These values are needed * for locking of rels selected FOR UPDATE/SHARE, and to do EvalPlanQual - * rechecking. See comments for PlanRowMark in plannodes.h. + * rechecking. See comments for PlanRowMark in plannodes.h. */ foreach(lc, root->rowMarks) { diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c index e15a8620426..0ed9535d94d 100644 --- a/src/backend/optimizer/prep/prepunion.c +++ b/src/backend/optimizer/prep/prepunion.c @@ -938,7 +938,7 @@ generate_setop_tlist(List *colTypes, int flag, * The Vars are always generated with varno 0. */ static List * -generate_append_tlist(List *colTypes, List*colCollations, bool flag, +generate_append_tlist(List *colTypes, List *colCollations, bool flag, List *input_plans, List *refnames_tlist) { diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c index b1069259f9b..b3c2aec97b0 100644 --- a/src/backend/optimizer/util/clauses.c +++ b/src/backend/optimizer/util/clauses.c @@ -2042,7 +2042,7 @@ rowtype_field_matches(Oid rowtypeid, int fieldnum, * * Whenever a function is eliminated from the expression by means of * constant-expression evaluation or inlining, we add the function to - * root->glob->invalItems. This ensures the plan is known to depend on + * root->glob->invalItems. This ensures the plan is known to depend on * such functions, even though they aren't referenced anymore. * * We assume that the tree has already been type-checked and contains @@ -2437,8 +2437,8 @@ eval_const_expressions_mutator(Node *node, context); /* - * Use negate_clause() to see if we can simplify away - * the NOT. + * Use negate_clause() to see if we can simplify away the + * NOT. */ return negate_clause(arg); } @@ -2548,9 +2548,9 @@ eval_const_expressions_mutator(Node *node, makeConst(OIDOID, -1, InvalidOid, sizeof(Oid), ObjectIdGetDatum(intypioparam), false, true), - makeConst(INT4OID, -1, InvalidOid, sizeof(int32), - Int32GetDatum(-1), - false, true)); + makeConst(INT4OID, -1, InvalidOid, sizeof(int32), + Int32GetDatum(-1), + false, true)); simple = simplify_function(infunc, expr->resulttype, -1, @@ -2618,9 +2618,9 @@ eval_const_expressions_mutator(Node *node, /* * If we can simplify the input to a constant, then we don't need the * CollateExpr node at all: just change the constcollid field of the - * Const node. Otherwise, replace the CollateExpr with a RelabelType. - * (We do that so as to improve uniformity of expression representation - * and thus simplify comparison of expressions.) + * Const node. Otherwise, replace the CollateExpr with a RelabelType. + * (We do that so as to improve uniformity of expression + * representation and thus simplify comparison of expressions.) */ CollateExpr *collate = (CollateExpr *) node; Node *arg; @@ -2675,7 +2675,7 @@ eval_const_expressions_mutator(Node *node, * placeholder nodes, so that we have the opportunity to reduce * constant test conditions. For example this allows * CASE 0 WHEN 0 THEN 1 ELSE 1/0 END - * to reduce to 1 rather than drawing a divide-by-0 error. Note + * to reduce to 1 rather than drawing a divide-by-0 error. Note * that when the test expression is constant, we don't have to * include it in the resulting CASE; for example * CASE 0 WHEN x THEN y ELSE z END @@ -2855,9 +2855,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)) { @@ -3353,12 +3353,12 @@ simplify_boolean_equality(Oid opno, List *args) if (DatumGetBool(((Const *) leftop)->constvalue)) return rightop; /* true = foo */ else - return negate_clause(rightop); /* false = foo */ + return negate_clause(rightop); /* false = foo */ } else { if (DatumGetBool(((Const *) leftop)->constvalue)) - return negate_clause(rightop); /* true <> foo */ + return negate_clause(rightop); /* true <> foo */ else return rightop; /* false <> foo */ } @@ -3902,7 +3902,7 @@ inline_function(Oid funcid, Oid result_type, Oid result_collid, fexpr->funcresulttype = result_type; fexpr->funcretset = false; fexpr->funcformat = COERCE_DONTCARE; /* doesn't matter */ - fexpr->funccollid = result_collid; /* doesn't matter */ + fexpr->funccollid = result_collid; /* doesn't matter */ fexpr->inputcollid = input_collid; fexpr->args = args; fexpr->location = -1; @@ -4060,18 +4060,18 @@ inline_function(Oid funcid, Oid result_type, Oid result_collid, MemoryContextDelete(mycxt); /* - * If the result is of a collatable type, force the result to expose - * the correct collation. In most cases this does not matter, but - * it's possible that the function result is used directly as a sort key - * or in other places where we expect exprCollation() to tell the truth. + * If the result is of a collatable type, force the result to expose the + * correct collation. In most cases this does not matter, but it's + * possible that the function result is used directly as a sort key or in + * other places where we expect exprCollation() to tell the truth. */ if (OidIsValid(result_collid)) { - Oid exprcoll = exprCollation(newexpr); + Oid exprcoll = exprCollation(newexpr); if (OidIsValid(exprcoll) && exprcoll != result_collid) { - CollateExpr *newnode = makeNode(CollateExpr); + CollateExpr *newnode = makeNode(CollateExpr); newnode->arg = (Expr *) newexpr; newnode->collOid = result_collid; @@ -4370,11 +4370,11 @@ inline_set_returning_function(PlannerInfo *root, RangeTblEntry *rte) oldcxt = MemoryContextSwitchTo(mycxt); /* - * When we call eval_const_expressions below, it might try to add items - * to root->glob->invalItems. Since it is running in the temp context, - * those items will be in that context, and will need to be copied out - * if we're successful. Temporarily reset the list so that we can keep - * those items separate from the pre-existing list contents. + * When we call eval_const_expressions below, it might try to add items to + * root->glob->invalItems. Since it is running in the temp context, those + * items will be in that context, and will need to be copied out if we're + * successful. Temporarily reset the list so that we can keep those items + * separate from the pre-existing list contents. */ saveInvalItems = root->glob->invalItems; root->glob->invalItems = NIL; @@ -4419,8 +4419,8 @@ inline_set_returning_function(PlannerInfo *root, RangeTblEntry *rte) goto fail; /* - * Set up to handle parameters while parsing the function body. We - * can use the FuncExpr just created as the input for + * Set up to handle parameters while parsing the function body. We can + * use the FuncExpr just created as the input for * prepare_sql_fn_parse_info. */ pinfo = prepare_sql_fn_parse_info(func_tuple, @@ -4438,7 +4438,7 @@ inline_set_returning_function(PlannerInfo *root, RangeTblEntry *rte) querytree_list = pg_analyze_and_rewrite_params(linitial(raw_parsetree_list), src, - (ParserSetupHook) sql_fn_parser_setup, + (ParserSetupHook) sql_fn_parser_setup, pinfo); if (list_length(querytree_list) != 1) goto fail; @@ -4513,8 +4513,8 @@ inline_set_returning_function(PlannerInfo *root, RangeTblEntry *rte) ReleaseSysCache(func_tuple); /* - * We don't have to fix collations here because the upper query is - * already parsed, ie, the collations in the RTE are what count. + * We don't have to fix collations here because the upper query is already + * parsed, ie, the collations in the RTE are what count. */ /* diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c index b60c88d9251..55218b58694 100644 --- a/src/backend/optimizer/util/pathnode.c +++ b/src/backend/optimizer/util/pathnode.c @@ -745,7 +745,7 @@ create_merge_append_path(PlannerInfo *root, else { /* We'll need to insert a Sort node, so include cost for that */ - Path sort_path; /* dummy for result of cost_sort */ + Path sort_path; /* dummy for result of cost_sort */ cost_sort(&sort_path, root, @@ -1432,11 +1432,11 @@ create_foreignscan_path(PlannerInfo *root, RelOptInfo *rel) ForeignPath *pathnode = makeNode(ForeignPath); RangeTblEntry *rte; FdwRoutine *fdwroutine; - FdwPlan *fdwplan; + FdwPlan *fdwplan; pathnode->path.pathtype = T_ForeignScan; pathnode->path.parent = rel; - pathnode->path.pathkeys = NIL; /* result is always unordered */ + pathnode->path.pathkeys = NIL; /* result is always unordered */ /* Get FDW's callback info */ rte = planner_rt_fetch(rel->relid, root); diff --git a/src/backend/optimizer/util/placeholder.c b/src/backend/optimizer/util/placeholder.c index 61edd4991c6..9796fbf9b60 100644 --- a/src/backend/optimizer/util/placeholder.c +++ b/src/backend/optimizer/util/placeholder.c @@ -25,7 +25,7 @@ /* Local functions */ static Relids find_placeholders_recurse(PlannerInfo *root, Node *jtnode); static void find_placeholders_in_qual(PlannerInfo *root, Node *qual, - Relids relids); + Relids relids); /* @@ -179,7 +179,7 @@ find_placeholders_recurse(PlannerInfo *root, Node *jtnode) { elog(ERROR, "unrecognized node type: %d", (int) nodeTag(jtnode)); - jtrelids = NULL; /* keep compiler quiet */ + jtrelids = NULL; /* keep compiler quiet */ } return jtrelids; } diff --git a/src/backend/optimizer/util/predtest.c b/src/backend/optimizer/util/predtest.c index 72fd3e4ca71..a7e83729b1b 100644 --- a/src/backend/optimizer/util/predtest.c +++ b/src/backend/optimizer/util/predtest.c @@ -1696,7 +1696,7 @@ get_btree_test_op(Oid pred_op, Oid clause_op, bool refute_it) else if (OidIsValid(clause_op_negator)) { clause_tuple = SearchSysCache3(AMOPOPID, - ObjectIdGetDatum(clause_op_negator), + ObjectIdGetDatum(clause_op_negator), CharGetDatum(AMOP_SEARCH), ObjectIdGetDatum(opfamily_id)); if (HeapTupleIsValid(clause_tuple)) diff --git a/src/backend/optimizer/util/var.c b/src/backend/optimizer/util/var.c index 944db238003..edf507c4056 100644 --- a/src/backend/optimizer/util/var.c +++ b/src/backend/optimizer/util/var.c @@ -694,7 +694,7 @@ pull_var_clause_walker(Node *node, pull_var_clause_context *context) * entries might now be arbitrary expressions, not just Vars. This affects * this function in one important way: we might find ourselves inserting * SubLink expressions into subqueries, and we must make sure that their - * Query.hasSubLinks fields get set to TRUE if so. If there are any + * Query.hasSubLinks fields get set to TRUE if so. If there are any * SubLinks in the join alias lists, the outer Query should already have * hasSubLinks = TRUE, so this is only relevant to un-flattened subqueries. * diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c index 315f067b17a..e4e83a67165 100644 --- a/src/backend/parser/analyze.c +++ b/src/backend/parser/analyze.c @@ -759,8 +759,8 @@ transformInsertRow(ParseState *pstate, List *exprlist, * columns. Add a suitable hint if that seems to be the problem, * because the main error message is quite misleading for this case. * (If there's no stmtcols, you'll get something about data type - * mismatch, which is less misleading so we don't worry about giving - * a hint in that case.) + * mismatch, which is less misleading so we don't worry about giving a + * hint in that case.) */ ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), @@ -809,7 +809,7 @@ transformInsertRow(ParseState *pstate, List *exprlist, * return -1 if expression isn't a RowExpr or a Var referencing one. * * This is currently used only for hint purposes, so we aren't terribly - * tense about recognizing all possible cases. The Var case is interesting + * tense about recognizing all possible cases. The Var case is interesting * because that's what we'll get in the INSERT ... SELECT (...) case. */ static int @@ -1100,8 +1100,8 @@ transformValuesClause(ParseState *pstate, SelectStmt *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 either. + * collations independently in each row, and don't worry about whether + * they are consistent vertically either. */ assign_list_collations(pstate, newsublist); @@ -1452,7 +1452,7 @@ transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt) * Recursively transform leaves and internal nodes of a set-op tree * * In addition to returning the transformed node, if targetlist isn't NULL - * then we return a list of its non-resjunk TargetEntry nodes. For a leaf + * then we return a list of its non-resjunk TargetEntry nodes. For a leaf * set-op node these are the actual targetlist entries; otherwise they are * dummy entries created to carry the type, typmod, collation, and location * (for error messages) of each output column of the set-op node. This info @@ -1672,7 +1672,7 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt, * child query's semantics. * * If a child expression is an UNKNOWN-type Const or Param, we - * want to replace it with the coerced expression. This can only + * want to replace it with the coerced expression. This can only * happen when the child is a leaf set-op node. It's safe to * replace the expression because if the child query's semantics * depended on the type of this output column, it'd have already @@ -1721,8 +1721,8 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt, * collation.) */ rescolcoll = select_common_collation(pstate, - list_make2(lcolnode, rcolnode), - (op->op == SETOP_UNION && op->all)); + list_make2(lcolnode, rcolnode), + (op->op == SETOP_UNION && op->all)); /* emit results */ op->colTypes = lappend_oid(op->colTypes, rescoltype); @@ -1778,7 +1778,7 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt, rescolnode->collation = rescolcoll; rescolnode->location = bestlocation; restle = makeTargetEntry((Expr *) rescolnode, - 0, /* no need to set resno */ + 0, /* no need to set resno */ NULL, false); *targetlist = lappend(*targetlist, restle); @@ -2331,10 +2331,10 @@ transformLockingClause(ParseState *pstate, Query *qry, LockingClause *lc, case RTE_RELATION: if (rte->relkind == RELKIND_FOREIGN_TABLE) ereport(ERROR, - (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("SELECT FOR UPDATE/SHARE cannot be used with foreign table \"%s\"", - rte->eref->aliasname), - parser_errposition(pstate, thisrel->location))); + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("SELECT FOR UPDATE/SHARE cannot be used with foreign table \"%s\"", + rte->eref->aliasname), + parser_errposition(pstate, thisrel->location))); applyLockingClause(qry, i, lc->forUpdate, lc->noWait, pushedDown); diff --git a/src/backend/parser/parse_agg.c b/src/backend/parser/parse_agg.c index 523d6e6989a..83561337966 100644 --- a/src/backend/parser/parse_agg.c +++ b/src/backend/parser/parse_agg.c @@ -631,7 +631,7 @@ check_ungrouped_columns_walker(Node *node, /* * Check whether the Var is known functionally dependent on the GROUP - * BY columns. If so, we can allow the Var to be used, because the + * BY columns. If so, we can allow the Var to be used, because the * grouping is really a no-op for this table. However, this deduction * depends on one or more constraints of the table, so we have to add * those constraints to the query's constraintDeps list, because it's @@ -642,11 +642,11 @@ check_ungrouped_columns_walker(Node *node, * Because this is a pretty expensive check, and will have the same * outcome for all columns of a table, we remember which RTEs we've * already proven functional dependency for in the func_grouped_rels - * list. This test also prevents us from adding duplicate entries - * to the constraintDeps list. + * list. This test also prevents us from adding duplicate entries to + * the constraintDeps list. */ if (list_member_int(*context->func_grouped_rels, var->varno)) - return false; /* previously proven acceptable */ + return false; /* previously proven acceptable */ Assert(var->varno > 0 && (int) var->varno <= list_length(context->pstate->p_rtable)); @@ -661,7 +661,7 @@ check_ungrouped_columns_walker(Node *node, { *context->func_grouped_rels = lappend_int(*context->func_grouped_rels, var->varno); - return false; /* acceptable */ + return false; /* acceptable */ } } diff --git a/src/backend/parser/parse_clause.c b/src/backend/parser/parse_clause.c index 6c0a78474cd..c5fe6b6a3fd 100644 --- a/src/backend/parser/parse_clause.c +++ b/src/backend/parser/parse_clause.c @@ -1078,7 +1078,7 @@ buildMergedJoinVar(ParseState *pstate, JoinType jointype, else if (l_colvar->vartypmod != outcoltypmod) l_node = (Node *) makeRelabelType((Expr *) l_colvar, outcoltype, outcoltypmod, - InvalidOid, /* fixed below */ + InvalidOid, /* fixed below */ COERCE_IMPLICIT_CAST); else l_node = (Node *) l_colvar; @@ -1090,7 +1090,7 @@ buildMergedJoinVar(ParseState *pstate, JoinType jointype, else if (r_colvar->vartypmod != outcoltypmod) r_node = (Node *) makeRelabelType((Expr *) r_colvar, outcoltype, outcoltypmod, - InvalidOid, /* fixed below */ + InvalidOid, /* fixed below */ COERCE_IMPLICIT_CAST); else r_node = (Node *) r_colvar; @@ -1143,8 +1143,8 @@ buildMergedJoinVar(ParseState *pstate, JoinType jointype, /* * Apply assign_expr_collations to fix up the collation info in the - * coercion and CoalesceExpr nodes, if we made any. This must be done - * now so that the join node's alias vars show correct collation info. + * coercion and CoalesceExpr nodes, if we made any. This must be done now + * so that the join node's alias vars show correct collation info. */ assign_expr_collations(pstate, res_node); diff --git a/src/backend/parser/parse_coerce.c b/src/backend/parser/parse_coerce.c index 895c3ad9856..0418972517e 100644 --- a/src/backend/parser/parse_coerce.c +++ b/src/backend/parser/parse_coerce.c @@ -285,7 +285,7 @@ coerce_type(ParseState *pstate, Node *node, { /* * If we have a COLLATE clause, we have to push the coercion - * underneath the COLLATE. This is really ugly, but there is little + * underneath the COLLATE. This is really ugly, but there is little * choice because the above hacks on Consts and Params wouldn't happen * otherwise. */ @@ -1959,7 +1959,7 @@ find_coercion_pathway(Oid targetTypeId, Oid sourceTypeId, Oid sourceElem; if ((targetElem = get_element_type(targetTypeId)) != InvalidOid && - (sourceElem = get_base_element_type(sourceTypeId)) != InvalidOid) + (sourceElem = get_base_element_type(sourceTypeId)) != InvalidOid) { CoercionPathType elempathtype; Oid elemfuncid; @@ -2091,8 +2091,8 @@ is_complex_array(Oid typid) static bool typeIsOfTypedTable(Oid reltypeId, Oid reloftypeId) { - Oid relid = typeidTypeRelid(reltypeId); - bool result = false; + Oid relid = typeidTypeRelid(reltypeId); + bool result = false; if (relid) { diff --git a/src/backend/parser/parse_collate.c b/src/backend/parser/parse_collate.c index 3e557db2668..f0cd3f88d23 100644 --- a/src/backend/parser/parse_collate.c +++ b/src/backend/parser/parse_collate.c @@ -14,19 +14,19 @@ * 1. The output collation of each expression node, or InvalidOid if it * returns a noncollatable data type. This can also be InvalidOid if the * result type is collatable but the collation is indeterminate. - * 2. The collation to be used in executing each function. InvalidOid means + * 2. The collation to be used in executing each function. InvalidOid means * that there are no collatable inputs or their collation is indeterminate. * This value is only stored in node types that might call collation-using * functions. * * You might think we could get away with storing only one collation per - * node, but the two concepts really need to be kept distinct. Otherwise + * node, but the two concepts really need to be kept distinct. Otherwise * it's too confusing when a function produces a collatable output type but * has no collatable inputs or produces noncollatable output from collatable * inputs. * * Cases with indeterminate collation might result in an error being thrown - * at runtime. If we knew exactly which functions require collation + * at runtime. If we knew exactly which functions require collation * information, we could throw those errors at parse time instead. * * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group @@ -72,7 +72,7 @@ typedef struct static bool assign_query_collations_walker(Node *node, ParseState *pstate); static bool assign_collations_walker(Node *node, - assign_collations_context *context); + assign_collations_context *context); /* @@ -116,8 +116,8 @@ assign_query_collations_walker(Node *node, ParseState *pstate) return false; /* - * We don't want to recurse into a set-operations tree; it's already - * been fully processed in transformSetOperationStmt. + * We don't want to recurse into a set-operations tree; it's already been + * fully processed in transformSetOperationStmt. */ if (IsA(node, SetOperationStmt)) return false; @@ -144,7 +144,7 @@ assign_list_collations(ParseState *pstate, List *exprs) foreach(lc, exprs) { - Node *node = (Node *) lfirst(lc); + Node *node = (Node *) lfirst(lc); assign_expr_collations(pstate, node); } @@ -231,7 +231,7 @@ select_common_collation(ParseState *pstate, List *exprs, bool none_ok) * Recursive guts of collation processing. * * Nodes with no children (eg, Vars, Consts, Params) must have been marked - * when built. All upper-level nodes are marked here. + * when built. All upper-level nodes are marked here. * * Note: if this is invoked directly on a List, it will attempt to infer a * common collation for all the list members. In particular, it will throw @@ -250,9 +250,9 @@ assign_collations_walker(Node *node, assign_collations_context *context) return false; /* - * Prepare for recursion. For most node types, though not all, the - * first thing we do is recurse to process all nodes below this one. - * Each level of the tree has its own local context. + * Prepare for recursion. For most node types, though not all, the first + * thing we do is recurse to process all nodes below this one. Each level + * of the tree has its own local context. */ loccontext.pstate = context->pstate; loccontext.collation = InvalidOid; @@ -323,11 +323,11 @@ assign_collations_walker(Node *node, assign_collations_context *context) { /* * CaseExpr is a special case because we do not want to - * recurse into the test expression (if any). It was - * already marked with collations during transformCaseExpr, - * and furthermore its collation is not relevant to the - * result of the CASE --- only the output expressions are. - * So we can't use expression_tree_walker here. + * recurse into the test expression (if any). It was already + * marked with collations during transformCaseExpr, and + * furthermore its collation is not relevant to the result of + * the CASE --- only the output expressions are. So we can't + * use expression_tree_walker here. */ CaseExpr *expr = (CaseExpr *) node; Oid typcollation; @@ -338,6 +338,7 @@ assign_collations_walker(Node *node, assign_collations_context *context) CaseWhen *when = (CaseWhen *) lfirst(lc); Assert(IsA(when, CaseWhen)); + /* * The condition expressions mustn't affect the CASE's * result collation either; but since they are known to @@ -401,11 +402,11 @@ assign_collations_walker(Node *node, assign_collations_context *context) case T_RowExpr: { /* - * RowExpr is a special case because the subexpressions - * are independent: we don't want to complain if some of - * them have incompatible explicit collations. + * RowExpr is a special case because the subexpressions are + * independent: we don't want to complain if some of them have + * incompatible explicit collations. */ - RowExpr *expr = (RowExpr *) node; + RowExpr *expr = (RowExpr *) node; assign_list_collations(context->pstate, expr->args); @@ -414,7 +415,7 @@ assign_collations_walker(Node *node, assign_collations_context *context) * has a collation, we can just stop here: this node has no * impact on the collation of its parent. */ - return false; /* done */ + return false; /* done */ } case T_RowCompareExpr: { @@ -431,9 +432,9 @@ assign_collations_walker(Node *node, assign_collations_context *context) forboth(l, expr->largs, r, expr->rargs) { - Node *le = (Node *) lfirst(l); - Node *re = (Node *) lfirst(r); - Oid coll; + Node *le = (Node *) lfirst(l); + Node *re = (Node *) lfirst(r); + Oid coll; coll = select_common_collation(context->pstate, list_make2(le, re), @@ -443,11 +444,11 @@ assign_collations_walker(Node *node, assign_collations_context *context) expr->inputcollids = colls; /* - * Since the result is always boolean and therefore never - * has a collation, we can just stop here: this node has no - * impact on the collation of its parent. + * Since the result is always boolean and therefore never has + * a collation, we can just stop here: this node has no impact + * on the collation of its parent. */ - return false; /* done */ + return false; /* done */ } case T_CoerceToDomain: { @@ -455,12 +456,12 @@ assign_collations_walker(Node *node, assign_collations_context *context) * If the domain declaration included a non-default COLLATE * spec, then use that collation as the output collation of * the coercion. Otherwise allow the input collation to - * bubble up. (The input should be of the domain's base - * type, therefore we don't need to worry about it not being + * bubble up. (The input should be of the domain's base type, + * therefore we don't need to worry about it not being * collatable when the domain is.) */ CoerceToDomain *expr = (CoerceToDomain *) node; - Oid typcollation = get_typcollation(expr->resulttype); + Oid typcollation = get_typcollation(expr->resulttype); /* ... but first, recurse */ (void) expression_tree_walker(node, @@ -510,7 +511,7 @@ assign_collations_walker(Node *node, assign_collations_context *context) /* * TargetEntry can have only one child, and should bubble that - * state up to its parent. We can't use the general-case code + * state up to its parent. We can't use the general-case code * below because exprType and friends don't work on TargetEntry. */ collation = loccontext.collation; @@ -525,9 +526,9 @@ assign_collations_walker(Node *node, assign_collations_context *context) * There are some cases where there might not be a failure, for * example if the planner chooses to use hash aggregation instead * of sorting for grouping; but it seems better to predictably - * throw an error. (Compare transformSetOperationTree, which will - * throw error for indeterminate collation of set-op columns, - * even though the planner might be able to implement the set-op + * throw an error. (Compare transformSetOperationTree, which will + * throw error for indeterminate collation of set-op columns, even + * though the planner might be able to implement the set-op * without sorting.) */ if (strength == COLLATE_CONFLICT && @@ -548,6 +549,7 @@ assign_collations_walker(Node *node, assign_collations_context *context) (void) expression_tree_walker(node, assign_collations_walker, (void *) &loccontext); + /* * When we're invoked on a query's jointree, we don't need to do * anything with join nodes except recurse through them to process @@ -599,6 +601,7 @@ assign_collations_walker(Node *node, assign_collations_context *context) case T_CaseTestExpr: case T_SetToDefault: case T_CurrentOfExpr: + /* * General case for childless expression nodes. These should * already have a collation assigned; it is not this function's @@ -610,10 +613,10 @@ assign_collations_walker(Node *node, assign_collations_context *context) /* * Note: in most cases, there will be an assigned collation * whenever type_is_collatable(exprType(node)); but an exception - * occurs for a Var referencing a subquery output column for - * which a unique collation was not determinable. That may lead - * to a runtime failure if a collation-sensitive function is - * applied to the Var. + * occurs for a Var referencing a subquery output column for which + * a unique collation was not determinable. That may lead to a + * runtime failure if a collation-sensitive function is applied to + * the Var. */ if (OidIsValid(collation)) @@ -626,10 +629,10 @@ assign_collations_walker(Node *node, assign_collations_context *context) default: { /* - * General case for most expression nodes with children. - * First recurse, then figure out what to assign here. + * General case for most expression nodes with children. First + * recurse, then figure out what to assign here. */ - Oid typcollation; + Oid typcollation; (void) expression_tree_walker(node, assign_collations_walker, @@ -668,9 +671,9 @@ assign_collations_walker(Node *node, assign_collations_context *context) } /* - * Save the result collation into the expression node. - * If the state is COLLATE_CONFLICT, we'll set the collation - * to InvalidOid, which might result in an error at runtime. + * Save the result collation into the expression node. If the + * state is COLLATE_CONFLICT, we'll set the collation to + * InvalidOid, which might result in an error at runtime. */ if (strength == COLLATE_CONFLICT) exprSetCollation(node, InvalidOid); diff --git a/src/backend/parser/parse_cte.c b/src/backend/parser/parse_cte.c index c527f7589e2..41097263b41 100644 --- a/src/backend/parser/parse_cte.c +++ b/src/backend/parser/parse_cte.c @@ -245,7 +245,7 @@ analyzeCTE(ParseState *pstate, CommonTableExpr *cte) cte->ctequery = (Node *) query; /* - * Check that we got something reasonable. These first two cases should + * Check that we got something reasonable. These first two cases should * be prevented by the grammar. */ if (!IsA(query, Query)) @@ -310,7 +310,7 @@ analyzeCTE(ParseState *pstate, CommonTableExpr *cte) continue; varattno++; Assert(varattno == te->resno); - if (lctyp == NULL || lctypmod == NULL || lccoll == NULL) /* shouldn't happen */ + if (lctyp == NULL || lctypmod == NULL || lccoll == NULL) /* shouldn't happen */ elog(ERROR, "wrong number of output columns in WITH"); texpr = (Node *) te->expr; if (exprType(texpr) != lfirst_oid(lctyp) || @@ -338,7 +338,7 @@ analyzeCTE(ParseState *pstate, CommonTableExpr *cte) lctypmod = lnext(lctypmod); lccoll = lnext(lccoll); } - if (lctyp != NULL || lctypmod != NULL || lccoll != NULL) /* shouldn't happen */ + if (lctyp != NULL || lctypmod != NULL || lccoll != NULL) /* shouldn't happen */ elog(ERROR, "wrong number of output columns in WITH"); } } @@ -645,7 +645,7 @@ checkWellFormedRecursion(CteState *cstate) CommonTableExpr *cte = cstate->items[i].cte; SelectStmt *stmt = (SelectStmt *) cte->ctequery; - Assert(!IsA(stmt, Query)); /* not analyzed yet */ + Assert(!IsA(stmt, Query)); /* not analyzed yet */ /* Ignore items that weren't found to be recursive */ if (!cte->cterecursive) diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c index 4986e0e5fab..08f0439e7ed 100644 --- a/src/backend/parser/parse_expr.c +++ b/src/backend/parser/parse_expr.c @@ -163,6 +163,7 @@ transformExpr(ParseState *pstate, Node *expr) typenameTypeIdAndMod(pstate, tc->typeName, &targetType, &targetTypmod); + /* * If target is a domain over array, work with the base * array type here. transformTypeCast below will cast the @@ -1283,9 +1284,9 @@ transformCaseExpr(ParseState *pstate, CaseExpr *c) /* * Run collation assignment on the test expression so that we know - * what collation to mark the placeholder with. In principle we - * could leave it to parse_collate.c to do that later, but propagating - * the result to the CaseTestExpr would be unnecessarily complicated. + * what collation to mark the placeholder with. In principle we could + * leave it to parse_collate.c to do that later, but propagating the + * result to the CaseTestExpr would be unnecessarily complicated. */ assign_expr_collations(pstate, arg); @@ -2122,15 +2123,16 @@ static Node * transformCollateClause(ParseState *pstate, CollateClause *c) { CollateExpr *newc; - Oid argtype; + Oid argtype; newc = makeNode(CollateExpr); newc->arg = (Expr *) transformExpr(pstate, c->arg); argtype = exprType((Node *) newc->arg); + /* - * The unknown type is not collatable, but coerce_type() takes - * care of it separately, so we'll let it go here. + * The unknown type is not collatable, but coerce_type() takes care of it + * separately, so we'll let it go here. */ if (!type_is_collatable(argtype) && argtype != UNKNOWNOID) ereport(ERROR, @@ -2351,7 +2353,7 @@ make_row_comparison_op(ParseState *pstate, List *opname, rcexpr->rctype = rctype; rcexpr->opnos = opnos; rcexpr->opfamilies = opfamilies; - rcexpr->inputcollids = NIL; /* assign_expr_collations will fix this */ + rcexpr->inputcollids = NIL; /* assign_expr_collations will fix this */ rcexpr->largs = largs; rcexpr->rargs = rargs; diff --git a/src/backend/parser/parse_func.c b/src/backend/parser/parse_func.c index ba699e9a1ed..75f1e20475d 100644 --- a/src/backend/parser/parse_func.c +++ b/src/backend/parser/parse_func.c @@ -288,9 +288,9 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs, errmsg("function %s does not exist", func_signature_string(funcname, nargs, argnames, actual_arg_types)), - errhint("No aggregate function matches the given name and argument types. " - "Perhaps you misplaced ORDER BY; ORDER BY must appear " - "after all regular arguments of the aggregate."), + errhint("No aggregate function matches the given name and argument types. " + "Perhaps you misplaced ORDER BY; ORDER BY must appear " + "after all regular arguments of the aggregate."), parser_errposition(pstate, location))); } else @@ -1034,7 +1034,7 @@ func_get_detail(List *funcname, case COERCION_PATH_COERCEVIAIO: if ((sourceType == RECORDOID || ISCOMPLEX(sourceType)) && - TypeCategory(targetType) == TYPCATEGORY_STRING) + TypeCategory(targetType) == TYPCATEGORY_STRING) iscoercion = false; else iscoercion = true; diff --git a/src/backend/parser/parse_node.c b/src/backend/parser/parse_node.c index 07257accc82..7b5c040cb40 100644 --- a/src/backend/parser/parse_node.c +++ b/src/backend/parser/parse_node.c @@ -220,7 +220,7 @@ transformArrayType(Oid *arrayType, int32 *arrayTypmod) * If the input is a domain, smash to base type, and extract the actual * typmod to be applied to the base type. Subscripting a domain is an * operation that necessarily works on the base array type, not the domain - * itself. (Note that we provide no method whereby the creator of a + * itself. (Note that we provide no method whereby the creator of a * domain over an array type could hide its ability to be subscripted.) */ *arrayType = getBaseTypeAndTypmod(*arrayType, arrayTypmod); @@ -290,8 +290,8 @@ transformArraySubscripts(ParseState *pstate, /* * Caller may or may not have bothered to determine elementType. Note - * that if the caller did do so, arrayType/arrayTypMod must be as - * modified by transformArrayType, ie, smash domain to base type. + * that if the caller did do so, arrayType/arrayTypMod must be as modified + * by transformArrayType, ie, smash domain to base type. */ if (!OidIsValid(elementType)) elementType = transformArrayType(&arrayType, &arrayTypMod); @@ -542,7 +542,7 @@ make_const(ParseState *pstate, Value *value, int location) con = makeConst(typeid, -1, /* typmod -1 is OK for all cases */ - InvalidOid, /* all cases are uncollatable types */ + InvalidOid, /* all cases are uncollatable types */ typelen, val, false, diff --git a/src/backend/parser/parse_oper.c b/src/backend/parser/parse_oper.c index 822e0a0a628..15a3bb3a013 100644 --- a/src/backend/parser/parse_oper.c +++ b/src/backend/parser/parse_oper.c @@ -214,9 +214,9 @@ get_sort_group_operators(Oid argtype, /* * If the datatype is an array, then we can use array_lt and friends ... * but only if there are suitable operators for the element type. - * Likewise, array types are only hashable if the element type is. - * Testing all three operator IDs here should be redundant, but let's do - * it anyway. + * Likewise, array types are only hashable if the element type is. Testing + * all three operator IDs here should be redundant, but let's do it + * anyway. */ if (lt_opr == ARRAY_LT_OP || eq_opr == ARRAY_EQ_OP || diff --git a/src/backend/parser/parse_param.c b/src/backend/parser/parse_param.c index 1895f92d7c4..3b8a67619e8 100644 --- a/src/backend/parser/parse_param.c +++ b/src/backend/parser/parse_param.c @@ -233,8 +233,8 @@ variable_coerce_param_hook(ParseState *pstate, Param *param, /* * This module always sets a Param's collation to be the default for - * its datatype. If that's not what you want, you should be using - * the more general parser substitution hooks. + * its datatype. If that's not what you want, you should be using the + * more general parser substitution hooks. */ param->paramcollid = get_typcollation(param->paramtype); diff --git a/src/backend/parser/parse_relation.c b/src/backend/parser/parse_relation.c index 1af3f2f3b53..d603ce2f423 100644 --- a/src/backend/parser/parse_relation.c +++ b/src/backend/parser/parse_relation.c @@ -1393,14 +1393,14 @@ addRangeTableEntryForCTE(ParseState *pstate, */ if (IsA(cte->ctequery, Query)) { - Query *ctequery = (Query *) cte->ctequery; + Query *ctequery = (Query *) cte->ctequery; if (ctequery->commandType != CMD_SELECT && ctequery->returningList == NIL) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("WITH query \"%s\" does not have a RETURNING clause", - cte->ctename), + errmsg("WITH query \"%s\" does not have a RETURNING clause", + cte->ctename), parser_errposition(pstate, rv->location))); } @@ -1871,7 +1871,7 @@ expandTupleDesc(TupleDesc tupdesc, Alias *eref, * what type the Const claims to be. */ *colvars = lappend(*colvars, - makeNullConst(INT4OID, -1, InvalidOid)); + makeNullConst(INT4OID, -1, InvalidOid)); } } continue; @@ -1893,7 +1893,7 @@ expandTupleDesc(TupleDesc tupdesc, Alias *eref, Var *varnode; varnode = makeVar(rtindex, attr->attnum, - attr->atttypid, attr->atttypmod, attr->attcollation, + attr->atttypid, attr->atttypmod, attr->attcollation, sublevels_up); varnode->location = location; diff --git a/src/backend/parser/parse_target.c b/src/backend/parser/parse_target.c index 52c6db2eb5c..3f630147b0f 100644 --- a/src/backend/parser/parse_target.c +++ b/src/backend/parser/parse_target.c @@ -671,7 +671,7 @@ transformAssignmentIndirection(ParseState *pstate, parser_errposition(pstate, location))); get_atttypetypmodcoll(typrelid, attnum, - &fieldTypeId, &fieldTypMod, &fieldCollation); + &fieldTypeId, &fieldTypMod, &fieldCollation); /* recurse to create appropriate RHS for field assign */ rhs = transformAssignmentIndirection(pstate, @@ -783,8 +783,8 @@ transformAssignmentSubscripts(ParseState *pstate, /* * Array normally has same collation as elements, but there's an - * exception: we might be subscripting a domain over an array type. - * In that case use collation of the base type. + * exception: we might be subscripting a domain over an array type. In + * that case use collation of the base type. */ if (arrayType == targetTypeId) collationNeeded = targetCollation; diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c index b65f5f991cb..22411f1608b 100644 --- a/src/backend/parser/parse_utilcmd.c +++ b/src/backend/parser/parse_utilcmd.c @@ -121,7 +121,7 @@ static void transformFKConstraints(CreateStmtContext *cxt, bool skipValidation, bool isAddConstraint); static void transformConstraintAttrs(CreateStmtContext *cxt, - List *constraintList); + List *constraintList); static void transformColumnType(CreateStmtContext *cxt, ColumnDef *column); static void setSchemaName(char *context_schema, char **stmt_schema_name); @@ -368,8 +368,8 @@ transformColumnDefinition(CreateStmtContext *cxt, ColumnDef *column) * If this is ALTER ADD COLUMN, make sure the sequence will be owned * by the table's owner. The current user might be someone else * (perhaps a superuser, or someone who's only a member of the owning - * role), but the SEQUENCE OWNED BY mechanisms will bleat unless - * table and sequence have exactly the same owning role. + * role), but the SEQUENCE OWNED BY mechanisms will bleat unless table + * and sequence have exactly the same owning role. */ if (cxt->rel) seqstmt->ownerId = cxt->rel->rd_rel->relowner; @@ -732,7 +732,7 @@ transformInhRelation(CreateStmtContext *cxt, InhRelation *inhRelation) /* Copy comment on constraint */ if ((inhRelation->options & CREATE_TABLE_LIKE_COMMENTS) && (comment = GetComment(get_constraint_oid(RelationGetRelid(relation), - n->conname, false), + n->conname, false), ConstraintRelationId, 0)) != NULL) { @@ -1390,8 +1390,8 @@ transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt) /* * If it's ALTER TABLE ADD CONSTRAINT USING INDEX, look up the index and * verify it's usable, then extract the implied column name list. (We - * will not actually need the column name list at runtime, but we need - * it now to check for duplicate column entries below.) + * will not actually need the column name list at runtime, but we need it + * now to check for duplicate column entries below.) */ if (constraint->indexname != NULL) { @@ -1436,8 +1436,8 @@ transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt) if (OidIsValid(get_index_constraint(index_oid))) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), - errmsg("index \"%s\" is already associated with a constraint", - index_name), + errmsg("index \"%s\" is already associated with a constraint", + index_name), parser_errposition(cxt->pstate, constraint->location))); /* Perform validity checks on the index */ @@ -1482,8 +1482,8 @@ transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt) parser_errposition(cxt->pstate, constraint->location))); /* - * It's probably unsafe to change a deferred index to non-deferred. - * (A non-constraint index couldn't be deferred anyway, so this case + * It's probably unsafe to change a deferred index to non-deferred. (A + * non-constraint index couldn't be deferred anyway, so this case * should never occur; no need to sweat, but let's check it.) */ if (!index_form->indimmediate && !constraint->deferrable) @@ -1494,7 +1494,7 @@ transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt) parser_errposition(cxt->pstate, constraint->location))); /* - * Insist on it being a btree. That's the only kind that supports + * Insist on it being a btree. That's the only kind that supports * uniqueness at the moment anyway; but we must have an index that * exactly matches what you'd get from plain ADD CONSTRAINT syntax, * else dump and reload will produce a different index (breaking @@ -1514,15 +1514,15 @@ transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt) for (i = 0; i < index_form->indnatts; i++) { - int2 attnum = index_form->indkey.values[i]; + int2 attnum = index_form->indkey.values[i]; Form_pg_attribute attform; - char *attname; - Oid defopclass; + char *attname; + Oid defopclass; /* * We shouldn't see attnum == 0 here, since we already rejected - * expression indexes. If we do, SystemAttributeDefinition - * will throw an error. + * expression indexes. If we do, SystemAttributeDefinition will + * throw an error. */ if (attnum > 0) { @@ -1531,11 +1531,11 @@ transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt) } else attform = SystemAttributeDefinition(attnum, - heap_rel->rd_rel->relhasoids); + heap_rel->rd_rel->relhasoids); attname = pstrdup(NameStr(attform->attname)); /* - * Insist on default opclass and sort options. While the index + * Insist on default opclass and sort options. While the index * would still work as a constraint with non-default settings, it * might not provide exactly the same uniqueness semantics as * you'd get from a normally-created constraint; and there's also @@ -1549,7 +1549,7 @@ transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt) (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("index \"%s\" does not have default sorting behavior", index_name), errdetail("Cannot create a PRIMARY KEY or UNIQUE constraint using such an index."), - parser_errposition(cxt->pstate, constraint->location))); + parser_errposition(cxt->pstate, constraint->location))); constraint->keys = lappend(constraint->keys, makeString(attname)); } @@ -1694,13 +1694,13 @@ transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt) (errcode(ERRCODE_DUPLICATE_COLUMN), errmsg("column \"%s\" appears twice in primary key constraint", key), - parser_errposition(cxt->pstate, constraint->location))); + parser_errposition(cxt->pstate, constraint->location))); else ereport(ERROR, (errcode(ERRCODE_DUPLICATE_COLUMN), errmsg("column \"%s\" appears twice in unique constraint", key), - parser_errposition(cxt->pstate, constraint->location))); + parser_errposition(cxt->pstate, constraint->location))); } } @@ -1743,7 +1743,7 @@ transformFKConstraints(CreateStmtContext *cxt, Constraint *constraint = (Constraint *) lfirst(fkclist); constraint->skip_validation = true; - constraint->initially_valid = true; + constraint->initially_valid = true; } } @@ -2120,18 +2120,18 @@ transformRuleStmt(RuleStmt *stmt, const char *queryString, * However, they were already in the outer rangetable when we * analyzed the query, so we have to check. * - * Note that in the INSERT...SELECT case, we need to examine - * the CTE lists of both top_subqry and sub_qry. + * Note that in the INSERT...SELECT case, we need to examine the + * CTE lists of both top_subqry and sub_qry. * - * Note that we aren't digging into the body of the query - * looking for WITHs in nested sub-SELECTs. A WITH down there - * can legitimately refer to OLD/NEW, because it'd be an + * Note that we aren't digging into the body of the query looking + * for WITHs in nested sub-SELECTs. A WITH down there can + * legitimately refer to OLD/NEW, because it'd be an * indirect-correlated outer reference. */ if (rangeTableEntry_used((Node *) top_subqry->cteList, PRS2_OLD_VARNO, 0) || rangeTableEntry_used((Node *) sub_qry->cteList, - PRS2_OLD_VARNO, 0)) + PRS2_OLD_VARNO, 0)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot refer to OLD within WITH query"))); @@ -2226,12 +2226,13 @@ transformAlterTableStmt(AlterTableStmt *stmt, const char *queryString) lockmode = AlterTableGetLockLevel(stmt->cmds); /* - * Acquire appropriate lock on the target relation, which will be held until - * end of transaction. This ensures any decisions we make here based on - * the state of the relation will still be good at execution. We must get - * lock now because execution will later require it; taking a lower grade lock - * now and trying to upgrade later risks deadlock. Any new commands we add - * after this must not upgrade the lock level requested here. + * Acquire appropriate lock on the target relation, which will be held + * until end of transaction. This ensures any decisions we make here + * based on the state of the relation will still be good at execution. We + * must get lock now because execution will later require it; taking a + * lower grade lock now and trying to upgrade later risks deadlock. Any + * new commands we add after this must not upgrade the lock level + * requested here. */ rel = relation_openrv(stmt->relation, lockmode); @@ -2522,7 +2523,7 @@ transformColumnType(CreateStmtContext *cxt, ColumnDef *column) if (column->collClause) { Form_pg_type typtup = (Form_pg_type) GETSTRUCT(ctype); - Oid collOid; + Oid collOid; collOid = LookupCollation(cxt->pstate, column->collClause->collname, diff --git a/src/backend/port/dynloader/freebsd.c b/src/backend/port/dynloader/freebsd.c index 373d6aaec84..bc400791788 100644 --- a/src/backend/port/dynloader/freebsd.c +++ b/src/backend/port/dynloader/freebsd.c @@ -89,7 +89,7 @@ BSD44_derived_dlsym(void *handle, const char *name) snprintf(buf, sizeof(buf), "_%s", name); name = buf; } -#endif /* !__ELF__ */ +#endif /* !__ELF__ */ if ((vp = dlsym(handle, (char *) name)) == NULL) snprintf(error_message, sizeof(error_message), "dlsym (%s) failed", name); diff --git a/src/backend/port/dynloader/netbsd.c b/src/backend/port/dynloader/netbsd.c index d1206561414..1bac83784af 100644 --- a/src/backend/port/dynloader/netbsd.c +++ b/src/backend/port/dynloader/netbsd.c @@ -89,7 +89,7 @@ BSD44_derived_dlsym(void *handle, const char *name) snprintf(buf, sizeof(buf), "_%s", name); name = buf; } -#endif /* !__ELF__ */ +#endif /* !__ELF__ */ if ((vp = dlsym(handle, (char *) name)) == NULL) snprintf(error_message, sizeof(error_message), "dlsym (%s) failed", name); diff --git a/src/backend/port/dynloader/openbsd.c b/src/backend/port/dynloader/openbsd.c index 2d061efb1e8..4556a2dfebb 100644 --- a/src/backend/port/dynloader/openbsd.c +++ b/src/backend/port/dynloader/openbsd.c @@ -89,7 +89,7 @@ BSD44_derived_dlsym(void *handle, const char *name) snprintf(buf, sizeof(buf), "_%s", name); name = buf; } -#endif /* !__ELF__ */ +#endif /* !__ELF__ */ if ((vp = dlsym(handle, (char *) name)) == NULL) snprintf(error_message, sizeof(error_message), "dlsym (%s) failed", name); diff --git a/src/backend/port/pipe.c b/src/backend/port/pipe.c index eeed3fc2e11..b86a53ad34a 100644 --- a/src/backend/port/pipe.c +++ b/src/backend/port/pipe.c @@ -37,7 +37,7 @@ pgpipe(int handles[2]) serv_addr.sin_family = AF_INET; serv_addr.sin_port = htons(0); serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); - if (bind(s, (SOCKADDR *) & serv_addr, len) == SOCKET_ERROR) + if (bind(s, (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR) { ereport(LOG, (errmsg_internal("pgpipe failed to bind: %ui", WSAGetLastError()))); closesocket(s); @@ -49,7 +49,7 @@ pgpipe(int handles[2]) closesocket(s); return -1; } - if (getsockname(s, (SOCKADDR *) & serv_addr, &len) == SOCKET_ERROR) + if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR) { ereport(LOG, (errmsg_internal("pgpipe failed to getsockname: %ui", WSAGetLastError()))); closesocket(s); @@ -62,13 +62,13 @@ pgpipe(int handles[2]) return -1; } - if (connect(handles[1], (SOCKADDR *) & serv_addr, len) == SOCKET_ERROR) + if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR) { ereport(LOG, (errmsg_internal("pgpipe failed to connect socket: %ui", WSAGetLastError()))); closesocket(s); return -1; } - if ((handles[0] = accept(s, (SOCKADDR *) & serv_addr, &len)) == INVALID_SOCKET) + if ((handles[0] = accept(s, (SOCKADDR *) &serv_addr, &len)) == INVALID_SOCKET) { ereport(LOG, (errmsg_internal("pgpipe failed to accept socket: %ui", WSAGetLastError()))); closesocket(handles[1]); diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c index 102a28ed04e..754d2ac7e04 100644 --- a/src/backend/port/sysv_shmem.c +++ b/src/backend/port/sysv_shmem.c @@ -153,7 +153,7 @@ InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size) "segment exceeded your kernel's SHMMAX parameter. You can either " "reduce the request size or reconfigure the kernel with larger SHMMAX. " "To reduce the request size (currently %lu bytes), reduce " - "PostgreSQL's shared memory usage, perhaps by reducing shared_buffers " + "PostgreSQL's shared memory usage, perhaps by reducing shared_buffers " "or max_connections.\n" "If the request size is already small, it's possible that it is less than " "your kernel's SHMMIN parameter, in which case raising the request size or " @@ -164,10 +164,10 @@ InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size) (errno == ENOMEM) ? errhint("This error usually means that PostgreSQL's request for a shared " "memory segment exceeded available memory or swap space, " - "or exceeded your kernel's SHMALL parameter. You can either " + "or exceeded your kernel's SHMALL parameter. You can either " "reduce the request size or reconfigure the kernel with larger SHMALL. " "To reduce the request size (currently %lu bytes), reduce " - "PostgreSQL's shared memory usage, perhaps by reducing shared_buffers " + "PostgreSQL's shared memory usage, perhaps by reducing shared_buffers " "or max_connections.\n" "The PostgreSQL documentation contains more information about shared " "memory configuration.", @@ -203,7 +203,7 @@ InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size) * hurt, but might confuse humans). */ { - char line[64]; + char line[64]; sprintf(line, "%9lu %9lu", (unsigned long) memKey, (unsigned long) shmid); diff --git a/src/backend/port/unix_latch.c b/src/backend/port/unix_latch.c index 32d0cb5e3f8..6dae7c94c03 100644 --- a/src/backend/port/unix_latch.c +++ b/src/backend/port/unix_latch.c @@ -37,11 +37,11 @@ * * for (;;) * { - * ResetLatch(); - * if (work to do) - * Do Stuff(); + * ResetLatch(); + * if (work to do) + * Do Stuff(); * - * WaitLatch(); + * WaitLatch(); * } * * It's important to reset the latch *before* checking if there's work to @@ -100,8 +100,8 @@ static volatile sig_atomic_t waiting = false; /* Read and write end of the self-pipe */ -static int selfpipe_readfd = -1; -static int selfpipe_writefd = -1; +static int selfpipe_readfd = -1; +static int selfpipe_writefd = -1; /* private function prototypes */ static void initSelfPipe(void); @@ -205,7 +205,8 @@ int WaitLatchOrSocket(volatile Latch *latch, pgsocket sock, bool forRead, bool forWrite, long timeout) { - struct timeval tv, *tvp = NULL; + struct timeval tv, + *tvp = NULL; fd_set input_mask; fd_set output_mask; int rc; @@ -225,13 +226,13 @@ WaitLatchOrSocket(volatile Latch *latch, pgsocket sock, bool forRead, waiting = true; for (;;) { - int hifd; + int hifd; /* * Clear the pipe, and check if the latch is set already. If someone - * sets the latch between this and the select() below, the setter - * will write a byte to the pipe (or signal us and the signal handler - * will do that), and the select() will return immediately. + * sets the latch between this and the select() below, the setter will + * write a byte to the pipe (or signal us and the signal handler will + * do that), and the select() will return immediately. */ drainSelfPipe(); if (latch->is_set) @@ -278,7 +279,7 @@ WaitLatchOrSocket(volatile Latch *latch, pgsocket sock, bool forRead, (forWrite && FD_ISSET(sock, &output_mask)))) { result = 2; - break; /* data available in socket */ + break; /* data available in socket */ } } waiting = false; @@ -293,7 +294,7 @@ WaitLatchOrSocket(volatile Latch *latch, pgsocket sock, bool forRead, void SetLatch(volatile Latch *latch) { - pid_t owner_pid; + pid_t owner_pid; /* Quick exit if already set */ if (latch->is_set) @@ -302,17 +303,17 @@ SetLatch(volatile Latch *latch) latch->is_set = true; /* - * See if anyone's waiting for the latch. It can be the current process - * if we're in a signal handler. We use the self-pipe to wake up the - * select() in that case. If it's another process, send a signal. + * See if anyone's waiting for the latch. It can be the current process if + * we're in a signal handler. We use the self-pipe to wake up the select() + * in that case. If it's another process, send a signal. * - * Fetch owner_pid only once, in case the owner simultaneously disowns - * the latch and clears owner_pid. XXX: This assumes that pid_t is - * atomic, which isn't guaranteed to be true! In practice, the effective - * range of pid_t fits in a 32 bit integer, and so should be atomic. In - * the worst case, we might end up signaling wrong process if the right - * one disowns the latch just as we fetch owner_pid. Even then, you're - * very unlucky if a process with that bogus pid exists. + * Fetch owner_pid only once, in case the owner simultaneously disowns the + * latch and clears owner_pid. XXX: This assumes that pid_t is atomic, + * which isn't guaranteed to be true! In practice, the effective range of + * pid_t fits in a 32 bit integer, and so should be atomic. In the worst + * case, we might end up signaling wrong process if the right one disowns + * the latch just as we fetch owner_pid. Even then, you're very unlucky if + * a process with that bogus pid exists. */ owner_pid = latch->owner_pid; if (owner_pid == 0) @@ -351,15 +352,14 @@ latch_sigusr1_handler(void) static void initSelfPipe(void) { - int pipefd[2]; + int pipefd[2]; /* * Set up the self-pipe that allows a signal handler to wake up the * select() in WaitLatch. Make the write-end non-blocking, so that * SetLatch won't block if the event has already been set many times - * filling the kernel buffer. Make the read-end non-blocking too, so - * that we can easily clear the pipe by reading until EAGAIN or - * EWOULDBLOCK. + * filling the kernel buffer. Make the read-end non-blocking too, so that + * we can easily clear the pipe by reading until EAGAIN or EWOULDBLOCK. */ if (pipe(pipefd) < 0) elog(FATAL, "pipe() failed: %m"); @@ -376,8 +376,8 @@ initSelfPipe(void) static void sendSelfPipeByte(void) { - int rc; - char dummy = 0; + int rc; + char dummy = 0; retry: rc = write(selfpipe_writefd, &dummy, 1); @@ -388,16 +388,16 @@ retry: goto retry; /* - * If the pipe is full, we don't need to retry, the data that's - * there already is enough to wake up WaitLatch. + * If the pipe is full, we don't need to retry, the data that's there + * already is enough to wake up WaitLatch. */ if (errno == EAGAIN || errno == EWOULDBLOCK) return; /* - * Oops, the write() failed for some other reason. We might be in - * a signal handler, so it's not safe to elog(). We have no choice - * but silently ignore the error. + * Oops, the write() failed for some other reason. We might be in a + * signal handler, so it's not safe to elog(). We have no choice but + * silently ignore the error. */ return; } @@ -408,11 +408,11 @@ static void drainSelfPipe(void) { /* - * There shouldn't normally be more than one byte in the pipe, or maybe - * a few more if multiple processes run SetLatch at the same instant. + * There shouldn't normally be more than one byte in the pipe, or maybe a + * few more if multiple processes run SetLatch at the same instant. */ - char buf[16]; - int rc; + char buf[16]; + int rc; for (;;) { @@ -420,9 +420,9 @@ drainSelfPipe(void) if (rc < 0) { if (errno == EAGAIN || errno == EWOULDBLOCK) - break; /* the pipe is empty */ + break; /* the pipe is empty */ else if (errno == EINTR) - continue; /* retry */ + continue; /* retry */ else elog(ERROR, "read() on self-pipe failed: %m"); } diff --git a/src/backend/port/win32/crashdump.c b/src/backend/port/win32/crashdump.c index b58b181ed99..98bde14804e 100644 --- a/src/backend/port/win32/crashdump.c +++ b/src/backend/port/win32/crashdump.c @@ -1,7 +1,7 @@ /*------------------------------------------------------------------------- * * win32_crashdump.c - * Automatic crash dump creation for PostgreSQL on Windows + * Automatic crash dump creation for PostgreSQL on Windows * * The crashdump feature traps unhandled win32 exceptions produced by the * backend, and tries to produce a Windows MiniDump crash @@ -57,11 +57,11 @@ * http://www.debuginfo.com/articles/effminidumps.html */ -typedef BOOL (WINAPI *MINIDUMPWRITEDUMP)(HANDLE hProcess, DWORD dwPid, HANDLE hFile, MINIDUMP_TYPE DumpType, - CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam, - CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, - CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam - ); +typedef BOOL (WINAPI * MINIDUMPWRITEDUMP) (HANDLE hProcess, DWORD dwPid, HANDLE hFile, MINIDUMP_TYPE DumpType, + CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam, + CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, + CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam +); /* @@ -76,24 +76,25 @@ typedef BOOL (WINAPI *MINIDUMPWRITEDUMP)(HANDLE hProcess, DWORD dwPid, HANDLE hF * any PostgreSQL functions. */ static LONG WINAPI -crashDumpHandler(struct _EXCEPTION_POINTERS *pExceptionInfo) +crashDumpHandler(struct _EXCEPTION_POINTERS * pExceptionInfo) { /* - * We only write crash dumps if the "crashdumps" directory within - * the postgres data directory exists. + * We only write crash dumps if the "crashdumps" directory within the + * postgres data directory exists. */ - DWORD attribs = GetFileAttributesA("crashdumps"); - if (attribs != INVALID_FILE_ATTRIBUTES && (attribs & FILE_ATTRIBUTE_DIRECTORY) ) + DWORD attribs = GetFileAttributesA("crashdumps"); + + if (attribs != INVALID_FILE_ATTRIBUTES && (attribs & FILE_ATTRIBUTE_DIRECTORY)) { /* 'crashdumps' exists and is a directory. Try to write a dump' */ - HMODULE hDll = NULL; + HMODULE hDll = NULL; MINIDUMPWRITEDUMP pDump = NULL; MINIDUMP_TYPE dumpType; - char dumpPath[_MAX_PATH]; - HANDLE selfProcHandle = GetCurrentProcess(); - DWORD selfPid = GetProcessId(selfProcHandle); - HANDLE dumpFile; - DWORD systemTicks; + char dumpPath[_MAX_PATH]; + HANDLE selfProcHandle = GetCurrentProcess(); + DWORD selfPid = GetProcessId(selfProcHandle); + HANDLE dumpFile; + DWORD systemTicks; struct _MINIDUMP_EXCEPTION_INFORMATION ExInfo; ExInfo.ThreadId = GetCurrentThreadId(); @@ -108,19 +109,18 @@ crashDumpHandler(struct _EXCEPTION_POINTERS *pExceptionInfo) return EXCEPTION_CONTINUE_SEARCH; } - pDump = (MINIDUMPWRITEDUMP)GetProcAddress(hDll, "MiniDumpWriteDump"); + pDump = (MINIDUMPWRITEDUMP) GetProcAddress(hDll, "MiniDumpWriteDump"); - if (pDump==NULL) + if (pDump == NULL) { write_stderr("could not load required functions in dbghelp.dll, cannot write crashdump\n"); return EXCEPTION_CONTINUE_SEARCH; } /* - * Dump as much as we can, except shared memory, code segments, - * and memory mapped files. - * Exactly what we can dump depends on the version of dbghelp.dll, - * see: + * Dump as much as we can, except shared memory, code segments, and + * memory mapped files. Exactly what we can dump depends on the + * version of dbghelp.dll, see: * http://msdn.microsoft.com/en-us/library/ms680519(v=VS.85).aspx */ dumpType = MiniDumpNormal | MiniDumpWithHandleData | @@ -135,25 +135,25 @@ crashDumpHandler(struct _EXCEPTION_POINTERS *pExceptionInfo) systemTicks = GetTickCount(); snprintf(dumpPath, _MAX_PATH, - "crashdumps\\postgres-pid%0i-%0i.mdmp", selfPid, systemTicks); - dumpPath[_MAX_PATH-1] = '\0'; + "crashdumps\\postgres-pid%0i-%0i.mdmp", selfPid, systemTicks); + dumpPath[_MAX_PATH - 1] = '\0'; dumpFile = CreateFile(dumpPath, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); - if (dumpFile==INVALID_HANDLE_VALUE) + if (dumpFile == INVALID_HANDLE_VALUE) { write_stderr("could not open crash dump file %s for writing: error code %d\n", - dumpPath, GetLastError()); + dumpPath, GetLastError()); return EXCEPTION_CONTINUE_SEARCH; } - if ((*pDump)(selfProcHandle, selfPid, dumpFile, dumpType, &ExInfo, - NULL, NULL)) + if ((*pDump) (selfProcHandle, selfPid, dumpFile, dumpType, &ExInfo, + NULL, NULL)) write_stderr("wrote crash dump to %s\n", dumpPath); else write_stderr("could not write crash dump to %s: error code %08x\n", - dumpPath, GetLastError()); + dumpPath, GetLastError()); CloseHandle(dumpFile); } diff --git a/src/backend/port/win32/timer.c b/src/backend/port/win32/timer.c index 1eb6de9bdb7..e118d96a4bc 100644 --- a/src/backend/port/win32/timer.c +++ b/src/backend/port/win32/timer.c @@ -27,7 +27,7 @@ typedef struct timerCA struct itimerval value; HANDLE event; CRITICAL_SECTION crit_sec; -} timerCA; +} timerCA; static timerCA timerCommArea; static HANDLE timerThreadHandle = INVALID_HANDLE_VALUE; diff --git a/src/backend/port/win32_latch.c b/src/backend/port/win32_latch.c index f42cfef40e7..b158300d572 100644 --- a/src/backend/port/win32_latch.c +++ b/src/backend/port/win32_latch.c @@ -50,8 +50,7 @@ InitSharedLatch(volatile Latch *latch) latch->is_shared = true; /* - * Set up security attributes to specify that the events are - * inherited. + * Set up security attributes to specify that the events are inherited. */ ZeroMemory(&sa, sizeof(sa)); sa.nLength = sizeof(sa); @@ -106,7 +105,7 @@ WaitLatchOrSocket(volatile Latch *latch, SOCKET sock, bool forRead, numevents = 2; if (sock != PGINVALID_SOCKET && (forRead || forWrite)) { - int flags = 0; + int flags = 0; if (forRead) flags |= FD_READ; @@ -135,7 +134,7 @@ WaitLatchOrSocket(volatile Latch *latch, SOCKET sock, bool forRead, } rc = WaitForMultipleObjects(numevents, events, FALSE, - (timeout >= 0) ? (timeout / 1000) : INFINITE); + (timeout >= 0) ? (timeout / 1000) : INFINITE); if (rc == WAIT_FAILED) elog(ERROR, "WaitForMultipleObjects() failed: error code %d", (int) GetLastError()); else if (rc == WAIT_TIMEOUT) @@ -178,7 +177,7 @@ WaitLatchOrSocket(volatile Latch *latch, SOCKET sock, bool forRead, void SetLatch(volatile Latch *latch) { - HANDLE handle; + HANDLE handle; /* Quick exit if already set */ if (latch->is_set) @@ -187,21 +186,22 @@ SetLatch(volatile Latch *latch) latch->is_set = true; /* - * See if anyone's waiting for the latch. It can be the current process - * if we're in a signal handler. Use a local variable here in case the - * latch is just disowned between the test and the SetEvent call, and - * event field set to NULL. + * See if anyone's waiting for the latch. It can be the current process if + * we're in a signal handler. Use a local variable here in case the latch + * is just disowned between the test and the SetEvent call, and event + * field set to NULL. * - * Fetch handle field only once, in case the owner simultaneously - * disowns the latch and clears handle. This assumes that HANDLE is - * atomic, which isn't guaranteed to be true! In practice, it should be, - * and in the worst case we end up calling SetEvent with a bogus handle, - * and SetEvent will return an error with no harm done. + * Fetch handle field only once, in case the owner simultaneously disowns + * the latch and clears handle. This assumes that HANDLE is atomic, which + * isn't guaranteed to be true! In practice, it should be, and in the + * worst case we end up calling SetEvent with a bogus handle, and SetEvent + * will return an error with no harm done. */ handle = latch->event; if (handle) { SetEvent(handle); + /* * Note that we silently ignore any errors. We might be in a signal * handler or other critical path where it's not safe to call elog(). diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c index 619facc7526..9fa63a4e6e1 100644 --- a/src/backend/postmaster/autovacuum.c +++ b/src/backend/postmaster/autovacuum.c @@ -210,7 +210,7 @@ typedef struct WorkerInfoData int wi_cost_delay; int wi_cost_limit; int wi_cost_limit_base; -} WorkerInfoData; +} WorkerInfoData; typedef struct WorkerInfoData *WorkerInfo; @@ -224,7 +224,7 @@ typedef enum AutoVacForkFailed, /* failed trying to start a worker */ AutoVacRebalance, /* rebalance the cost limits */ AutoVacNumSignals /* must be last */ -} AutoVacuumSignal; +} AutoVacuumSignal; /*------------- * The main autovacuum shmem struct. On shared memory we store this main @@ -1527,9 +1527,9 @@ AutoVacWorkerMain(int argc, char *argv[]) SetConfigOption("statement_timeout", "0", PGC_SUSET, PGC_S_OVERRIDE); /* - * Force synchronous replication off to allow regular maintenance even - * if we are waiting for standbys to connect. This is important to - * ensure we aren't blocked from performing anti-wraparound tasks. + * Force synchronous replication off to allow regular maintenance even if + * we are waiting for standbys to connect. This is important to ensure we + * aren't blocked from performing anti-wraparound tasks. */ if (synchronous_commit > SYNCHRONOUS_COMMIT_LOCAL_FLUSH) SetConfigOption("synchronous_commit", "local", PGC_SUSET, PGC_S_OVERRIDE); @@ -1690,8 +1690,8 @@ autovac_balance_cost(void) { /* * The idea here is that we ration out I/O equally. The amount of I/O - * that a worker can consume is determined by cost_limit/cost_delay, so - * we try to equalize those ratios rather than the raw limit settings. + * that a worker can consume is determined by cost_limit/cost_delay, so we + * try to equalize those ratios rather than the raw limit settings. * * note: in cost_limit, zero also means use value from elsewhere, because * zero is not a valid value. @@ -1746,7 +1746,7 @@ autovac_balance_cost(void) /* * We put a lower bound of 1 on the cost_limit, to avoid division- - * by-zero in the vacuum code. Also, in case of roundoff trouble + * by-zero in the vacuum code. Also, in case of roundoff trouble * in these calculations, let's be sure we don't ever set * cost_limit to more than the base value. */ @@ -1785,7 +1785,7 @@ get_database_list(void) Relation rel; HeapScanDesc scan; HeapTuple tup; - MemoryContext resultcxt; + MemoryContext resultcxt; /* This is the context that we will allocate our output data in */ resultcxt = CurrentMemoryContext; @@ -1807,13 +1807,13 @@ get_database_list(void) { Form_pg_database pgdatabase = (Form_pg_database) GETSTRUCT(tup); avw_dbase *avdb; - MemoryContext oldcxt; + MemoryContext oldcxt; /* - * Allocate our results in the caller's context, not the transaction's. - * We do this inside the loop, and restore the original context at the - * end, so that leaky things like heap_getnext() are not called in a - * potentially long-lived context. + * Allocate our results in the caller's context, not the + * transaction's. We do this inside the loop, and restore the original + * context at the end, so that leaky things like heap_getnext() are + * not called in a potentially long-lived context. */ oldcxt = MemoryContextSwitchTo(resultcxt); @@ -2217,9 +2217,9 @@ do_autovacuum(void) LWLockRelease(AutovacuumScheduleLock); /* - * Remember the prevailing values of the vacuum cost GUCs. We have - * to restore these at the bottom of the loop, else we'll compute - * wrong values in the next iteration of autovac_balance_cost(). + * Remember the prevailing values of the vacuum cost GUCs. We have to + * restore these at the bottom of the loop, else we'll compute wrong + * values in the next iteration of autovac_balance_cost(). */ stdVacuumCostDelay = VacuumCostDelay; stdVacuumCostLimit = VacuumCostLimit; diff --git a/src/backend/postmaster/bgwriter.c b/src/backend/postmaster/bgwriter.c index 1b450a802ba..1f4ac93d8d7 100644 --- a/src/backend/postmaster/bgwriter.c +++ b/src/backend/postmaster/bgwriter.c @@ -1077,7 +1077,7 @@ RequestCheckpoint(int flags) * to the requests[] queue without checking for duplicates. The bgwriter * will have to eliminate dups internally anyway. However, if we discover * that the queue is full, we make a pass over the entire queue to compact - * it. This is somewhat expensive, but the alternative is for the backend + * it. This is somewhat expensive, but the alternative is for the backend * to perform its own fsync, which is far more expensive in practice. It * is theoretically possible a backend fsync might still be necessary, if * the queue is full and contains no duplicate entries. In that case, we @@ -1102,13 +1102,13 @@ ForwardFsyncRequest(RelFileNodeBackend rnode, ForkNumber forknum, /* * If the background writer isn't running or the request queue is full, - * the backend will have to perform its own fsync request. But before + * the backend will have to perform its own fsync request. But before * forcing that to happen, we can try to compact the background writer * request queue. */ if (BgWriterShmem->bgwriter_pid == 0 || (BgWriterShmem->num_requests >= BgWriterShmem->max_requests - && !CompactBgwriterRequestQueue())) + && !CompactBgwriterRequestQueue())) { /* * Count the subset of writes where backends have to do their own @@ -1128,12 +1128,12 @@ ForwardFsyncRequest(RelFileNodeBackend rnode, ForkNumber forknum, /* * CompactBgwriterRequestQueue - * Remove duplicates from the request queue to avoid backend fsyncs. + * Remove duplicates from the request queue to avoid backend fsyncs. * * Although a full fsync request queue is not common, it can lead to severe * performance problems when it does happen. So far, this situation has * only been observed to occur when the system is under heavy write load, - * and especially during the "sync" phase of a checkpoint. Without this + * and especially during the "sync" phase of a checkpoint. Without this * logic, each backend begins doing an fsync for every block written, which * gets very expensive and can slow down the whole system. * @@ -1144,9 +1144,10 @@ ForwardFsyncRequest(RelFileNodeBackend rnode, ForkNumber forknum, static bool CompactBgwriterRequestQueue() { - struct BgWriterSlotMapping { - BgWriterRequest request; - int slot; + struct BgWriterSlotMapping + { + BgWriterRequest request; + int slot; }; int n, @@ -1172,7 +1173,7 @@ CompactBgwriterRequestQueue() /* Initialize skip_slot array */ skip_slot = palloc0(sizeof(bool) * BgWriterShmem->num_requests); - /* + /* * The basic idea here is that a request can be skipped if it's followed * by a later, identical request. It might seem more sensible to work * backwards from the end of the queue and check whether a request is @@ -1189,7 +1190,7 @@ CompactBgwriterRequestQueue() { BgWriterRequest *request; struct BgWriterSlotMapping *slotmap; - bool found; + bool found; request = &BgWriterShmem->requests[n]; slotmap = hash_search(htab, request, HASH_ENTER, &found); @@ -1219,8 +1220,8 @@ CompactBgwriterRequestQueue() BgWriterShmem->requests[preserve_count++] = BgWriterShmem->requests[n]; } ereport(DEBUG1, - (errmsg("compacted fsync request queue from %d entries to %d entries", - BgWriterShmem->num_requests, preserve_count))); + (errmsg("compacted fsync request queue from %d entries to %d entries", + BgWriterShmem->num_requests, preserve_count))); BgWriterShmem->num_requests = preserve_count; /* Cleanup. */ diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.c index 5f0db513d27..5ed6e8337c1 100644 --- a/src/backend/postmaster/pgstat.c +++ b/src/backend/postmaster/pgstat.c @@ -1319,7 +1319,7 @@ pgstat_report_analyze(Relation rel, bool adopt_counts, /* -------- * pgstat_report_recovery_conflict() - * - * Tell the collector about a Hot Standby recovery conflict. + * Tell the collector about a Hot Standby recovery conflict. * -------- */ void @@ -4075,7 +4075,7 @@ pgstat_recv_resetcounter(PgStat_MsgResetcounter *msg, int len) dbentry->functions = NULL; /* - * Reset database-level stats too. This should match the initialization + * Reset database-level stats too. This should match the initialization * code in pgstat_get_db_entry(). */ dbentry->n_xact_commit = 0; @@ -4280,22 +4280,23 @@ pgstat_recv_bgwriter(PgStat_MsgBgWriter *msg, int len) /* ---------- * pgstat_recv_recoveryconflict() - * - * Process as RECOVERYCONFLICT message. + * Process as RECOVERYCONFLICT message. * ---------- */ static void pgstat_recv_recoveryconflict(PgStat_MsgRecoveryConflict *msg, int len) { PgStat_StatDBEntry *dbentry; + dbentry = pgstat_get_db_entry(msg->m_databaseid, true); switch (msg->m_reason) { case PROCSIG_RECOVERY_CONFLICT_DATABASE: + /* - * Since we drop the information about the database as soon - * as it replicates, there is no point in counting these - * conflicts. + * Since we drop the information about the database as soon as it + * replicates, there is no point in counting these conflicts. */ break; case PROCSIG_RECOVERY_CONFLICT_TABLESPACE: diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index 93e59258cc5..6e7f66472fd 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -385,7 +385,7 @@ typedef struct HANDLE waitHandle; HANDLE procHandle; DWORD procId; -} win32_deadchild_waitinfo; +} win32_deadchild_waitinfo; HANDLE PostmasterHandle; #endif @@ -400,7 +400,7 @@ typedef struct SOCKET origsocket; /* Original socket value, or PGINVALID_SOCKET * if not a socket */ WSAPROTOCOL_INFO wsainfo; -} InheritableSocket; +} InheritableSocket; #else typedef int InheritableSocket; #endif @@ -447,15 +447,15 @@ typedef struct char my_exec_path[MAXPGPATH]; char pkglib_path[MAXPGPATH]; char ExtraOptions[MAXPGPATH]; -} BackendParameters; +} BackendParameters; static void read_backend_variables(char *id, Port *port); -static void restore_backend_variables(BackendParameters * param, Port *port); +static void restore_backend_variables(BackendParameters *param, Port *port); #ifndef WIN32 -static bool save_backend_variables(BackendParameters * param, Port *port); +static bool save_backend_variables(BackendParameters *param, Port *port); #else -static bool save_backend_variables(BackendParameters * param, Port *port, +static bool save_backend_variables(BackendParameters *param, Port *port, HANDLE childProcess, pid_t childPid); #endif @@ -1936,9 +1936,9 @@ canAcceptConnections(void) * * In state PM_WAIT_BACKUP only superusers can connect (this must be * allowed so that a superuser can end online backup mode); we return - * CAC_WAITBACKUP code to indicate that this must be checked later. - * Note that neither CAC_OK nor CAC_WAITBACKUP can safely be returned - * until we have checked for too many children. + * CAC_WAITBACKUP code to indicate that this must be checked later. Note + * that neither CAC_OK nor CAC_WAITBACKUP can safely be returned until we + * have checked for too many children. */ if (pmState != PM_RUN) { @@ -1949,10 +1949,10 @@ canAcceptConnections(void) else if (!FatalError && (pmState == PM_STARTUP || pmState == PM_RECOVERY)) - return CAC_STARTUP; /* normal startup */ + return CAC_STARTUP; /* normal startup */ else if (!FatalError && pmState == PM_HOT_STANDBY) - result = CAC_OK; /* connection OK during hot standby */ + result = CAC_OK; /* connection OK during hot standby */ else return CAC_RECOVERY; /* else must be crash recovery */ } @@ -2004,10 +2004,10 @@ ConnCreate(int serverFd) /* * Precompute password salt values to use for this connection. It's - * slightly annoying to do this long in advance of knowing whether - * we'll need 'em or not, but we must do the random() calls before we - * fork, not after. Else the postmaster's random sequence won't get - * advanced, and all backends would end up using the same salt... + * slightly annoying to do this long in advance of knowing whether we'll + * need 'em or not, but we must do the random() calls before we fork, not + * after. Else the postmaster's random sequence won't get advanced, and + * all backends would end up using the same salt... */ RandomSalt(port->md5Salt); @@ -2611,12 +2611,13 @@ CleanupBackend(int pid, * the active backend list. */ #ifdef WIN32 + /* - * On win32, also treat ERROR_WAIT_NO_CHILDREN (128) as nonfatal - * case, since that sometimes happens under load when the process fails - * to start properly (long before it starts using shared memory). - * Microsoft reports it is related to mutex failure: - * http://archives.postgresql.org/pgsql-hackers/2010-09/msg00790.php + * On win32, also treat ERROR_WAIT_NO_CHILDREN (128) as nonfatal case, + * since that sometimes happens under load when the process fails to start + * properly (long before it starts using shared memory). Microsoft reports + * it is related to mutex failure: + * http://archives.postgresql.org/pgsql-hackers/2010-09/msg00790.php */ if (exitstatus == ERROR_WAIT_NO_CHILDREN) { @@ -3086,11 +3087,11 @@ PostmasterStateMachine(void) } /* - * If recovery failed, or the user does not want an automatic restart after - * backend crashes, wait for all non-syslogger children to exit, and then - * exit postmaster. We don't try to reinitialize when recovery fails, - * because more than likely it will just fail again and we will keep trying - * forever. + * If recovery failed, or the user does not want an automatic restart + * after backend crashes, wait for all non-syslogger children to exit, and + * then exit postmaster. We don't try to reinitialize when recovery fails, + * because more than likely it will just fail again and we will keep + * trying forever. */ if (pmState == PM_NO_CHILDREN && (RecoveryError || !restart_after_crash)) ExitPostmaster(1); @@ -3169,9 +3170,8 @@ SignalSomeChildren(int signal, int target) continue; /* - * Since target == BACKEND_TYPE_ALL is the most common case, - * we test it first and avoid touching shared memory for - * every child. + * Since target == BACKEND_TYPE_ALL is the most common case, we test + * it first and avoid touching shared memory for every child. */ if (target != BACKEND_TYPE_ALL) { @@ -4409,9 +4409,8 @@ CountChildren(int target) continue; /* - * Since target == BACKEND_TYPE_ALL is the most common case, - * we test it first and avoid touching shared memory for - * every child. + * Since target == BACKEND_TYPE_ALL is the most common case, we test + * it first and avoid touching shared memory for every child. */ if (target != BACKEND_TYPE_ALL) { @@ -4686,19 +4685,19 @@ extern pgsocket pgStatSock; #define read_inheritable_socket(dest, src) (*(dest) = *(src)) #else static bool write_duplicated_handle(HANDLE *dest, HANDLE src, HANDLE child); -static bool write_inheritable_socket(InheritableSocket * dest, SOCKET src, +static bool write_inheritable_socket(InheritableSocket *dest, SOCKET src, pid_t childPid); -static void read_inheritable_socket(SOCKET * dest, InheritableSocket * src); +static void read_inheritable_socket(SOCKET *dest, InheritableSocket *src); #endif /* Save critical backend variables into the BackendParameters struct */ #ifndef WIN32 static bool -save_backend_variables(BackendParameters * param, Port *port) +save_backend_variables(BackendParameters *param, Port *port) #else static bool -save_backend_variables(BackendParameters * param, Port *port, +save_backend_variables(BackendParameters *param, Port *port, HANDLE childProcess, pid_t childPid) #endif { @@ -4790,7 +4789,7 @@ write_duplicated_handle(HANDLE *dest, HANDLE src, HANDLE childProcess) * straight socket inheritance. */ static bool -write_inheritable_socket(InheritableSocket * dest, SOCKET src, pid_t childpid) +write_inheritable_socket(InheritableSocket *dest, SOCKET src, pid_t childpid) { dest->origsocket = src; if (src != 0 && src != PGINVALID_SOCKET) @@ -4811,7 +4810,7 @@ write_inheritable_socket(InheritableSocket * dest, SOCKET src, pid_t childpid) * Read a duplicate socket structure back, and get the socket descriptor. */ static void -read_inheritable_socket(SOCKET * dest, InheritableSocket * src) +read_inheritable_socket(SOCKET *dest, InheritableSocket *src) { SOCKET s; @@ -4920,7 +4919,7 @@ read_backend_variables(char *id, Port *port) /* Restore critical backend variables from the BackendParameters struct */ static void -restore_backend_variables(BackendParameters * param, Port *port) +restore_backend_variables(BackendParameters *param, Port *port) { memcpy(port, ¶m->port, sizeof(Port)); read_inheritable_socket(&port->sock, ¶m->portsocket); diff --git a/src/backend/postmaster/syslogger.c b/src/backend/postmaster/syslogger.c index f2eb0ad02b1..a00b70f934e 100644 --- a/src/backend/postmaster/syslogger.c +++ b/src/backend/postmaster/syslogger.c @@ -137,7 +137,7 @@ static void process_pipe_input(char *logbuffer, int *bytes_in_logbuffer); static void flush_pipe_input(char *logbuffer, int *bytes_in_logbuffer); static void open_csvlogfile(void); static FILE *logfile_open(const char *filename, const char *mode, - bool allow_errors); + bool allow_errors); #ifdef WIN32 static unsigned int __stdcall pipeThread(void *arg); @@ -1017,8 +1017,8 @@ logfile_open(const char *filename, const char *mode, bool allow_errors) mode_t oumask; /* - * Note we do not let Log_file_mode disable IWUSR, since we certainly - * want to be able to write the files ourselves. + * Note we do not let Log_file_mode disable IWUSR, since we certainly want + * to be able to write the files ourselves. */ oumask = umask((mode_t) ((~(Log_file_mode | S_IWUSR)) & (S_IRWXU | S_IRWXG | S_IRWXO))); fh = fopen(filename, mode); @@ -1035,7 +1035,7 @@ logfile_open(const char *filename, const char *mode, bool allow_errors) } else { - int save_errno = errno; + int save_errno = errno; ereport(allow_errors ? LOG : FATAL, (errcode_for_file_access(), diff --git a/src/backend/regex/regcomp.c b/src/backend/regex/regcomp.c index a93e99011d1..6ed466a9d97 100644 --- a/src/backend/regex/regcomp.c +++ b/src/backend/regex/regcomp.c @@ -238,7 +238,7 @@ struct vars #define NOERR() {if (ISERR()) return;} /* if error seen, return */ #define NOERRN() {if (ISERR()) return NULL;} /* NOERR with retval */ #define NOERRZ() {if (ISERR()) return 0;} /* NOERR with retval */ -#define INSIST(c, e) do { if (!(c)) ERR(e); } while (0) /* error if c false */ +#define INSIST(c, e) do { if (!(c)) ERR(e); } while (0) /* error if c false */ #define NOTE(b) (v->re->re_info |= (b)) /* note visible condition */ #define EMPTYARC(x, y) newarc(v->nfa, EMPTY, 0, x, y) diff --git a/src/backend/replication/basebackup.c b/src/backend/replication/basebackup.c index d21568cb215..030a283e817 100644 --- a/src/backend/replication/basebackup.c +++ b/src/backend/replication/basebackup.c @@ -39,7 +39,7 @@ typedef struct bool fastcheckpoint; bool nowait; bool includewal; -} basebackup_options; +} basebackup_options; static int64 sendDir(char *path, int basepathlen, bool sizeonly); @@ -67,7 +67,7 @@ typedef struct char *oid; char *path; int64 size; -} tablespaceinfo; +} tablespaceinfo; /* @@ -119,7 +119,7 @@ perform_base_backup(basebackup_options *opt, DIR *tblspcdir) if (readlink(fullpath, linkpath, sizeof(linkpath) - 1) == -1) { ereport(WARNING, - (errmsg("unable to read symbolic link %s: %m", fullpath))); + (errmsg("unable to read symbolic link %s: %m", fullpath))); continue; } @@ -219,10 +219,11 @@ perform_base_backup(basebackup_options *opt, DIR *tblspcdir) ptr.xrecoff = logseg * XLogSegSize + TAR_SEND_SIZE * i; /* - * Some old compilers, e.g. gcc 2.95.3/x86, think that passing - * a struct in the same function as a longjump might clobber - * a variable. bjm 2011-02-04 - * http://lists.apple.com/archives/xcode-users/2003/Dec//msg00051.html + * Some old compilers, e.g. gcc 2.95.3/x86, think that passing + * a struct in the same function as a longjump might clobber a + * variable. bjm 2011-02-04 + * http://lists.apple.com/archives/xcode-users/2003/Dec//msg000 + * 51.html */ XLogRead(buf, ptr, TAR_SEND_SIZE); if (pq_putmessage('d', buf, TAR_SEND_SIZE)) @@ -494,13 +495,14 @@ static void sendFileWithContent(const char *filename, const char *content) { struct stat statbuf; - int pad, len; + int pad, + len; len = strlen(content); /* - * Construct a stat struct for the backup_label file we're injecting - * in the tar. + * Construct a stat struct for the backup_label file we're injecting in + * the tar. */ /* Windows doesn't have the concept of uid and gid */ #ifdef WIN32 @@ -522,7 +524,8 @@ sendFileWithContent(const char *filename, const char *content) pad = ((len + 511) & ~511) - len; if (pad > 0) { - char buf[512]; + char buf[512]; + MemSet(buf, 0, pad); pq_putmessage('d', buf, pad); } @@ -564,13 +567,13 @@ sendDir(char *path, int basepathlen, bool sizeonly) continue; /* - * Check if the postmaster has signaled us to exit, and abort - * with an error in that case. The error handler further up - * will call do_pg_abort_backup() for us. + * Check if the postmaster has signaled us to exit, and abort with an + * error in that case. The error handler further up will call + * do_pg_abort_backup() for us. */ if (walsender_shutdown_requested || walsender_ready_to_stop) ereport(ERROR, - (errmsg("shutdown requested, aborting active base backup"))); + (errmsg("shutdown requested, aborting active base backup"))); snprintf(pathbuf, MAXPGPATH, "%s/%s", path, de->d_name); @@ -707,7 +710,7 @@ _tarChecksum(char *header) /* Given the member, write the TAR header & send the file */ static void -sendFile(char *readfilename, char *tarfilename, struct stat *statbuf) +sendFile(char *readfilename, char *tarfilename, struct stat * statbuf) { FILE *fp; char buf[TAR_SEND_SIZE]; @@ -737,7 +740,7 @@ sendFile(char *readfilename, char *tarfilename, struct stat *statbuf) /* Send the chunk as a CopyData message */ if (pq_putmessage('d', buf, cnt)) ereport(ERROR, - (errmsg("base backup could not send data, aborting backup"))); + (errmsg("base backup could not send data, aborting backup"))); len += cnt; diff --git a/src/backend/replication/syncrep.c b/src/backend/replication/syncrep.c index 192aac9aea3..1d4df8a4488 100644 --- a/src/backend/replication/syncrep.c +++ b/src/backend/replication/syncrep.c @@ -63,7 +63,7 @@ #include "utils/ps_status.h" /* User-settable parameters for sync rep */ -char *SyncRepStandbyNames; +char *SyncRepStandbyNames; #define SyncStandbysDefined() \ (SyncRepStandbyNames != NULL && SyncRepStandbyNames[0] != '\0') @@ -73,7 +73,8 @@ static bool announce_next_takeover = true; static void SyncRepQueueInsert(void); static void SyncRepCancelWait(void); -static int SyncRepGetStandbyPriority(void); +static int SyncRepGetStandbyPriority(void); + #ifdef USE_ASSERT_CHECKING static bool SyncRepQueueIsOrderedByLSN(void); #endif @@ -96,13 +97,13 @@ static bool SyncRepQueueIsOrderedByLSN(void); void SyncRepWaitForLSN(XLogRecPtr XactCommitLSN) { - char *new_status = NULL; + char *new_status = NULL; const char *old_status; /* - * Fast exit if user has not requested sync replication, or - * there are no sync replication standby names defined. - * Note that those standbys don't need to be connected. + * Fast exit if user has not requested sync replication, or there are no + * sync replication standby names defined. Note that those standbys don't + * need to be connected. */ if (!SyncRepRequested() || !SyncStandbysDefined()) return; @@ -117,12 +118,12 @@ SyncRepWaitForLSN(XLogRecPtr XactCommitLSN) Assert(MyProc->syncRepState == SYNC_REP_NOT_WAITING); /* - * We don't wait for sync rep if WalSndCtl->sync_standbys_defined is - * not set. See SyncRepUpdateSyncStandbysDefined. + * We don't wait for sync rep if WalSndCtl->sync_standbys_defined is not + * set. See SyncRepUpdateSyncStandbysDefined. * - * Also check that the standby hasn't already replied. Unlikely - * race condition but we'll be fetching that cache line anyway - * so its likely to be a low cost check. + * Also check that the standby hasn't already replied. Unlikely race + * condition but we'll be fetching that cache line anyway so its likely to + * be a low cost check. */ if (!WalSndCtl->sync_standbys_defined || XLByteLE(XactCommitLSN, WalSndCtl->lsn)) @@ -163,12 +164,12 @@ SyncRepWaitForLSN(XLogRecPtr XactCommitLSN) */ for (;;) { - int syncRepState; + int syncRepState; /* - * Wait on latch for up to 60 seconds. This allows us to - * check for postmaster death regularly while waiting. - * Note that timeout here does not necessarily release from loop. + * Wait on latch for up to 60 seconds. This allows us to check for + * postmaster death regularly while waiting. Note that timeout here + * does not necessarily release from loop. */ WaitLatch(&MyProc->waitLatch, 60000000L); @@ -176,12 +177,13 @@ SyncRepWaitForLSN(XLogRecPtr XactCommitLSN) ResetLatch(&MyProc->waitLatch); /* - * Try checking the state without the lock first. There's no guarantee - * that we'll read the most up-to-date value, so if it looks like we're - * still waiting, recheck while holding the lock. But if it looks like - * we're done, we must really be done, because once walsender changes - * the state to SYNC_REP_WAIT_COMPLETE, it will never update it again, - * so we can't be seeing a stale value in that case. + * Try checking the state without the lock first. There's no + * guarantee that we'll read the most up-to-date value, so if it looks + * like we're still waiting, recheck while holding the lock. But if + * it looks like we're done, we must really be done, because once + * walsender changes the state to SYNC_REP_WAIT_COMPLETE, it will + * never update it again, so we can't be seeing a stale value in that + * case. */ syncRepState = MyProc->syncRepState; if (syncRepState == SYNC_REP_WAITING) @@ -195,16 +197,15 @@ SyncRepWaitForLSN(XLogRecPtr XactCommitLSN) /* * If a wait for synchronous replication is pending, we can neither - * acknowledge the commit nor raise ERROR or FATAL. The latter - * would lead the client to believe that that the transaction - * aborted, which is not true: it's already committed locally. - * The former is no good either: the client has requested - * synchronous replication, and is entitled to assume that an - * acknowledged commit is also replicated, which may not be true. - * So in this case we issue a WARNING (which some clients may - * be able to interpret) and shut off further output. We do NOT - * reset ProcDiePending, so that the process will die after the - * commit is cleaned up. + * acknowledge the commit nor raise ERROR or FATAL. The latter would + * lead the client to believe that that the transaction aborted, which + * is not true: it's already committed locally. The former is no good + * either: the client has requested synchronous replication, and is + * entitled to assume that an acknowledged commit is also replicated, + * which may not be true. So in this case we issue a WARNING (which + * some clients may be able to interpret) and shut off further output. + * We do NOT reset ProcDiePending, so that the process will die after + * the commit is cleaned up. */ if (ProcDiePending) { @@ -220,8 +221,8 @@ SyncRepWaitForLSN(XLogRecPtr XactCommitLSN) /* * It's unclear what to do if a query cancel interrupt arrives. We * can't actually abort at this point, but ignoring the interrupt - * altogether is not helpful, so we just terminate the wait with - * a suitable warning. + * altogether is not helpful, so we just terminate the wait with a + * suitable warning. */ if (QueryCancelPending) { @@ -234,8 +235,9 @@ 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. + * If the postmaster dies, we'll probably never get an + * acknowledgement, because all the wal sender processes will exit. + * So just bail out. */ if (!PostmasterIsAlive(true)) { @@ -274,7 +276,7 @@ SyncRepWaitForLSN(XLogRecPtr XactCommitLSN) static void SyncRepQueueInsert(void) { - PGPROC *proc; + PGPROC *proc; proc = (PGPROC *) SHMQueuePrev(&(WalSndCtl->SyncRepQueue), &(WalSndCtl->SyncRepQueue), @@ -283,8 +285,8 @@ SyncRepQueueInsert(void) while (proc) { /* - * Stop at the queue element that we should after to - * ensure the queue is ordered by LSN. + * Stop at the queue element that we should after to ensure the queue + * is ordered by LSN. */ if (XLByteLT(proc->waitLSN, MyProc->waitLSN)) break; @@ -339,7 +341,7 @@ SyncRepCleanupAtProcExit(int code, Datum arg) void SyncRepInitConfig(void) { - int priority; + int priority; /* * Determine if we are a potential sync standby and remember the result @@ -352,8 +354,8 @@ SyncRepInitConfig(void) MyWalSnd->sync_standby_priority = priority; LWLockRelease(SyncRepLock); ereport(DEBUG1, - (errmsg("standby \"%s\" now has synchronous standby priority %u", - application_name, priority))); + (errmsg("standby \"%s\" now has synchronous standby priority %u", + application_name, priority))); } } @@ -369,24 +371,24 @@ SyncRepReleaseWaiters(void) { volatile WalSndCtlData *walsndctl = WalSndCtl; volatile WalSnd *syncWalSnd = NULL; - int numprocs = 0; + int numprocs = 0; int priority = 0; int i; /* * If this WALSender is serving a standby that is not on the list of - * potential standbys then we have nothing to do. If we are still - * starting up or still running base backup, then leave quickly also. + * potential standbys then we have nothing to do. If we are still starting + * up or still running base backup, then leave quickly also. */ if (MyWalSnd->sync_standby_priority == 0 || MyWalSnd->state < WALSNDSTATE_STREAMING) return; /* - * We're a potential sync standby. Release waiters if we are the - * highest priority standby. If there are multiple standbys with - * same priorities then we use the first mentioned standby. - * If you change this, also change pg_stat_get_wal_senders(). + * We're a potential sync standby. Release waiters if we are the highest + * priority standby. If there are multiple standbys with same priorities + * then we use the first mentioned standby. If you change this, also + * change pg_stat_get_wal_senders(). */ LWLockAcquire(SyncRepLock, LW_EXCLUSIVE); @@ -400,8 +402,8 @@ SyncRepReleaseWaiters(void) (priority == 0 || priority > walsnd->sync_standby_priority)) { - priority = walsnd->sync_standby_priority; - syncWalSnd = walsnd; + priority = walsnd->sync_standby_priority; + syncWalSnd = walsnd; } } @@ -423,8 +425,8 @@ SyncRepReleaseWaiters(void) if (XLByteLT(walsndctl->lsn, MyWalSnd->flush)) { /* - * Set the lsn first so that when we wake backends they will - * release up to this location. + * Set the lsn first so that when we wake backends they will release + * up to this location. */ walsndctl->lsn = MyWalSnd->flush; numprocs = SyncRepWakeQueue(false); @@ -433,9 +435,9 @@ SyncRepReleaseWaiters(void) LWLockRelease(SyncRepLock); elog(DEBUG3, "released %d procs up to %X/%X", - numprocs, - MyWalSnd->flush.xlogid, - MyWalSnd->flush.xrecoff); + numprocs, + MyWalSnd->flush.xlogid, + MyWalSnd->flush.xrecoff); /* * If we are managing the highest priority standby, though we weren't @@ -502,7 +504,7 @@ SyncRepGetStandbyPriority(void) /* * Walk queue from head. Set the state of any backends that need to be woken, - * remove them from the queue, and then wake them. Pass all = true to wake + * remove them from the queue, and then wake them. Pass all = true to wake * whole queue; otherwise, just wake up to the walsender's LSN. * * Must hold SyncRepLock. @@ -511,9 +513,9 @@ int SyncRepWakeQueue(bool all) { volatile WalSndCtlData *walsndctl = WalSndCtl; - PGPROC *proc = NULL; - PGPROC *thisproc = NULL; - int numprocs = 0; + PGPROC *proc = NULL; + PGPROC *thisproc = NULL; + int numprocs = 0; Assert(SyncRepQueueIsOrderedByLSN()); @@ -539,8 +541,8 @@ SyncRepWakeQueue(bool all) offsetof(PGPROC, syncRepLinks)); /* - * Set state to complete; see SyncRepWaitForLSN() for discussion - * of the various states. + * Set state to complete; see SyncRepWaitForLSN() for discussion of + * the various states. */ thisproc->syncRepState = SYNC_REP_WAIT_COMPLETE; @@ -603,8 +605,8 @@ SyncRepUpdateSyncStandbysDefined(void) static bool SyncRepQueueIsOrderedByLSN(void) { - PGPROC *proc = NULL; - XLogRecPtr lastLSN; + PGPROC *proc = NULL; + XLogRecPtr lastLSN; lastLSN.xlogid = 0; lastLSN.xrecoff = 0; @@ -616,8 +618,8 @@ SyncRepQueueIsOrderedByLSN(void) while (proc) { /* - * Check the queue is ordered by LSN and that multiple - * procs don't have matching LSNs + * Check the queue is ordered by LSN and that multiple procs don't + * have matching LSNs */ if (XLByteLE(proc->waitLSN, lastLSN)) return false; @@ -662,8 +664,8 @@ check_synchronous_standby_names(char **newval, void **extra, GucSource source) * Any additional validation of standby names should go here. * * Don't attempt to set WALSender priority because this is executed by - * postmaster at startup, not WALSender, so the application_name is - * not yet correctly set. + * postmaster at startup, not WALSender, so the application_name is not + * yet correctly set. */ pfree(rawstring); diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c index f6259e4e30f..471c844ab2a 100644 --- a/src/backend/replication/walreceiver.c +++ b/src/backend/replication/walreceiver.c @@ -94,8 +94,8 @@ static struct XLogRecPtr Flush; /* last byte + 1 flushed in the standby */ } LogstreamResult; -static StandbyReplyMessage reply_message; -static StandbyHSFeedbackMessage feedback_message; +static StandbyReplyMessage reply_message; +static StandbyHSFeedbackMessage feedback_message; /* * About SIGTERM handling: @@ -329,8 +329,8 @@ WalReceiverMain(void) else { /* - * We didn't receive anything new, but send a status update to - * the master anyway, to report any progress in applying WAL. + * We didn't receive anything new, but send a status update to the + * master anyway, to report any progress in applying WAL. */ XLogWalRcvSendReply(); XLogWalRcvSendHSFeedback(); @@ -595,7 +595,7 @@ static void XLogWalRcvSendReply(void) { char buf[sizeof(StandbyReplyMessage) + 1]; - TimestampTz now; + TimestampTz now; /* * If the user doesn't want status to be reported to the master, be sure @@ -619,7 +619,7 @@ XLogWalRcvSendReply(void) if (XLByteEQ(reply_message.write, LogstreamResult.Write) && XLByteEQ(reply_message.flush, LogstreamResult.Flush) && !TimestampDifferenceExceeds(reply_message.sendTime, now, - wal_receiver_status_interval * 1000)) + wal_receiver_status_interval * 1000)) return; /* Construct a new message */ @@ -629,9 +629,9 @@ XLogWalRcvSendReply(void) reply_message.sendTime = now; elog(DEBUG2, "sending write %X/%X flush %X/%X apply %X/%X", - reply_message.write.xlogid, reply_message.write.xrecoff, - reply_message.flush.xlogid, reply_message.flush.xrecoff, - reply_message.apply.xlogid, reply_message.apply.xrecoff); + reply_message.write.xlogid, reply_message.write.xrecoff, + reply_message.flush.xlogid, reply_message.flush.xrecoff, + reply_message.apply.xlogid, reply_message.apply.xrecoff); /* Prepend with the message type and send it. */ buf[0] = 'r'; @@ -646,11 +646,11 @@ XLogWalRcvSendReply(void) static void XLogWalRcvSendHSFeedback(void) { - char buf[sizeof(StandbyHSFeedbackMessage) + 1]; - TimestampTz now; - TransactionId nextXid; - uint32 nextEpoch; - TransactionId xmin; + char buf[sizeof(StandbyHSFeedbackMessage) + 1]; + TimestampTz now; + TransactionId nextXid; + uint32 nextEpoch; + TransactionId xmin; /* * If the user doesn't want status to be reported to the master, be sure @@ -666,26 +666,25 @@ XLogWalRcvSendHSFeedback(void) * Send feedback at most once per wal_receiver_status_interval. */ if (!TimestampDifferenceExceeds(feedback_message.sendTime, now, - wal_receiver_status_interval * 1000)) + wal_receiver_status_interval * 1000)) return; /* - * If Hot Standby is not yet active there is nothing to send. - * Check this after the interval has expired to reduce number of - * calls. + * If Hot Standby is not yet active there is nothing to send. Check this + * after the interval has expired to reduce number of calls. */ if (!HotStandbyActive()) return; /* - * Make the expensive call to get the oldest xmin once we are - * certain everything else has been checked. + * Make the expensive call to get the oldest xmin once we are certain + * everything else has been checked. */ xmin = GetOldestXmin(true, false); /* - * Get epoch and adjust if nextXid and oldestXmin are different - * sides of the epoch boundary. + * Get epoch and adjust if nextXid and oldestXmin are different sides of + * the epoch boundary. */ GetNextXidAndEpoch(&nextXid, &nextEpoch); if (nextXid < xmin) @@ -699,8 +698,8 @@ XLogWalRcvSendHSFeedback(void) feedback_message.epoch = nextEpoch; elog(DEBUG2, "sending hot standby feedback xmin %u epoch %u", - feedback_message.xmin, - feedback_message.epoch); + feedback_message.xmin, + feedback_message.epoch); /* Prepend with the message type and send it. */ buf[0] = 'h'; diff --git a/src/backend/replication/walreceiverfuncs.c b/src/backend/replication/walreceiverfuncs.c index 48ab503d893..587949bfdb9 100644 --- a/src/backend/replication/walreceiverfuncs.c +++ b/src/backend/replication/walreceiverfuncs.c @@ -200,8 +200,8 @@ RequestXLogStreaming(XLogRecPtr recptr, const char *conninfo) walrcv->startTime = now; /* - * If this is the first startup of walreceiver, we initialize - * receivedUpto and latestChunkStart to receiveStart. + * If this is the first startup of walreceiver, we initialize receivedUpto + * and latestChunkStart to receiveStart. */ if (walrcv->receiveStart.xlogid == 0 && walrcv->receiveStart.xrecoff == 0) diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c index 1c11e7ff7a2..af3c95a78b8 100644 --- a/src/backend/replication/walsender.c +++ b/src/backend/replication/walsender.c @@ -66,15 +66,16 @@ WalSndCtlData *WalSndCtl = NULL; /* My slot in the shared memory array */ -WalSnd *MyWalSnd = NULL; +WalSnd *MyWalSnd = NULL; /* Global state */ bool am_walsender = false; /* Am I a walsender process ? */ /* User-settable parameters for walsender */ int max_wal_senders = 0; /* the maximum number of concurrent walsenders */ -int WalSndDelay = 1000; /* max sleep time between some actions */ -int replication_timeout = 60 * 1000; /* maximum time to send one WAL data message */ +int WalSndDelay = 1000; /* max sleep time between some actions */ +int replication_timeout = 60 * 1000; /* maximum time to send one + * WAL data message */ /* * These variables are used similarly to openLogFile/Id/Seg/Off, @@ -121,7 +122,7 @@ static void WalSndHandshake(void); static void WalSndKill(int code, Datum arg); static void XLogSend(char *msgbuf, bool *caughtup); static void IdentifySystem(void); -static void StartReplication(StartReplicationCmd * cmd); +static void StartReplication(StartReplicationCmd *cmd); static void ProcessStandbyMessage(void); static void ProcessStandbyReplyMessage(void); static void ProcessStandbyHSFeedbackMessage(void); @@ -281,8 +282,8 @@ IdentifySystem(void) XLogRecPtr logptr; /* - * Reply with a result set with one row, three columns. First col is system - * ID, second is timeline ID, and third is current xlog location. + * Reply with a result set with one row, three columns. First col is + * system ID, second is timeline ID, and third is current xlog location. */ snprintf(sysid, sizeof(sysid), UINT64_FORMAT, @@ -348,17 +349,16 @@ IdentifySystem(void) * START_REPLICATION */ static void -StartReplication(StartReplicationCmd * cmd) +StartReplication(StartReplicationCmd *cmd) { StringInfoData buf; /* - * Let postmaster know that we're streaming. Once we've declared us as - * a WAL sender process, postmaster will let us outlive the bgwriter and - * kill us last in the shutdown sequence, so we get a chance to stream - * all remaining WAL at shutdown, including the shutdown checkpoint. - * Note that there's no going back, and we mustn't write any WAL records - * after this. + * Let postmaster know that we're streaming. Once we've declared us as a + * WAL sender process, postmaster will let us outlive the bgwriter and + * kill us last in the shutdown sequence, so we get a chance to stream all + * remaining WAL at shutdown, including the shutdown checkpoint. Note that + * there's no going back, and we mustn't write any WAL records after this. */ MarkPostmasterChildWalSender(); SendPostmasterSignal(PMSIGNAL_ADVANCE_STATE_MACHINE); @@ -383,8 +383,8 @@ StartReplication(StartReplicationCmd * cmd) * For some applications, for example, synchronous replication, it is * important to have a clear state for this initial catchup mode, so we * can trigger actions when we change streaming state later. We may stay - * in this state for a long time, which is exactly why we want to be - * able to monitor whether or not we are still here. + * in this state for a long time, which is exactly why we want to be able + * to monitor whether or not we are still here. */ WalSndSetState(WALSNDSTATE_CATCHUP); @@ -476,7 +476,7 @@ ProcessRepliesIfAny(void) { unsigned char firstchar; int r; - int received = false; + int received = false; for (;;) { @@ -519,9 +519,9 @@ ProcessRepliesIfAny(void) firstchar))); } } + /* - * Save the last reply timestamp if we've received at least - * one reply. + * Save the last reply timestamp if we've received at least one reply. */ if (received) last_reply_timestamp = GetCurrentTimestamp(); @@ -533,7 +533,7 @@ ProcessRepliesIfAny(void) static void ProcessStandbyMessage(void) { - char msgtype; + char msgtype; resetStringInfo(&reply_message); @@ -577,7 +577,7 @@ ProcessStandbyMessage(void) static void ProcessStandbyReplyMessage(void) { - StandbyReplyMessage reply; + StandbyReplyMessage reply; pq_copymsgbytes(&reply_message, (char *) &reply, sizeof(StandbyReplyMessage)); @@ -587,8 +587,8 @@ ProcessStandbyReplyMessage(void) reply.apply.xlogid, reply.apply.xrecoff); /* - * Update shared state for this WalSender process - * based on reply data from standby. + * Update shared state for this WalSender process based on reply data from + * standby. */ { /* use volatile pointer to prevent code rearrangement */ @@ -610,7 +610,7 @@ ProcessStandbyReplyMessage(void) static void ProcessStandbyHSFeedbackMessage(void) { - StandbyHSFeedbackMessage reply; + StandbyHSFeedbackMessage reply; TransactionId newxmin = InvalidTransactionId; pq_copymsgbytes(&reply_message, (char *) &reply, sizeof(StandbyHSFeedbackMessage)); @@ -620,22 +620,21 @@ ProcessStandbyHSFeedbackMessage(void) reply.epoch); /* - * Update the WalSender's proc xmin to allow it to be visible - * to snapshots. This will hold back the removal of dead rows - * and thereby prevent the generation of cleanup conflicts - * on the standby server. + * Update the WalSender's proc xmin to allow it to be visible to + * snapshots. This will hold back the removal of dead rows and thereby + * prevent the generation of cleanup conflicts on the standby server. */ if (TransactionIdIsValid(reply.xmin)) { - TransactionId nextXid; - uint32 nextEpoch; - bool epochOK = false; + TransactionId nextXid; + uint32 nextEpoch; + bool epochOK = false; GetNextXidAndEpoch(&nextXid, &nextEpoch); /* - * Epoch of oldestXmin should be same as standby or - * if the counter has wrapped, then one less than reply. + * Epoch of oldestXmin should be same as standby or if the counter has + * wrapped, then one less than reply. */ if (reply.xmin <= nextXid) { @@ -657,6 +656,7 @@ ProcessStandbyHSFeedbackMessage(void) if (!TransactionIdIsValid(MyProc->xmin)) { TransactionId oldestXmin = GetOldestXmin(true, true); + if (TransactionIdPrecedes(oldestXmin, reply.xmin)) newxmin = reply.xmin; else @@ -667,7 +667,7 @@ ProcessStandbyHSFeedbackMessage(void) if (TransactionIdPrecedes(MyProc->xmin, reply.xmin)) newxmin = reply.xmin; else - newxmin = MyProc->xmin; /* stay the same */ + newxmin = MyProc->xmin; /* stay the same */ } } } @@ -735,8 +735,8 @@ WalSndLoop(void) } /* - * If we don't have any pending data in the output buffer, try to - * send some more. + * If we don't have any pending data in the output buffer, try to send + * some more. */ if (!pq_is_send_pending()) { @@ -746,8 +746,8 @@ WalSndLoop(void) * Even if we wrote all the WAL that was available when we started * sending, more might have arrived while we were sending this * batch. We had the latch set while sending, so we have not - * received any signals from that time. Let's arm the latch - * again, and after that check that we're still up-to-date. + * received any signals from that time. Let's arm the latch again, + * and after that check that we're still up-to-date. */ if (caughtup && !pq_is_send_pending()) { @@ -777,17 +777,17 @@ WalSndLoop(void) !got_SIGHUP && !walsender_shutdown_requested) { - TimestampTz finish_time = 0; + TimestampTz finish_time = 0; long sleeptime; /* Reschedule replication timeout */ if (replication_timeout > 0) { long secs; - int usecs; + int usecs; finish_time = TimestampTzPlusMilliseconds(last_reply_timestamp, - replication_timeout); + replication_timeout); TimestampDifference(GetCurrentTimestamp(), finish_time, &secs, &usecs); sleeptime = secs * 1000 + usecs / 1000; @@ -815,8 +815,8 @@ WalSndLoop(void) { /* * Since typically expiration of replication timeout means - * communication problem, we don't send the error message - * to the standby. + * communication problem, we don't send the error message to + * the standby. */ ereport(COMMERROR, (errmsg("terminating walsender process due to replication timeout"))); @@ -829,14 +829,14 @@ WalSndLoop(void) * This is an important state change for users, since before this * point data loss might occur if the primary dies and we need to * failover to the standby. The state change is also important for - * synchronous replication, since commits that started to wait at - * that point might wait for some time. + * synchronous replication, since commits that started to wait at that + * point might wait for some time. */ if (MyWalSnd->state == WALSNDSTATE_CATCHUP && caughtup) { ereport(DEBUG1, (errmsg("standby \"%s\" has now caught up with primary", - application_name))); + application_name))); WalSndSetState(WALSNDSTATE_STREAMING); } @@ -1317,7 +1317,7 @@ WalSndShmemInit(void) void WalSndWakeup(void) { - int i; + int i; for (i = 0; i < max_wal_senders; i++) SetLatch(&WalSndCtl->walsnds[i].latch); @@ -1369,16 +1369,16 @@ WalSndGetStateString(WalSndState state) Datum pg_stat_get_wal_senders(PG_FUNCTION_ARGS) { -#define PG_STAT_GET_WAL_SENDERS_COLS 8 - ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo; - TupleDesc tupdesc; - Tuplestorestate *tupstore; - MemoryContext per_query_ctx; - MemoryContext oldcontext; - int *sync_priority; - int priority = 0; - int sync_standby = -1; - int i; +#define PG_STAT_GET_WAL_SENDERS_COLS 8 + ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo; + TupleDesc tupdesc; + Tuplestorestate *tupstore; + MemoryContext per_query_ctx; + MemoryContext oldcontext; + int *sync_priority; + int priority = 0; + int sync_standby = -1; + int i; /* check to see if caller supports us returning a tuplestore */ if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo)) @@ -1406,9 +1406,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS) MemoryContextSwitchTo(oldcontext); /* - * Get the priorities of sync standbys all in one go, to minimise - * lock acquisitions and to allow us to evaluate who is the current - * sync standby. This code must match the code in SyncRepReleaseWaiters(). + * Get the priorities of sync standbys all in one go, to minimise lock + * acquisitions and to allow us to evaluate who is the current sync + * standby. This code must match the code in SyncRepReleaseWaiters(). */ sync_priority = palloc(sizeof(int) * max_wal_senders); LWLockAcquire(SyncRepLock, LW_SHARED); @@ -1442,7 +1442,7 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS) XLogRecPtr write; XLogRecPtr flush; XLogRecPtr apply; - WalSndState state; + WalSndState state; Datum values[PG_STAT_GET_WAL_SENDERS_COLS]; bool nulls[PG_STAT_GET_WAL_SENDERS_COLS]; @@ -1463,8 +1463,8 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS) if (!superuser()) { /* - * Only superusers can see details. Other users only get - * the pid value to know it's a walsender, but no details. + * Only superusers can see details. Other users only get the pid + * value to know it's a walsender, but no details. */ MemSet(&nulls[1], true, PG_STAT_GET_WAL_SENDERS_COLS - 1); } @@ -1485,7 +1485,7 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS) if (flush.xlogid == 0 && flush.xrecoff == 0) nulls[4] = true; snprintf(location, sizeof(location), "%X/%X", - flush.xlogid, flush.xrecoff); + flush.xlogid, flush.xrecoff); values[4] = CStringGetTextDatum(location); if (apply.xlogid == 0 && apply.xrecoff == 0) @@ -1497,8 +1497,8 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS) values[6] = Int32GetDatum(sync_priority[i]); /* - * More easily understood version of standby state. - * This is purely informational, not different from priority. + * More easily understood version of standby state. This is purely + * informational, not different from priority. */ if (sync_priority[i] == 0) values[7] = CStringGetTextDatum("ASYNC"); diff --git a/src/backend/rewrite/rewriteDefine.c b/src/backend/rewrite/rewriteDefine.c index a405dbfe8ee..c1b97d141eb 100644 --- a/src/backend/rewrite/rewriteDefine.c +++ b/src/backend/rewrite/rewriteDefine.c @@ -241,9 +241,9 @@ DefineQueryRewrite(char *rulename, /* * If we are installing an ON SELECT rule, we had better grab * AccessExclusiveLock to ensure no SELECTs are currently running on the - * event relation. For other types of rules, it is sufficient to - * grab ShareRowExclusiveLock to lock out insert/update/delete actions - * and to ensure that we lock out current CREATE RULE statements. + * event relation. For other types of rules, it is sufficient to grab + * ShareRowExclusiveLock to lock out insert/update/delete actions and to + * ensure that we lock out current CREATE RULE statements. */ if (event_type == CMD_SELECT) event_relation = heap_open(event_relid, AccessExclusiveLock); diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c index a695b012399..bfc8fd7ee04 100644 --- a/src/backend/rewrite/rewriteHandler.c +++ b/src/backend/rewrite/rewriteHandler.c @@ -53,7 +53,7 @@ static Node *get_assignment_input(Node *node); static void rewriteValuesRTE(RangeTblEntry *rte, Relation target_relation, List *attrnos); static void rewriteTargetListUD(Query *parsetree, RangeTblEntry *target_rte, - Relation target_relation); + Relation target_relation); static void markQueryForLocking(Query *qry, Node *jtnode, bool forUpdate, bool noWait, bool pushedDown); static List *matchLocks(CmdType event, RuleLock *rulelocks, @@ -743,8 +743,8 @@ rewriteTargetListIU(Query *parsetree, Relation target_relation, } /* - * For an UPDATE on a view, provide a dummy entry whenever there is - * no explicit assignment. + * For an UPDATE on a view, provide a dummy entry whenever there is no + * explicit assignment. */ if (new_tle == NULL && commandType == CMD_UPDATE && target_relation->rd_rel->relkind == RELKIND_VIEW) @@ -1112,7 +1112,7 @@ rewriteValuesRTE(RangeTblEntry *rte, Relation target_relation, List *attrnos) * rewriteTargetListUD - rewrite UPDATE/DELETE targetlist as needed * * This function adds a "junk" TLE that is needed to allow the executor to - * find the original row for the update or delete. When the target relation + * find the original row for the update or delete. When the target relation * is a regular table, the junk TLE emits the ctid attribute of the original * row. When the target relation is a view, there is no ctid, so we instead * emit a whole-row Var that will contain the "old" values of the view row. @@ -1145,8 +1145,8 @@ rewriteTargetListUD(Query *parsetree, RangeTblEntry *target_rte, else { /* - * Emit whole-row Var so that executor will have the "old" view row - * to pass to the INSTEAD OF trigger. + * Emit whole-row Var so that executor will have the "old" view row to + * pass to the INSTEAD OF trigger. */ var = makeWholeRowVar(target_rte, parsetree->resultRelation, @@ -1267,11 +1267,11 @@ ApplyRetrieveRule(Query *parsetree, * fine as the result relation. * * For UPDATE/DELETE, we need to expand the view so as to have source - * data for the operation. But we also need an unmodified RTE to + * data for the operation. But we also need an unmodified RTE to * serve as the target. So, copy the RTE and add the copy to the - * rangetable. Note that the copy does not get added to the jointree. - * Also note that there's a hack in fireRIRrules to avoid calling - * this function again when it arrives at the copied RTE. + * rangetable. Note that the copy does not get added to the jointree. + * Also note that there's a hack in fireRIRrules to avoid calling this + * function again when it arrives at the copied RTE. */ if (parsetree->commandType == CMD_INSERT) return parsetree; @@ -1286,9 +1286,9 @@ ApplyRetrieveRule(Query *parsetree, parsetree->resultRelation = list_length(parsetree->rtable); /* - * There's no need to do permissions checks twice, so wipe out - * the permissions info for the original RTE (we prefer to keep - * the bits set on the result RTE). + * There's no need to do permissions checks twice, so wipe out the + * permissions info for the original RTE (we prefer to keep the + * bits set on the result RTE). */ rte->requiredPerms = 0; rte->checkAsUser = InvalidOid; @@ -1988,9 +1988,9 @@ RewriteQuery(Query *parsetree, List *rewrite_events) */ foreach(lc1, parsetree->cteList) { - CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc1); - Query *ctequery = (Query *) cte->ctequery; - List *newstuff; + CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc1); + Query *ctequery = (Query *) cte->ctequery; + List *newstuff; Assert(IsA(ctequery, Query)); @@ -2021,12 +2021,12 @@ RewriteQuery(Query *parsetree, List *rewrite_events) } else { - ListCell *lc2; + ListCell *lc2; /* examine queries to determine which error message to issue */ foreach(lc2, newstuff) { - Query *q = (Query *) lfirst(lc2); + Query *q = (Query *) lfirst(lc2); if (q->querySource == QSRC_QUAL_INSTEAD_RULE) ereport(ERROR, diff --git a/src/backend/rewrite/rewriteSupport.c b/src/backend/rewrite/rewriteSupport.c index 9feed7345eb..7770d032b1e 100644 --- a/src/backend/rewrite/rewriteSupport.c +++ b/src/backend/rewrite/rewriteSupport.c @@ -127,7 +127,7 @@ get_rewrite_oid(Oid relid, const char *rulename, bool missing_ok) * Find rule oid, given only a rule name but no rel OID. * * If there's more than one, it's an error. If there aren't any, that's an - * error, too. In general, this should be avoided - it is provided to support + * error, too. In general, this should be avoided - it is provided to support * syntax that is compatible with pre-7.3 versions of PG, where rule names * were unique across the entire database. */ diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c index 1f89e527056..f96685db50b 100644 --- a/src/backend/storage/buffer/bufmgr.c +++ b/src/backend/storage/buffer/bufmgr.c @@ -644,17 +644,17 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum, /* OK, do the I/O */ TRACE_POSTGRESQL_BUFFER_WRITE_DIRTY_START(forkNum, blockNum, - smgr->smgr_rnode.node.spcNode, - smgr->smgr_rnode.node.dbNode, - smgr->smgr_rnode.node.relNode); + smgr->smgr_rnode.node.spcNode, + smgr->smgr_rnode.node.dbNode, + smgr->smgr_rnode.node.relNode); FlushBuffer(buf, NULL); LWLockRelease(buf->content_lock); TRACE_POSTGRESQL_BUFFER_WRITE_DIRTY_DONE(forkNum, blockNum, - smgr->smgr_rnode.node.spcNode, - smgr->smgr_rnode.node.dbNode, - smgr->smgr_rnode.node.relNode); + smgr->smgr_rnode.node.spcNode, + smgr->smgr_rnode.node.dbNode, + smgr->smgr_rnode.node.relNode); } else { @@ -2029,7 +2029,7 @@ PrintBufferDescs(void) "[%02d] (freeNext=%d, rel=%s, " "blockNum=%u, flags=0x%x, refcount=%u %d)", i, buf->freeNext, - relpathbackend(buf->tag.rnode, InvalidBackendId, buf->tag.forkNum), + relpathbackend(buf->tag.rnode, InvalidBackendId, buf->tag.forkNum), buf->tag.blockNum, buf->flags, buf->refcount, PrivateRefCount[i]); } @@ -2765,7 +2765,7 @@ local_buffer_write_error_callback(void *arg) if (bufHdr != NULL) { char *path = relpathbackend(bufHdr->tag.rnode, MyBackendId, - bufHdr->tag.forkNum); + bufHdr->tag.forkNum); errcontext("writing block %u of relation %s", bufHdr->tag.blockNum, path); diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 72968db026c..bf9903b9f32 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -77,7 +77,7 @@ typedef struct BufferAccessStrategyData * struct. */ Buffer buffers[1]; /* VARIABLE SIZE ARRAY */ -} BufferAccessStrategyData; +} BufferAccessStrategyData; /* Prototypes for internal functions */ diff --git a/src/backend/storage/buffer/localbuf.c b/src/backend/storage/buffer/localbuf.c index 0a01ed544e5..8816a5dfab4 100644 --- a/src/backend/storage/buffer/localbuf.c +++ b/src/backend/storage/buffer/localbuf.c @@ -150,8 +150,8 @@ LocalBufferAlloc(SMgrRelation smgr, ForkNumber forkNum, BlockNumber blockNum, #ifdef LBDEBUG fprintf(stderr, "LB ALLOC (%u,%d,%d) %d\n", - smgr->smgr_rnode.node.relNode, forkNum, blockNum, - -nextFreeLocalBuf - 1); + smgr->smgr_rnode.node.relNode, forkNum, blockNum, + -nextFreeLocalBuf - 1); #endif /* @@ -311,7 +311,7 @@ DropRelFileNodeLocalBuffers(RelFileNode rnode, ForkNumber forkNum, elog(ERROR, "block %u of %s is still referenced (local %u)", bufHdr->tag.blockNum, relpathbackend(bufHdr->tag.rnode, MyBackendId, - bufHdr->tag.forkNum), + bufHdr->tag.forkNum), LocalRefCount[i]); /* Remove entry from hashtable */ hresult = (LocalBufferLookupEnt *) @@ -413,7 +413,7 @@ GetLocalBufferStorage(void) /* * We allocate local buffers in a context of their own, so that the * space eaten for them is easily recognizable in MemoryContextStats - * output. Create the context on first use. + * output. Create the context on first use. */ if (LocalBufferContext == NULL) LocalBufferContext = diff --git a/src/backend/storage/file/fd.c b/src/backend/storage/file/fd.c index bdb97b2ad11..11bab38280e 100644 --- a/src/backend/storage/file/fd.c +++ b/src/backend/storage/file/fd.c @@ -1063,15 +1063,15 @@ FileClose(File file) * If we get an error, as could happen within the ereport/elog calls, * we'll come right back here during transaction abort. Reset the * flag to ensure that we can't get into an infinite loop. This code - * is arranged to ensure that the worst-case consequence is failing - * to emit log message(s), not failing to attempt the unlink. + * is arranged to ensure that the worst-case consequence is failing to + * emit log message(s), not failing to attempt the unlink. */ vfdP->fdstate &= ~FD_TEMPORARY; if (log_temp_files >= 0) { struct stat filestats; - int stat_errno; + int stat_errno; /* first try the stat() */ if (stat(vfdP->fileName, &filestats)) @@ -1900,7 +1900,7 @@ RemovePgTempFiles(void) RemovePgTempFilesInDir(temp_path); snprintf(temp_path, sizeof(temp_path), "pg_tblspc/%s/%s", - spc_de->d_name, TABLESPACE_VERSION_DIRECTORY); + spc_de->d_name, TABLESPACE_VERSION_DIRECTORY); RemovePgTempRelationFiles(temp_path); } @@ -1977,7 +1977,7 @@ RemovePgTempRelationFiles(const char *tsdirname) while ((de = ReadDir(ts_dir, tsdirname)) != NULL) { - int i = 0; + int i = 0; /* * We're only interested in the per-database directories, which have @@ -2023,7 +2023,7 @@ RemovePgTempRelationFilesInDbspace(const char *dbspacedirname) snprintf(rm_path, sizeof(rm_path), "%s/%s", dbspacedirname, de->d_name); - unlink(rm_path); /* note we ignore any error */ + unlink(rm_path); /* note we ignore any error */ } FreeDir(dbspace_dir); @@ -2055,15 +2055,17 @@ looks_like_temp_rel_name(const char *name) /* We might have _forkname or .segment or both. */ if (name[pos] == '_') { - int forkchar = forkname_chars(&name[pos+1], NULL); + int forkchar = forkname_chars(&name[pos + 1], NULL); + if (forkchar <= 0) return false; pos += forkchar + 1; } if (name[pos] == '.') { - int segchar; - for (segchar = 1; isdigit((unsigned char) name[pos+segchar]); ++segchar) + int segchar; + + for (segchar = 1; isdigit((unsigned char) name[pos + segchar]); ++segchar) ; if (segchar <= 1) return false; diff --git a/src/backend/storage/file/reinit.c b/src/backend/storage/file/reinit.c index 54fde73de8e..837ab90c8d8 100644 --- a/src/backend/storage/file/reinit.c +++ b/src/backend/storage/file/reinit.c @@ -24,14 +24,15 @@ #include "utils/memutils.h" static void ResetUnloggedRelationsInTablespaceDir(const char *tsdirname, - int op); + int op); static void ResetUnloggedRelationsInDbspaceDir(const char *dbspacedirname, int op); static bool parse_filename_for_nontemp_relation(const char *name, int *oidchars, ForkNumber *fork); -typedef struct { - char oid[OIDCHARS+1]; +typedef struct +{ + char oid[OIDCHARS + 1]; } unlogged_relation_entry; /* @@ -49,13 +50,14 @@ ResetUnloggedRelations(int op) char temp_path[MAXPGPATH]; DIR *spc_dir; struct dirent *spc_de; - MemoryContext tmpctx, oldctx; + MemoryContext tmpctx, + oldctx; /* Log it. */ ereport(DEBUG1, (errmsg("resetting unlogged relations: cleanup %d init %d", - (op & UNLOGGED_RELATION_CLEANUP) != 0, - (op & UNLOGGED_RELATION_INIT) != 0))); + (op & UNLOGGED_RELATION_CLEANUP) != 0, + (op & UNLOGGED_RELATION_INIT) != 0))); /* * Just to be sure we don't leak any memory, let's create a temporary @@ -85,7 +87,7 @@ ResetUnloggedRelations(int op) continue; snprintf(temp_path, sizeof(temp_path), "pg_tblspc/%s/%s", - spc_de->d_name, TABLESPACE_VERSION_DIRECTORY); + spc_de->d_name, TABLESPACE_VERSION_DIRECTORY); ResetUnloggedRelationsInTablespaceDir(temp_path, op); } @@ -119,7 +121,7 @@ ResetUnloggedRelationsInTablespaceDir(const char *tsdirname, int op) while ((de = ReadDir(ts_dir, tsdirname)) != NULL) { - int i = 0; + int i = 0; /* * We're only interested in the per-database directories, which have @@ -184,8 +186,8 @@ ResetUnloggedRelationsInDbspaceDir(const char *dbspacedirname, int op) /* Scan the directory. */ while ((de = ReadDir(dbspace_dir, dbspacedirname)) != NULL) { - ForkNumber forkNum; - int oidchars; + ForkNumber forkNum; + int oidchars; unlogged_relation_entry ent; /* Skip anything that doesn't look like a relation data file. */ @@ -198,8 +200,8 @@ ResetUnloggedRelationsInDbspaceDir(const char *dbspacedirname, int op) continue; /* - * Put the OID portion of the name into the hash table, if it isn't - * already. + * Put the OID portion of the name into the hash table, if it + * isn't already. */ memset(ent.oid, 0, sizeof(ent.oid)); memcpy(ent.oid, de->d_name, oidchars); @@ -236,9 +238,9 @@ ResetUnloggedRelationsInDbspaceDir(const char *dbspacedirname, int op) /* Scan the directory. */ while ((de = ReadDir(dbspace_dir, dbspacedirname)) != NULL) { - ForkNumber forkNum; - int oidchars; - bool found; + ForkNumber forkNum; + int oidchars; + bool found; unlogged_relation_entry ent; /* Skip anything that doesn't look like a relation data file. */ @@ -262,7 +264,8 @@ ResetUnloggedRelationsInDbspaceDir(const char *dbspacedirname, int op) if (found) { snprintf(rm_path, sizeof(rm_path), "%s/%s", - dbspacedirname, de->d_name); + dbspacedirname, de->d_name); + /* * It's tempting to actually throw an error here, but since * this code gets run during database startup, that could @@ -284,9 +287,9 @@ ResetUnloggedRelationsInDbspaceDir(const char *dbspacedirname, int op) /* * Initialization happens after cleanup is complete: we copy each init * fork file to the corresponding main fork file. Note that if we are - * asked to do both cleanup and init, we may never get here: if the cleanup - * code determines that there are no init forks in this dbspace, it will - * return before we get to this point. + * asked to do both cleanup and init, we may never get here: if the + * cleanup code determines that there are no init forks in this dbspace, + * it will return before we get to this point. */ if ((op & UNLOGGED_RELATION_INIT) != 0) { @@ -304,11 +307,11 @@ ResetUnloggedRelationsInDbspaceDir(const char *dbspacedirname, int op) /* Scan the directory. */ while ((de = ReadDir(dbspace_dir, dbspacedirname)) != NULL) { - ForkNumber forkNum; - int oidchars; - char oidbuf[OIDCHARS+1]; - char srcpath[MAXPGPATH]; - char dstpath[MAXPGPATH]; + ForkNumber forkNum; + int oidchars; + char oidbuf[OIDCHARS + 1]; + char srcpath[MAXPGPATH]; + char dstpath[MAXPGPATH]; /* Skip anything that doesn't look like a relation data file. */ if (!parse_filename_for_nontemp_relation(de->d_name, &oidchars, @@ -370,9 +373,9 @@ parse_filename_for_nontemp_relation(const char *name, int *oidchars, *fork = MAIN_FORKNUM; else { - int forkchar; + int forkchar; - forkchar = forkname_chars(&name[pos+1], fork); + forkchar = forkname_chars(&name[pos + 1], fork); if (forkchar <= 0) return false; pos += forkchar + 1; @@ -381,8 +384,9 @@ parse_filename_for_nontemp_relation(const char *name, int *oidchars, /* Check for a segment number. */ if (name[pos] == '.') { - int segchar; - for (segchar = 1; isdigit((unsigned char) name[pos+segchar]); ++segchar) + int segchar; + + for (segchar = 1; isdigit((unsigned char) name[pos + segchar]); ++segchar) ; if (segchar <= 1) return false; diff --git a/src/backend/storage/ipc/pmsignal.c b/src/backend/storage/ipc/pmsignal.c index 391d6a6ea04..306e3f9a216 100644 --- a/src/backend/storage/ipc/pmsignal.c +++ b/src/backend/storage/ipc/pmsignal.c @@ -279,7 +279,7 @@ PostmasterIsAlive(bool amDirectChild) #ifndef WIN32 if (amDirectChild) { - pid_t ppid = getppid(); + pid_t ppid = getppid(); /* If the postmaster is still our parent, it must be alive. */ if (ppid == PostmasterPid) @@ -297,10 +297,10 @@ PostmasterIsAlive(bool amDirectChild) } /* - * Use kill() to see if the postmaster is still alive. This can - * sometimes give a false positive result, since the postmaster's PID - * may get recycled, but it is good enough for existing uses by - * indirect children and in debugging environments. + * Use kill() to see if the postmaster is still alive. This can sometimes + * give a false positive result, since the postmaster's PID may get + * recycled, but it is good enough for existing uses by indirect children + * and in debugging environments. */ return (kill(PostmasterPid, 0) == 0); #else /* WIN32 */ diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c index 65fca7171a4..e7593fa2ebe 100644 --- a/src/backend/storage/ipc/procarray.c +++ b/src/backend/storage/ipc/procarray.c @@ -475,10 +475,10 @@ ProcArrayApplyRecoveryInfo(RunningTransactions running) return; /* - * If our initial RunningTransactionsData had an overflowed snapshot then we knew - * we were missing some subxids from our snapshot. We can use this data as - * an initial snapshot, but we cannot yet mark it valid. We know that the - * missing subxids are equal to or earlier than nextXid. After we + * If our initial RunningTransactionsData had an overflowed snapshot then + * we knew we were missing some subxids from our snapshot. We can use this + * data as an initial snapshot, but we cannot yet mark it valid. We know + * that the missing subxids are equal to or earlier than nextXid. After we * initialise we continue to apply changes during recovery, so once the * oldestRunningXid is later than the nextXid from the initial snapshot we * know that we no longer have missing information and can mark the @@ -510,8 +510,8 @@ ProcArrayApplyRecoveryInfo(RunningTransactions running) */ /* - * Release any locks belonging to old transactions that are not - * running according to the running-xacts record. + * Release any locks belonging to old transactions that are not running + * according to the running-xacts record. */ StandbyReleaseOldLocks(running->nextXid); @@ -582,9 +582,8 @@ ProcArrayApplyRecoveryInfo(RunningTransactions running) * Now we've got the running xids we need to set the global values that * are used to track snapshots as they evolve further. * - * - latestCompletedXid which will be the xmax for snapshots - * - lastOverflowedXid which shows whether snapshots overflow - * - nextXid + * - latestCompletedXid which will be the xmax for snapshots - + * lastOverflowedXid which shows whether snapshots overflow - nextXid * * If the snapshot overflowed, then we still initialise with what we know, * but the recovery snapshot isn't fully valid yet because we know there @@ -611,9 +610,8 @@ ProcArrayApplyRecoveryInfo(RunningTransactions running) /* * If a transaction wrote a commit record in the gap between taking and - * logging the snapshot then latestCompletedXid may already be higher - * than the value from the snapshot, so check before we use the incoming - * value. + * logging the snapshot then latestCompletedXid may already be higher than + * the value from the snapshot, so check before we use the incoming value. */ if (TransactionIdPrecedes(ShmemVariableCache->latestCompletedXid, running->latestCompletedXid)) @@ -1048,7 +1046,7 @@ GetOldestXmin(bool allDbs, bool ignoreVacuum) if (allDbs || proc->databaseId == MyDatabaseId || - proc->databaseId == 0) /* include WalSender */ + proc->databaseId == 0) /* include WalSender */ { /* Fetch xid just once - see GetNewTransactionId */ TransactionId xid = proc->xid; @@ -1075,8 +1073,8 @@ GetOldestXmin(bool allDbs, bool ignoreVacuum) if (RecoveryInProgress()) { /* - * Check to see whether KnownAssignedXids contains an xid value - * older than the main procarray. + * Check to see whether KnownAssignedXids contains an xid value older + * than the main procarray. */ TransactionId kaxmin = KnownAssignedXidsGetOldestXmin(); @@ -1084,7 +1082,7 @@ GetOldestXmin(bool allDbs, bool ignoreVacuum) if (TransactionIdIsNormal(kaxmin) && TransactionIdPrecedes(kaxmin, result)) - result = kaxmin; + result = kaxmin; } else { @@ -1100,9 +1098,9 @@ GetOldestXmin(bool allDbs, bool ignoreVacuum) * vacuum_defer_cleanup_age provides some additional "slop" for the * benefit of hot standby queries on slave servers. This is quick and * dirty, and perhaps not all that useful unless the master has a - * predictable transaction rate, but it's what we've got. Note that we - * are assuming vacuum_defer_cleanup_age isn't large enough to cause - * wraparound --- so guc.c should limit it to no more than the + * predictable transaction rate, but it's what we've got. Note that + * we are assuming vacuum_defer_cleanup_age isn't large enough to + * cause wraparound --- so guc.c should limit it to no more than the * xidStopLimit threshold in varsup.c. */ result -= vacuum_defer_cleanup_age; @@ -1483,9 +1481,9 @@ GetRunningTransactionData(void) suboverflowed = true; /* - * Top-level XID of a transaction is always less than any of - * its subxids, so we don't need to check if any of the subxids - * are smaller than oldestRunningXid + * Top-level XID of a transaction is always less than any of its + * subxids, so we don't need to check if any of the subxids are + * smaller than oldestRunningXid */ } } diff --git a/src/backend/storage/ipc/standby.c b/src/backend/storage/ipc/standby.c index 2e71484126d..3fdb5184a94 100644 --- a/src/backend/storage/ipc/standby.c +++ b/src/backend/storage/ipc/standby.c @@ -193,7 +193,7 @@ ResolveRecoveryConflictWithVirtualXIDs(VirtualTransactionId *waitlist, return; waitStart = GetCurrentTimestamp(); - new_status = NULL; /* we haven't changed the ps display */ + new_status = NULL; /* we haven't changed the ps display */ while (VirtualTransactionIdIsValid(*waitlist)) { @@ -963,14 +963,14 @@ void LogAccessExclusiveLockPrepare(void) { /* - * Ensure that a TransactionId has been assigned to this transaction, - * for two reasons, both related to lock release on the standby. - * First, we must assign an xid so that RecordTransactionCommit() and + * Ensure that a TransactionId has been assigned to this transaction, for + * two reasons, both related to lock release on the standby. First, we + * must assign an xid so that RecordTransactionCommit() and * RecordTransactionAbort() do not optimise away the transaction - * completion record which recovery relies upon to release locks. It's - * a hack, but for a corner case not worth adding code for into the - * main commit path. Second, must must assign an xid before the lock - * is recorded in shared memory, otherwise a concurrently executing + * completion record which recovery relies upon to release locks. It's a + * hack, but for a corner case not worth adding code for into the main + * commit path. Second, must must assign an xid before the lock is + * recorded in shared memory, otherwise a concurrently executing * GetRunningTransactionLocks() might see a lock associated with an * InvalidTransactionId which we later assert cannot happen. */ diff --git a/src/backend/storage/large_object/inv_api.c b/src/backend/storage/large_object/inv_api.c index 01e3492cb83..e0441f5bf1c 100644 --- a/src/backend/storage/large_object/inv_api.c +++ b/src/backend/storage/large_object/inv_api.c @@ -844,8 +844,8 @@ inv_truncate(LargeObjectDesc *obj_desc, int len) { /* * If the first page we found was after the truncation point, we're in - * a hole that we'll fill, but we need to delete the later page because - * the loop below won't visit it again. + * a hole that we'll fill, but we need to delete the later page + * because the loop below won't visit it again. */ if (olddata != NULL) { diff --git a/src/backend/storage/lmgr/lock.c b/src/backend/storage/lmgr/lock.c index ed0ea1205f4..3fbe14a4090 100644 --- a/src/backend/storage/lmgr/lock.c +++ b/src/backend/storage/lmgr/lock.c @@ -586,7 +586,8 @@ LockAcquireExtended(const LOCKTAG *locktag, * standby server. Only AccessExclusiveLocks can conflict with lock types * that read-only transactions can acquire in a standby server. * - * Make sure this definition matches the one in GetRunningTransactionLocks(). + * Make sure this definition matches the one in + * GetRunningTransactionLocks(). * * First we prepare to log, then after lock acquired we issue log record. */ diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c index 7978bef996d..72385c2f3eb 100644 --- a/src/backend/storage/lmgr/predicate.c +++ b/src/backend/storage/lmgr/predicate.c @@ -327,7 +327,7 @@ typedef struct OldSerXidControlData TransactionId headXid; /* newest valid Xid in the SLRU */ TransactionId tailXid; /* oldest xmin we might be interested in */ bool warningIssued; -} OldSerXidControlData; +} OldSerXidControlData; typedef struct OldSerXidControlData *OldSerXidControl; @@ -477,7 +477,7 @@ ReleasePredXact(SERIALIZABLEXACT *sxact) ptle = (PredXactListElement) (((char *) sxact) - offsetof(PredXactListElementData, sxact) - +offsetof(PredXactListElementData, link)); + + offsetof(PredXactListElementData, link)); SHMQueueDelete(&ptle->link); SHMQueueInsertBefore(&PredXact->availableList, &ptle->link); } @@ -507,7 +507,7 @@ NextPredXact(SERIALIZABLEXACT *sxact) ptle = (PredXactListElement) (((char *) sxact) - offsetof(PredXactListElementData, sxact) - +offsetof(PredXactListElementData, link)); + + offsetof(PredXactListElementData, link)); ptle = (PredXactListElement) SHMQueueNext(&PredXact->activeList, &ptle->link, @@ -746,10 +746,10 @@ OldSerXidAdd(TransactionId xid, SerCommitSeqNo minConflictCommitSeqNo) Assert(TransactionIdIsValid(tailXid)); /* - * If the SLRU is currently unused, zero out the whole active region - * from tailXid to headXid before taking it into use. Otherwise zero - * out only any new pages that enter the tailXid-headXid range as we - * advance headXid. + * If the SLRU is currently unused, zero out the whole active region from + * tailXid to headXid before taking it into use. Otherwise zero out only + * any new pages that enter the tailXid-headXid range as we advance + * headXid. */ if (oldSerXidControl->headPage < 0) { @@ -855,8 +855,8 @@ OldSerXidSetActiveSerXmin(TransactionId xid) /* * When no sxacts are active, nothing overlaps, set the xid values to * invalid to show that there are no valid entries. Don't clear headPage, - * though. A new xmin might still land on that page, and we don't want - * to repeatedly zero out the same page. + * though. A new xmin might still land on that page, and we don't want to + * repeatedly zero out the same page. */ if (!TransactionIdIsValid(xid)) { @@ -901,7 +901,7 @@ OldSerXidSetActiveSerXmin(TransactionId xid) void CheckPointPredicate(void) { - int tailPage; + int tailPage; LWLockAcquire(OldSerXidLock, LW_EXCLUSIVE); @@ -921,16 +921,15 @@ CheckPointPredicate(void) { /* * The SLRU is no longer needed. Truncate everything. If we try to - * leave the head page around to avoid re-zeroing it, we might not - * use the SLRU again until we're past the wrap-around point, which - * makes SLRU unhappy. + * leave the head page around to avoid re-zeroing it, we might not use + * the SLRU again until we're past the wrap-around point, which makes + * SLRU unhappy. * * While the API asks you to specify truncation by page, it silently - * ignores the request unless the specified page is in a segment - * past some allocated portion of the SLRU. We don't care which - * page in a later segment we hit, so just add the number of pages - * per segment to the head page to land us *somewhere* in the next - * segment. + * ignores the request unless the specified page is in a segment past + * some allocated portion of the SLRU. We don't care which page in a + * later segment we hit, so just add the number of pages per segment + * to the head page to land us *somewhere* in the next segment. */ tailPage = oldSerXidControl->headPage + SLRU_PAGES_PER_SEGMENT; oldSerXidControl->headPage = -1; @@ -1329,12 +1328,12 @@ SummarizeOldestCommittedSxact(void) /* * This function is only called if there are no sxact slots available. * Some of them must belong to old, already-finished transactions, so - * there should be something in FinishedSerializableTransactions list - * that we can summarize. However, there's a race condition: while we - * were not holding any locks, a transaction might have ended and cleaned - * up all the finished sxact entries already, freeing up their sxact - * slots. In that case, we have nothing to do here. The caller will find - * one of the slots released by the other backend when it retries. + * there should be something in FinishedSerializableTransactions list that + * we can summarize. However, there's a race condition: while we were not + * holding any locks, a transaction might have ended and cleaned up all + * the finished sxact entries already, freeing up their sxact slots. In + * that case, we have nothing to do here. The caller will find one of the + * slots released by the other backend when it retries. */ if (SHMQueueEmpty(FinishedSerializableTransactions)) { @@ -2213,7 +2212,7 @@ PredicateLockTuple(const Relation relation, const HeapTuple tuple) */ if (relation->rd_index == NULL) { - TransactionId myxid; + TransactionId myxid; targetxmin = HeapTupleHeaderGetXmin(tuple->t_data); @@ -2223,6 +2222,7 @@ PredicateLockTuple(const Relation relation, const HeapTuple tuple) if (TransactionIdFollowsOrEquals(targetxmin, TransactionXmin)) { TransactionId xid = SubTransGetTopmostTransaction(targetxmin); + if (TransactionIdEquals(xid, myxid)) { /* We wrote it; we already have a write lock. */ @@ -2272,7 +2272,7 @@ PredicateLockTupleRowVersionLink(const Relation relation, PREDICATELOCKTARGETTAG oldtupletag; PREDICATELOCKTARGETTAG oldpagetag; PREDICATELOCKTARGETTAG newtupletag; - BlockNumber oldblk, + BlockNumber oldblk, newblk; OffsetNumber oldoff, newoff; @@ -2308,10 +2308,10 @@ PredicateLockTupleRowVersionLink(const Relation relation, /* * A page-level lock on the page containing the old tuple counts too. - * Anyone holding a lock on the page is logically holding a lock on - * the old tuple, so we need to acquire a lock on his behalf on the - * new tuple too. However, if the new tuple is on the same page as the - * old one, the old page-level lock already covers the new tuple. + * Anyone holding a lock on the page is logically holding a lock on the + * old tuple, so we need to acquire a lock on his behalf on the new tuple + * too. However, if the new tuple is on the same page as the old one, the + * old page-level lock already covers the new tuple. * * A relation-level lock always covers both tuple versions, so we don't * need to worry about those here. @@ -2668,10 +2668,10 @@ PredicateLockPageSplit(const Relation relation, const BlockNumber oldblkno, /* * Move the locks to the parent. This shouldn't fail. * - * Note that here we are removing locks held by other - * backends, leading to a possible inconsistency in their - * local lock hash table. This is OK because we're replacing - * it with a lock that covers the old one. + * Note that here we are removing locks held by other backends, + * leading to a possible inconsistency in their local lock hash table. + * This is OK because we're replacing it with a lock that covers the + * old one. */ success = TransferPredicateLocksToNewTarget(oldtargettag, newtargettag, @@ -2696,16 +2696,15 @@ PredicateLockPageCombine(const Relation relation, const BlockNumber oldblkno, const BlockNumber newblkno) { /* - * Page combines differ from page splits in that we ought to be - * able to remove the locks on the old page after transferring - * them to the new page, instead of duplicating them. However, - * because we can't edit other backends' local lock tables, - * removing the old lock would leave them with an entry in their - * LocalPredicateLockHash for a lock they're not holding, which - * isn't acceptable. So we wind up having to do the same work as a - * page split, acquiring a lock on the new page and keeping the old - * page locked too. That can lead to some false positives, but - * should be rare in practice. + * Page combines differ from page splits in that we ought to be able to + * remove the locks on the old page after transferring them to the new + * page, instead of duplicating them. However, because we can't edit other + * backends' local lock tables, removing the old lock would leave them + * with an entry in their LocalPredicateLockHash for a lock they're not + * holding, which isn't acceptable. So we wind up having to do the same + * work as a page split, acquiring a lock on the new page and keeping the + * old page locked too. That can lead to some false positives, but should + * be rare in practice. */ PredicateLockPageSplit(relation, oldblkno, newblkno); } @@ -3652,15 +3651,15 @@ CheckTargetForConflictsIn(PREDICATELOCKTARGETTAG *targettag) /* * If we're getting a write lock on the tuple and we're not in a * subtransaction, we don't need a predicate (SIREAD) lock. We - * can't use this optimization within a subtransaction because - * the subtransaction could be rolled back, and we would be left + * can't use this optimization within a subtransaction because the + * subtransaction could be rolled back, and we would be left * without any lock at the top level. - * + * * At this point our transaction already has an ExclusiveRowLock - * on the relation, so we are OK to drop the predicate lock on - * the tuple, if found, without fearing that another write - * against the tuple will occur before the MVCC information - * makes it to the buffer. + * on the relation, so we are OK to drop the predicate lock on the + * tuple, if found, without fearing that another write against the + * tuple will occur before the MVCC information makes it to the + * buffer. */ if (!IsSubTransaction() && GET_PREDICATELOCKTARGETTAG_OFFSET(*targettag)) @@ -3722,8 +3721,8 @@ CheckTargetForConflictsIn(PREDICATELOCKTARGETTAG *targettag) /* * Remove entry in local lock table if it exists and has * no children. It's OK if it doesn't exist; that means - * the lock was transferred to a new target by a - * different backend. + * the lock was transferred to a new target by a different + * backend. */ if (locallock != NULL) { @@ -3733,8 +3732,8 @@ CheckTargetForConflictsIn(PREDICATELOCKTARGETTAG *targettag) { rmlocallock = (LOCALPREDICATELOCK *) hash_search_with_hash_value(LocalPredicateLockHash, - targettag, targettaghash, - HASH_REMOVE, NULL); + targettag, targettaghash, + HASH_REMOVE, NULL); Assert(rmlocallock == locallock); } } @@ -3772,9 +3771,9 @@ CheckTargetForConflictsIn(PREDICATELOCKTARGETTAG *targettag) LWLockAcquire(partitionLock, LW_SHARED); /* - * The list may have been altered by another process - * while we weren't holding the partition lock. Start - * over at the front. + * The list may have been altered by another process while + * we weren't holding the partition lock. Start over at + * the front. */ nextpredlock = (PREDICATELOCK *) SHMQueueNext(&(target->predicateLocks), @@ -3862,8 +3861,8 @@ CheckForSerializableConflictIn(const Relation relation, const HeapTuple tuple, relation->rd_node.dbNode, relation->rd_id, ItemPointerGetBlockNumber(&(tuple->t_data->t_ctid)), - ItemPointerGetOffsetNumber(&(tuple->t_data->t_ctid)), - HeapTupleHeaderGetXmin(tuple->t_data)); + ItemPointerGetOffsetNumber(&(tuple->t_data->t_ctid)), + HeapTupleHeaderGetXmin(tuple->t_data)); CheckTargetForConflictsIn(&targettag); } diff --git a/src/backend/storage/smgr/md.c b/src/backend/storage/smgr/md.c index 9d585b6fea8..6f8866836d6 100644 --- a/src/backend/storage/smgr/md.c +++ b/src/backend/storage/smgr/md.c @@ -938,7 +938,7 @@ mdsync(void) int processed = 0; instr_time sync_start, sync_end, - sync_diff; + sync_diff; uint64 elapsed; uint64 longest = 0; uint64 total_elapsed = 0; @@ -1094,7 +1094,7 @@ mdsync(void) if (seg != NULL && FileSync(seg->mdfd_vfd) >= 0) { - if (log_checkpoints && (! INSTR_TIME_IS_ZERO(sync_start))) + if (log_checkpoints && (!INSTR_TIME_IS_ZERO(sync_start))) { INSTR_TIME_SET_CURRENT(sync_end); sync_diff = sync_end; @@ -1104,8 +1104,8 @@ mdsync(void) longest = elapsed; total_elapsed += elapsed; processed++; - elog(DEBUG1, "checkpoint sync: number=%d file=%s time=%.3f msec", - processed, FilePathName(seg->mdfd_vfd), (double) elapsed / 1000); + elog(DEBUG1, "checkpoint sync: number=%d file=%s time=%.3f msec", + processed, FilePathName(seg->mdfd_vfd), (double) elapsed / 1000); } break; /* success; break out of retry loop */ @@ -1268,7 +1268,7 @@ register_dirty_segment(SMgrRelation reln, ForkNumber forknum, MdfdVec *seg) return; /* passed it off successfully */ ereport(DEBUG1, - (errmsg("could not forward fsync request because request queue is full"))); + (errmsg("could not forward fsync request because request queue is full"))); if (FileSync(seg->mdfd_vfd) < 0) ereport(ERROR, diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c index 82bf2326454..a6610bf4f82 100644 --- a/src/backend/storage/smgr/smgr.c +++ b/src/backend/storage/smgr/smgr.c @@ -48,16 +48,16 @@ typedef struct f_smgr void (*smgr_unlink) (RelFileNodeBackend rnode, ForkNumber forknum, bool isRedo); void (*smgr_extend) (SMgrRelation reln, ForkNumber forknum, - BlockNumber blocknum, char *buffer, bool skipFsync); + BlockNumber blocknum, char *buffer, bool skipFsync); void (*smgr_prefetch) (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum); void (*smgr_read) (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer); void (*smgr_write) (SMgrRelation reln, ForkNumber forknum, - BlockNumber blocknum, char *buffer, bool skipFsync); + BlockNumber blocknum, char *buffer, bool skipFsync); BlockNumber (*smgr_nblocks) (SMgrRelation reln, ForkNumber forknum); void (*smgr_truncate) (SMgrRelation reln, ForkNumber forknum, - BlockNumber nblocks); + BlockNumber nblocks); void (*smgr_immedsync) (SMgrRelation reln, ForkNumber forknum); void (*smgr_pre_ckpt) (void); /* may be NULL */ void (*smgr_sync) (void); /* may be NULL */ diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c index cc7945aeb66..805514b07b4 100644 --- a/src/backend/tcop/postgres.c +++ b/src/backend/tcop/postgres.c @@ -1555,7 +1555,7 @@ exec_bind_message(StringInfo input_message) /* sizeof(ParamListInfoData) includes the first array element */ params = (ParamListInfo) palloc(sizeof(ParamListInfoData) + - (numParams - 1) *sizeof(ParamExternData)); + (numParams - 1) * sizeof(ParamExternData)); /* we have static list of params, so no hooks needed */ params->paramFetch = NULL; params->paramFetchArg = NULL; @@ -2982,17 +2982,16 @@ ia64_get_bsp(void) #ifndef __INTEL_COMPILER /* the ;; is a "stop", seems to be required before fetching BSP */ - __asm__ __volatile__( - ";;\n" - " mov %0=ar.bsp \n" -: "=r"(ret)); + __asm__ __volatile__( + ";;\n" + " mov %0=ar.bsp \n" + : "=r"(ret)); #else - ret = (char *) __getReg(_IA64_REG_AR_BSP); + ret = (char *) __getReg(_IA64_REG_AR_BSP); #endif - return ret; + return ret; } - -#endif /* IA64 */ +#endif /* IA64 */ /* @@ -3035,7 +3034,7 @@ check_stack_depth(void) (errcode(ERRCODE_STATEMENT_TOO_COMPLEX), errmsg("stack depth limit exceeded"), errhint("Increase the configuration parameter \"max_stack_depth\" (currently %dkB), " - "after ensuring the platform's stack depth limit is adequate.", + "after ensuring the platform's stack depth limit is adequate.", max_stack_depth))); } @@ -3057,10 +3056,10 @@ check_stack_depth(void) (errcode(ERRCODE_STATEMENT_TOO_COMPLEX), errmsg("stack depth limit exceeded"), errhint("Increase the configuration parameter \"max_stack_depth\" (currently %dkB), " - "after ensuring the platform's stack depth limit is adequate.", + "after ensuring the platform's stack depth limit is adequate.", max_stack_depth))); } -#endif /* IA64 */ +#endif /* IA64 */ } /* GUC check hook for max_stack_depth */ diff --git a/src/backend/tcop/pquery.c b/src/backend/tcop/pquery.c index 1286edee729..b7649c68fcf 100644 --- a/src/backend/tcop/pquery.c +++ b/src/backend/tcop/pquery.c @@ -248,8 +248,8 @@ ChoosePortalStrategy(List *stmts) /* * PORTAL_ONE_SELECT and PORTAL_UTIL_SELECT need only consider the * single-statement case, since there are no rewrite rules that can add - * auxiliary queries to a SELECT or a utility command. - * PORTAL_ONE_MOD_WITH likewise allows only one top-level statement. + * auxiliary queries to a SELECT or a utility command. PORTAL_ONE_MOD_WITH + * likewise allows only one top-level statement. */ if (list_length(stmts) == 1) { @@ -1158,7 +1158,7 @@ PortalRunUtility(Portal portal, Node *utilityStmt, bool isTopLevel, * list. Transaction control, LOCK, and SET must *not* set a snapshot * since they need to be executable at the start of a transaction-snapshot * mode transaction without freezing a snapshot. By extension we allow - * SHOW not to set a snapshot. The other stmts listed are just efficiency + * SHOW not to set a snapshot. The other stmts listed are just efficiency * hacks. Beware of listing anything that can modify the database --- if, * say, it has to update an index with expressions that invoke * user-defined functions, then it had better have a snapshot. diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c index 8e130962469..b1fd5ec04fe 100644 --- a/src/backend/tcop/utility.c +++ b/src/backend/tcop/utility.c @@ -562,12 +562,12 @@ standard_ProcessUtility(Node *parsetree, /* * Unless "IF NOT EXISTS" was specified and the - * relation already exists, create the pg_foreign_table - * entry. + * relation already exists, create the + * pg_foreign_table entry. */ if (relOid != InvalidOid) CreateForeignTable((CreateForeignTableStmt *) stmt, - relOid); + relOid); } else { @@ -916,6 +916,7 @@ standard_ProcessUtility(Node *parsetree, break; case T_AlterEnumStmt: /* ALTER TYPE (enum) */ + /* * We disallow this in transaction blocks, because we can't cope * with enum OID values getting into indexes and then having their diff --git a/src/backend/tsearch/spell.c b/src/backend/tsearch/spell.c index d4ddcba6315..ecc880f54de 100644 --- a/src/backend/tsearch/spell.c +++ b/src/backend/tsearch/spell.c @@ -74,7 +74,7 @@ NIFinishBuild(IspellDict *Conf) * doesn't need that. The cpalloc and cpalloc0 macros are just documentation * to indicate which allocations actually require zeroing. */ -#define COMPACT_ALLOC_CHUNK 8192 /* must be > aset.c's allocChunkLimit */ +#define COMPACT_ALLOC_CHUNK 8192 /* must be > aset.c's allocChunkLimit */ #define COMPACT_MAX_REQ 1024 /* must be < COMPACT_ALLOC_CHUNK */ static void * diff --git a/src/backend/tsearch/ts_locale.c b/src/backend/tsearch/ts_locale.c index c66f4aa8bfa..b8ae0fe65e0 100644 --- a/src/backend/tsearch/ts_locale.c +++ b/src/backend/tsearch/ts_locale.c @@ -28,7 +28,7 @@ t_isdigit(const char *ptr) { int clen = pg_mblen(ptr); wchar_t character[2]; - Oid collation = DEFAULT_COLLATION_OID; /*TODO*/ + Oid collation = DEFAULT_COLLATION_OID; /* TODO */ if (clen == 1 || lc_ctype_is_c(collation)) return isdigit(TOUCHAR(ptr)); @@ -43,7 +43,7 @@ t_isspace(const char *ptr) { int clen = pg_mblen(ptr); wchar_t character[2]; - Oid collation = DEFAULT_COLLATION_OID; /*TODO*/ + Oid collation = DEFAULT_COLLATION_OID; /* TODO */ if (clen == 1 || lc_ctype_is_c(collation)) return isspace(TOUCHAR(ptr)); @@ -58,7 +58,7 @@ t_isalpha(const char *ptr) { int clen = pg_mblen(ptr); wchar_t character[2]; - Oid collation = DEFAULT_COLLATION_OID; /*TODO*/ + Oid collation = DEFAULT_COLLATION_OID; /* TODO */ if (clen == 1 || lc_ctype_is_c(collation)) return isalpha(TOUCHAR(ptr)); @@ -73,7 +73,7 @@ t_isprint(const char *ptr) { int clen = pg_mblen(ptr); wchar_t character[2]; - Oid collation = DEFAULT_COLLATION_OID; /*TODO*/ + Oid collation = DEFAULT_COLLATION_OID; /* TODO */ if (clen == 1 || lc_ctype_is_c(collation)) return isprint(TOUCHAR(ptr)); @@ -243,8 +243,9 @@ char * lowerstr_with_len(const char *str, int len) { char *out; + #ifdef USE_WIDE_UPPER_LOWER - Oid collation = DEFAULT_COLLATION_OID; /*TODO*/ + Oid collation = DEFAULT_COLLATION_OID; /* TODO */ #endif if (len == 0) diff --git a/src/backend/tsearch/ts_selfuncs.c b/src/backend/tsearch/ts_selfuncs.c index 7f33c16a245..366fa2ebf4c 100644 --- a/src/backend/tsearch/ts_selfuncs.c +++ b/src/backend/tsearch/ts_selfuncs.c @@ -304,9 +304,9 @@ tsquery_opr_selec(QueryItem *item, char *operand, /* * Our strategy is to scan through the MCV list and add up the - * frequencies of the ones that match the prefix, thereby - * assuming that the MCVs are representative of the whole lexeme - * population in this respect. Compare histogram_selectivity(). + * frequencies of the ones that match the prefix, thereby assuming + * that the MCVs are representative of the whole lexeme population + * in this respect. Compare histogram_selectivity(). * * This is only a good plan if we have a pretty fair number of * MCVs available; we set the threshold at 100. If no stats or @@ -401,7 +401,7 @@ tsquery_opr_selec(QueryItem *item, char *operand, default: elog(ERROR, "unrecognized operator: %d", item->qoperator.oper); - selec = 0; /* keep compiler quiet */ + selec = 0; /* keep compiler quiet */ break; } } diff --git a/src/backend/tsearch/wparser_def.c b/src/backend/tsearch/wparser_def.c index 3981a50589d..47d777a3e6a 100644 --- a/src/backend/tsearch/wparser_def.c +++ b/src/backend/tsearch/wparser_def.c @@ -299,16 +299,16 @@ TParserInit(char *str, int len) */ if (prs->charmaxlen > 1) { - Oid collation = DEFAULT_COLLATION_OID; /*TODO*/ - + Oid collation = DEFAULT_COLLATION_OID; /* TODO */ + prs->usewide = true; - if ( lc_ctype_is_c(collation) ) + if (lc_ctype_is_c(collation)) { /* - * char2wchar doesn't work for C-locale and - * sizeof(pg_wchar) could be not equal to sizeof(wchar_t) + * char2wchar doesn't work for C-locale and sizeof(pg_wchar) could + * be not equal to sizeof(wchar_t) */ - prs->pgwstr = (pg_wchar*) palloc(sizeof(pg_wchar) * (prs->lenstr + 1)); + prs->pgwstr = (pg_wchar *) palloc(sizeof(pg_wchar) * (prs->lenstr + 1)); pg_mb2wchar_with_len(prs->str, prs->pgwstr, prs->lenstr); } else @@ -325,10 +325,11 @@ TParserInit(char *str, int len) prs->state->state = TPS_Base; #ifdef WPARSER_TRACE + /* - * Use of %.*s here is a bit risky since it can misbehave if the data - * is not in what libc thinks is the prevailing encoding. However, - * since this is just a debugging aid, we choose to live with that. + * Use of %.*s here is a bit risky since it can misbehave if the data is + * not in what libc thinks is the prevailing encoding. However, since + * this is just a debugging aid, we choose to live with that. */ fprintf(stderr, "parsing \"%.*s\"\n", len, str); #endif @@ -425,11 +426,11 @@ TParserCopyClose(TParser *prs) /* * Character-type support functions, equivalent to is* macros, but * working with any possible encodings and locales. Notes: - * - with multibyte encoding and C-locale isw* function may fail - * or give wrong result. - * - multibyte encoding and C-locale often are used for - * Asian languages. - * - if locale is C the we use pgwstr instead of wstr + * - with multibyte encoding and C-locale isw* function may fail + * or give wrong result. + * - multibyte encoding and C-locale often are used for + * Asian languages. + * - if locale is C the we use pgwstr instead of wstr */ #ifdef USE_WIDE_UPPER_LOWER @@ -447,7 +448,7 @@ p_is##type(TParser *prs) { \ } \ \ return is##type( *(unsigned char*)( prs->str + prs->state->posbyte ) ); \ -} \ +} \ \ static int \ p_isnot##type(TParser *prs) { \ @@ -719,7 +720,7 @@ p_isignore(TParser *prs) static int p_ishost(TParser *prs) { - TParser *tmpprs = TParserCopyInit(prs); + TParser *tmpprs = TParserCopyInit(prs); int res = 0; tmpprs->wanthost = true; @@ -741,7 +742,7 @@ p_ishost(TParser *prs) static int p_isURLPath(TParser *prs) { - TParser *tmpprs = TParserCopyInit(prs); + TParser *tmpprs = TParserCopyInit(prs); int res = 0; tmpprs->state = newTParserPosition(tmpprs->state); @@ -773,269 +774,269 @@ p_isspecial(TParser *prs) /* * pg_dsplen could return -1 which means error or control character */ - if ( pg_dsplen(prs->str + prs->state->posbyte) == 0 ) + if (pg_dsplen(prs->str + prs->state->posbyte) == 0) return 1; #ifdef USE_WIDE_UPPER_LOWER + /* - * Unicode Characters in the 'Mark, Spacing Combining' Category - * That characters are not alpha although they are not breakers - * of word too. - * Check that only in utf encoding, because other encodings - * aren't supported by postgres or even exists. + * Unicode Characters in the 'Mark, Spacing Combining' Category That + * characters are not alpha although they are not breakers of word too. + * Check that only in utf encoding, because other encodings aren't + * supported by postgres or even exists. */ - if ( GetDatabaseEncoding() == PG_UTF8 && prs->usewide ) + if (GetDatabaseEncoding() == PG_UTF8 && prs->usewide) { - static pg_wchar strange_letter[] = { - /* - * use binary search, so elements - * should be ordered - */ - 0x0903, /* DEVANAGARI SIGN VISARGA */ - 0x093E, /* DEVANAGARI VOWEL SIGN AA */ - 0x093F, /* DEVANAGARI VOWEL SIGN I */ - 0x0940, /* DEVANAGARI VOWEL SIGN II */ - 0x0949, /* DEVANAGARI VOWEL SIGN CANDRA O */ - 0x094A, /* DEVANAGARI VOWEL SIGN SHORT O */ - 0x094B, /* DEVANAGARI VOWEL SIGN O */ - 0x094C, /* DEVANAGARI VOWEL SIGN AU */ - 0x0982, /* BENGALI SIGN ANUSVARA */ - 0x0983, /* BENGALI SIGN VISARGA */ - 0x09BE, /* BENGALI VOWEL SIGN AA */ - 0x09BF, /* BENGALI VOWEL SIGN I */ - 0x09C0, /* BENGALI VOWEL SIGN II */ - 0x09C7, /* BENGALI VOWEL SIGN E */ - 0x09C8, /* BENGALI VOWEL SIGN AI */ - 0x09CB, /* BENGALI VOWEL SIGN O */ - 0x09CC, /* BENGALI VOWEL SIGN AU */ - 0x09D7, /* BENGALI AU LENGTH MARK */ - 0x0A03, /* GURMUKHI SIGN VISARGA */ - 0x0A3E, /* GURMUKHI VOWEL SIGN AA */ - 0x0A3F, /* GURMUKHI VOWEL SIGN I */ - 0x0A40, /* GURMUKHI VOWEL SIGN II */ - 0x0A83, /* GUJARATI SIGN VISARGA */ - 0x0ABE, /* GUJARATI VOWEL SIGN AA */ - 0x0ABF, /* GUJARATI VOWEL SIGN I */ - 0x0AC0, /* GUJARATI VOWEL SIGN II */ - 0x0AC9, /* GUJARATI VOWEL SIGN CANDRA O */ - 0x0ACB, /* GUJARATI VOWEL SIGN O */ - 0x0ACC, /* GUJARATI VOWEL SIGN AU */ - 0x0B02, /* ORIYA SIGN ANUSVARA */ - 0x0B03, /* ORIYA SIGN VISARGA */ - 0x0B3E, /* ORIYA VOWEL SIGN AA */ - 0x0B40, /* ORIYA VOWEL SIGN II */ - 0x0B47, /* ORIYA VOWEL SIGN E */ - 0x0B48, /* ORIYA VOWEL SIGN AI */ - 0x0B4B, /* ORIYA VOWEL SIGN O */ - 0x0B4C, /* ORIYA VOWEL SIGN AU */ - 0x0B57, /* ORIYA AU LENGTH MARK */ - 0x0BBE, /* TAMIL VOWEL SIGN AA */ - 0x0BBF, /* TAMIL VOWEL SIGN I */ - 0x0BC1, /* TAMIL VOWEL SIGN U */ - 0x0BC2, /* TAMIL VOWEL SIGN UU */ - 0x0BC6, /* TAMIL VOWEL SIGN E */ - 0x0BC7, /* TAMIL VOWEL SIGN EE */ - 0x0BC8, /* TAMIL VOWEL SIGN AI */ - 0x0BCA, /* TAMIL VOWEL SIGN O */ - 0x0BCB, /* TAMIL VOWEL SIGN OO */ - 0x0BCC, /* TAMIL VOWEL SIGN AU */ - 0x0BD7, /* TAMIL AU LENGTH MARK */ - 0x0C01, /* TELUGU SIGN CANDRABINDU */ - 0x0C02, /* TELUGU SIGN ANUSVARA */ - 0x0C03, /* TELUGU SIGN VISARGA */ - 0x0C41, /* TELUGU VOWEL SIGN U */ - 0x0C42, /* TELUGU VOWEL SIGN UU */ - 0x0C43, /* TELUGU VOWEL SIGN VOCALIC R */ - 0x0C44, /* TELUGU VOWEL SIGN VOCALIC RR */ - 0x0C82, /* KANNADA SIGN ANUSVARA */ - 0x0C83, /* KANNADA SIGN VISARGA */ - 0x0CBE, /* KANNADA VOWEL SIGN AA */ - 0x0CC0, /* KANNADA VOWEL SIGN II */ - 0x0CC1, /* KANNADA VOWEL SIGN U */ - 0x0CC2, /* KANNADA VOWEL SIGN UU */ - 0x0CC3, /* KANNADA VOWEL SIGN VOCALIC R */ - 0x0CC4, /* KANNADA VOWEL SIGN VOCALIC RR */ - 0x0CC7, /* KANNADA VOWEL SIGN EE */ - 0x0CC8, /* KANNADA VOWEL SIGN AI */ - 0x0CCA, /* KANNADA VOWEL SIGN O */ - 0x0CCB, /* KANNADA VOWEL SIGN OO */ - 0x0CD5, /* KANNADA LENGTH MARK */ - 0x0CD6, /* KANNADA AI LENGTH MARK */ - 0x0D02, /* MALAYALAM SIGN ANUSVARA */ - 0x0D03, /* MALAYALAM SIGN VISARGA */ - 0x0D3E, /* MALAYALAM VOWEL SIGN AA */ - 0x0D3F, /* MALAYALAM VOWEL SIGN I */ - 0x0D40, /* MALAYALAM VOWEL SIGN II */ - 0x0D46, /* MALAYALAM VOWEL SIGN E */ - 0x0D47, /* MALAYALAM VOWEL SIGN EE */ - 0x0D48, /* MALAYALAM VOWEL SIGN AI */ - 0x0D4A, /* MALAYALAM VOWEL SIGN O */ - 0x0D4B, /* MALAYALAM VOWEL SIGN OO */ - 0x0D4C, /* MALAYALAM VOWEL SIGN AU */ - 0x0D57, /* MALAYALAM AU LENGTH MARK */ - 0x0D82, /* SINHALA SIGN ANUSVARAYA */ - 0x0D83, /* SINHALA SIGN VISARGAYA */ - 0x0DCF, /* SINHALA VOWEL SIGN AELA-PILLA */ - 0x0DD0, /* SINHALA VOWEL SIGN KETTI AEDA-PILLA */ - 0x0DD1, /* SINHALA VOWEL SIGN DIGA AEDA-PILLA */ - 0x0DD8, /* SINHALA VOWEL SIGN GAETTA-PILLA */ - 0x0DD9, /* SINHALA VOWEL SIGN KOMBUVA */ - 0x0DDA, /* SINHALA VOWEL SIGN DIGA KOMBUVA */ - 0x0DDB, /* SINHALA VOWEL SIGN KOMBU DEKA */ - 0x0DDC, /* SINHALA VOWEL SIGN KOMBUVA HAA AELA-PILLA */ - 0x0DDD, /* SINHALA VOWEL SIGN KOMBUVA HAA DIGA AELA-PILLA */ - 0x0DDE, /* SINHALA VOWEL SIGN KOMBUVA HAA GAYANUKITTA */ - 0x0DDF, /* SINHALA VOWEL SIGN GAYANUKITTA */ - 0x0DF2, /* SINHALA VOWEL SIGN DIGA GAETTA-PILLA */ - 0x0DF3, /* SINHALA VOWEL SIGN DIGA GAYANUKITTA */ - 0x0F3E, /* TIBETAN SIGN YAR TSHES */ - 0x0F3F, /* TIBETAN SIGN MAR TSHES */ - 0x0F7F, /* TIBETAN SIGN RNAM BCAD */ - 0x102B, /* MYANMAR VOWEL SIGN TALL AA */ - 0x102C, /* MYANMAR VOWEL SIGN AA */ - 0x1031, /* MYANMAR VOWEL SIGN E */ - 0x1038, /* MYANMAR SIGN VISARGA */ - 0x103B, /* MYANMAR CONSONANT SIGN MEDIAL YA */ - 0x103C, /* MYANMAR CONSONANT SIGN MEDIAL RA */ - 0x1056, /* MYANMAR VOWEL SIGN VOCALIC R */ - 0x1057, /* MYANMAR VOWEL SIGN VOCALIC RR */ - 0x1062, /* MYANMAR VOWEL SIGN SGAW KAREN EU */ - 0x1063, /* MYANMAR TONE MARK SGAW KAREN HATHI */ - 0x1064, /* MYANMAR TONE MARK SGAW KAREN KE PHO */ - 0x1067, /* MYANMAR VOWEL SIGN WESTERN PWO KAREN EU */ - 0x1068, /* MYANMAR VOWEL SIGN WESTERN PWO KAREN UE */ - 0x1069, /* MYANMAR SIGN WESTERN PWO KAREN TONE-1 */ - 0x106A, /* MYANMAR SIGN WESTERN PWO KAREN TONE-2 */ - 0x106B, /* MYANMAR SIGN WESTERN PWO KAREN TONE-3 */ - 0x106C, /* MYANMAR SIGN WESTERN PWO KAREN TONE-4 */ - 0x106D, /* MYANMAR SIGN WESTERN PWO KAREN TONE-5 */ - 0x1083, /* MYANMAR VOWEL SIGN SHAN AA */ - 0x1084, /* MYANMAR VOWEL SIGN SHAN E */ - 0x1087, /* MYANMAR SIGN SHAN TONE-2 */ - 0x1088, /* MYANMAR SIGN SHAN TONE-3 */ - 0x1089, /* MYANMAR SIGN SHAN TONE-5 */ - 0x108A, /* MYANMAR SIGN SHAN TONE-6 */ - 0x108B, /* MYANMAR SIGN SHAN COUNCIL TONE-2 */ - 0x108C, /* MYANMAR SIGN SHAN COUNCIL TONE-3 */ - 0x108F, /* MYANMAR SIGN RUMAI PALAUNG TONE-5 */ - 0x17B6, /* KHMER VOWEL SIGN AA */ - 0x17BE, /* KHMER VOWEL SIGN OE */ - 0x17BF, /* KHMER VOWEL SIGN YA */ - 0x17C0, /* KHMER VOWEL SIGN IE */ - 0x17C1, /* KHMER VOWEL SIGN E */ - 0x17C2, /* KHMER VOWEL SIGN AE */ - 0x17C3, /* KHMER VOWEL SIGN AI */ - 0x17C4, /* KHMER VOWEL SIGN OO */ - 0x17C5, /* KHMER VOWEL SIGN AU */ - 0x17C7, /* KHMER SIGN REAHMUK */ - 0x17C8, /* KHMER SIGN YUUKALEAPINTU */ - 0x1923, /* LIMBU VOWEL SIGN EE */ - 0x1924, /* LIMBU VOWEL SIGN AI */ - 0x1925, /* LIMBU VOWEL SIGN OO */ - 0x1926, /* LIMBU VOWEL SIGN AU */ - 0x1929, /* LIMBU SUBJOINED LETTER YA */ - 0x192A, /* LIMBU SUBJOINED LETTER RA */ - 0x192B, /* LIMBU SUBJOINED LETTER WA */ - 0x1930, /* LIMBU SMALL LETTER KA */ - 0x1931, /* LIMBU SMALL LETTER NGA */ - 0x1933, /* LIMBU SMALL LETTER TA */ - 0x1934, /* LIMBU SMALL LETTER NA */ - 0x1935, /* LIMBU SMALL LETTER PA */ - 0x1936, /* LIMBU SMALL LETTER MA */ - 0x1937, /* LIMBU SMALL LETTER RA */ - 0x1938, /* LIMBU SMALL LETTER LA */ - 0x19B0, /* NEW TAI LUE VOWEL SIGN VOWEL SHORTENER */ - 0x19B1, /* NEW TAI LUE VOWEL SIGN AA */ - 0x19B2, /* NEW TAI LUE VOWEL SIGN II */ - 0x19B3, /* NEW TAI LUE VOWEL SIGN U */ - 0x19B4, /* NEW TAI LUE VOWEL SIGN UU */ - 0x19B5, /* NEW TAI LUE VOWEL SIGN E */ - 0x19B6, /* NEW TAI LUE VOWEL SIGN AE */ - 0x19B7, /* NEW TAI LUE VOWEL SIGN O */ - 0x19B8, /* NEW TAI LUE VOWEL SIGN OA */ - 0x19B9, /* NEW TAI LUE VOWEL SIGN UE */ - 0x19BA, /* NEW TAI LUE VOWEL SIGN AY */ - 0x19BB, /* NEW TAI LUE VOWEL SIGN AAY */ - 0x19BC, /* NEW TAI LUE VOWEL SIGN UY */ - 0x19BD, /* NEW TAI LUE VOWEL SIGN OY */ - 0x19BE, /* NEW TAI LUE VOWEL SIGN OAY */ - 0x19BF, /* NEW TAI LUE VOWEL SIGN UEY */ - 0x19C0, /* NEW TAI LUE VOWEL SIGN IY */ - 0x19C8, /* NEW TAI LUE TONE MARK-1 */ - 0x19C9, /* NEW TAI LUE TONE MARK-2 */ - 0x1A19, /* BUGINESE VOWEL SIGN E */ - 0x1A1A, /* BUGINESE VOWEL SIGN O */ - 0x1A1B, /* BUGINESE VOWEL SIGN AE */ - 0x1B04, /* BALINESE SIGN BISAH */ - 0x1B35, /* BALINESE VOWEL SIGN TEDUNG */ - 0x1B3B, /* BALINESE VOWEL SIGN RA REPA TEDUNG */ - 0x1B3D, /* BALINESE VOWEL SIGN LA LENGA TEDUNG */ - 0x1B3E, /* BALINESE VOWEL SIGN TALING */ - 0x1B3F, /* BALINESE VOWEL SIGN TALING REPA */ - 0x1B40, /* BALINESE VOWEL SIGN TALING TEDUNG */ - 0x1B41, /* BALINESE VOWEL SIGN TALING REPA TEDUNG */ - 0x1B43, /* BALINESE VOWEL SIGN PEPET TEDUNG */ - 0x1B44, /* BALINESE ADEG ADEG */ - 0x1B82, /* SUNDANESE SIGN PANGWISAD */ - 0x1BA1, /* SUNDANESE CONSONANT SIGN PAMINGKAL */ - 0x1BA6, /* SUNDANESE VOWEL SIGN PANAELAENG */ - 0x1BA7, /* SUNDANESE VOWEL SIGN PANOLONG */ - 0x1BAA, /* SUNDANESE SIGN PAMAAEH */ - 0x1C24, /* LEPCHA SUBJOINED LETTER YA */ - 0x1C25, /* LEPCHA SUBJOINED LETTER RA */ - 0x1C26, /* LEPCHA VOWEL SIGN AA */ - 0x1C27, /* LEPCHA VOWEL SIGN I */ - 0x1C28, /* LEPCHA VOWEL SIGN O */ - 0x1C29, /* LEPCHA VOWEL SIGN OO */ - 0x1C2A, /* LEPCHA VOWEL SIGN U */ - 0x1C2B, /* LEPCHA VOWEL SIGN UU */ - 0x1C34, /* LEPCHA CONSONANT SIGN NYIN-DO */ - 0x1C35, /* LEPCHA CONSONANT SIGN KANG */ - 0xA823, /* SYLOTI NAGRI VOWEL SIGN A */ - 0xA824, /* SYLOTI NAGRI VOWEL SIGN I */ - 0xA827, /* SYLOTI NAGRI VOWEL SIGN OO */ - 0xA880, /* SAURASHTRA SIGN ANUSVARA */ - 0xA881, /* SAURASHTRA SIGN VISARGA */ - 0xA8B4, /* SAURASHTRA CONSONANT SIGN HAARU */ - 0xA8B5, /* SAURASHTRA VOWEL SIGN AA */ - 0xA8B6, /* SAURASHTRA VOWEL SIGN I */ - 0xA8B7, /* SAURASHTRA VOWEL SIGN II */ - 0xA8B8, /* SAURASHTRA VOWEL SIGN U */ - 0xA8B9, /* SAURASHTRA VOWEL SIGN UU */ - 0xA8BA, /* SAURASHTRA VOWEL SIGN VOCALIC R */ - 0xA8BB, /* SAURASHTRA VOWEL SIGN VOCALIC RR */ - 0xA8BC, /* SAURASHTRA VOWEL SIGN VOCALIC L */ - 0xA8BD, /* SAURASHTRA VOWEL SIGN VOCALIC LL */ - 0xA8BE, /* SAURASHTRA VOWEL SIGN E */ - 0xA8BF, /* SAURASHTRA VOWEL SIGN EE */ - 0xA8C0, /* SAURASHTRA VOWEL SIGN AI */ - 0xA8C1, /* SAURASHTRA VOWEL SIGN O */ - 0xA8C2, /* SAURASHTRA VOWEL SIGN OO */ - 0xA8C3, /* SAURASHTRA VOWEL SIGN AU */ - 0xA952, /* REJANG CONSONANT SIGN H */ - 0xA953, /* REJANG VIRAMA */ - 0xAA2F, /* CHAM VOWEL SIGN O */ - 0xAA30, /* CHAM VOWEL SIGN AI */ - 0xAA33, /* CHAM CONSONANT SIGN YA */ - 0xAA34, /* CHAM CONSONANT SIGN RA */ - 0xAA4D /* CHAM CONSONANT SIGN FINAL H */ - }; - pg_wchar *StopLow = strange_letter, - *StopHigh = strange_letter + lengthof(strange_letter), - *StopMiddle; + static pg_wchar strange_letter[] = { + /* + * use binary search, so elements should be ordered + */ + 0x0903, /* DEVANAGARI SIGN VISARGA */ + 0x093E, /* DEVANAGARI VOWEL SIGN AA */ + 0x093F, /* DEVANAGARI VOWEL SIGN I */ + 0x0940, /* DEVANAGARI VOWEL SIGN II */ + 0x0949, /* DEVANAGARI VOWEL SIGN CANDRA O */ + 0x094A, /* DEVANAGARI VOWEL SIGN SHORT O */ + 0x094B, /* DEVANAGARI VOWEL SIGN O */ + 0x094C, /* DEVANAGARI VOWEL SIGN AU */ + 0x0982, /* BENGALI SIGN ANUSVARA */ + 0x0983, /* BENGALI SIGN VISARGA */ + 0x09BE, /* BENGALI VOWEL SIGN AA */ + 0x09BF, /* BENGALI VOWEL SIGN I */ + 0x09C0, /* BENGALI VOWEL SIGN II */ + 0x09C7, /* BENGALI VOWEL SIGN E */ + 0x09C8, /* BENGALI VOWEL SIGN AI */ + 0x09CB, /* BENGALI VOWEL SIGN O */ + 0x09CC, /* BENGALI VOWEL SIGN AU */ + 0x09D7, /* BENGALI AU LENGTH MARK */ + 0x0A03, /* GURMUKHI SIGN VISARGA */ + 0x0A3E, /* GURMUKHI VOWEL SIGN AA */ + 0x0A3F, /* GURMUKHI VOWEL SIGN I */ + 0x0A40, /* GURMUKHI VOWEL SIGN II */ + 0x0A83, /* GUJARATI SIGN VISARGA */ + 0x0ABE, /* GUJARATI VOWEL SIGN AA */ + 0x0ABF, /* GUJARATI VOWEL SIGN I */ + 0x0AC0, /* GUJARATI VOWEL SIGN II */ + 0x0AC9, /* GUJARATI VOWEL SIGN CANDRA O */ + 0x0ACB, /* GUJARATI VOWEL SIGN O */ + 0x0ACC, /* GUJARATI VOWEL SIGN AU */ + 0x0B02, /* ORIYA SIGN ANUSVARA */ + 0x0B03, /* ORIYA SIGN VISARGA */ + 0x0B3E, /* ORIYA VOWEL SIGN AA */ + 0x0B40, /* ORIYA VOWEL SIGN II */ + 0x0B47, /* ORIYA VOWEL SIGN E */ + 0x0B48, /* ORIYA VOWEL SIGN AI */ + 0x0B4B, /* ORIYA VOWEL SIGN O */ + 0x0B4C, /* ORIYA VOWEL SIGN AU */ + 0x0B57, /* ORIYA AU LENGTH MARK */ + 0x0BBE, /* TAMIL VOWEL SIGN AA */ + 0x0BBF, /* TAMIL VOWEL SIGN I */ + 0x0BC1, /* TAMIL VOWEL SIGN U */ + 0x0BC2, /* TAMIL VOWEL SIGN UU */ + 0x0BC6, /* TAMIL VOWEL SIGN E */ + 0x0BC7, /* TAMIL VOWEL SIGN EE */ + 0x0BC8, /* TAMIL VOWEL SIGN AI */ + 0x0BCA, /* TAMIL VOWEL SIGN O */ + 0x0BCB, /* TAMIL VOWEL SIGN OO */ + 0x0BCC, /* TAMIL VOWEL SIGN AU */ + 0x0BD7, /* TAMIL AU LENGTH MARK */ + 0x0C01, /* TELUGU SIGN CANDRABINDU */ + 0x0C02, /* TELUGU SIGN ANUSVARA */ + 0x0C03, /* TELUGU SIGN VISARGA */ + 0x0C41, /* TELUGU VOWEL SIGN U */ + 0x0C42, /* TELUGU VOWEL SIGN UU */ + 0x0C43, /* TELUGU VOWEL SIGN VOCALIC R */ + 0x0C44, /* TELUGU VOWEL SIGN VOCALIC RR */ + 0x0C82, /* KANNADA SIGN ANUSVARA */ + 0x0C83, /* KANNADA SIGN VISARGA */ + 0x0CBE, /* KANNADA VOWEL SIGN AA */ + 0x0CC0, /* KANNADA VOWEL SIGN II */ + 0x0CC1, /* KANNADA VOWEL SIGN U */ + 0x0CC2, /* KANNADA VOWEL SIGN UU */ + 0x0CC3, /* KANNADA VOWEL SIGN VOCALIC R */ + 0x0CC4, /* KANNADA VOWEL SIGN VOCALIC RR */ + 0x0CC7, /* KANNADA VOWEL SIGN EE */ + 0x0CC8, /* KANNADA VOWEL SIGN AI */ + 0x0CCA, /* KANNADA VOWEL SIGN O */ + 0x0CCB, /* KANNADA VOWEL SIGN OO */ + 0x0CD5, /* KANNADA LENGTH MARK */ + 0x0CD6, /* KANNADA AI LENGTH MARK */ + 0x0D02, /* MALAYALAM SIGN ANUSVARA */ + 0x0D03, /* MALAYALAM SIGN VISARGA */ + 0x0D3E, /* MALAYALAM VOWEL SIGN AA */ + 0x0D3F, /* MALAYALAM VOWEL SIGN I */ + 0x0D40, /* MALAYALAM VOWEL SIGN II */ + 0x0D46, /* MALAYALAM VOWEL SIGN E */ + 0x0D47, /* MALAYALAM VOWEL SIGN EE */ + 0x0D48, /* MALAYALAM VOWEL SIGN AI */ + 0x0D4A, /* MALAYALAM VOWEL SIGN O */ + 0x0D4B, /* MALAYALAM VOWEL SIGN OO */ + 0x0D4C, /* MALAYALAM VOWEL SIGN AU */ + 0x0D57, /* MALAYALAM AU LENGTH MARK */ + 0x0D82, /* SINHALA SIGN ANUSVARAYA */ + 0x0D83, /* SINHALA SIGN VISARGAYA */ + 0x0DCF, /* SINHALA VOWEL SIGN AELA-PILLA */ + 0x0DD0, /* SINHALA VOWEL SIGN KETTI AEDA-PILLA */ + 0x0DD1, /* SINHALA VOWEL SIGN DIGA AEDA-PILLA */ + 0x0DD8, /* SINHALA VOWEL SIGN GAETTA-PILLA */ + 0x0DD9, /* SINHALA VOWEL SIGN KOMBUVA */ + 0x0DDA, /* SINHALA VOWEL SIGN DIGA KOMBUVA */ + 0x0DDB, /* SINHALA VOWEL SIGN KOMBU DEKA */ + 0x0DDC, /* SINHALA VOWEL SIGN KOMBUVA HAA AELA-PILLA */ + 0x0DDD, /* SINHALA VOWEL SIGN KOMBUVA HAA DIGA + * AELA-PILLA */ + 0x0DDE, /* SINHALA VOWEL SIGN KOMBUVA HAA GAYANUKITTA */ + 0x0DDF, /* SINHALA VOWEL SIGN GAYANUKITTA */ + 0x0DF2, /* SINHALA VOWEL SIGN DIGA GAETTA-PILLA */ + 0x0DF3, /* SINHALA VOWEL SIGN DIGA GAYANUKITTA */ + 0x0F3E, /* TIBETAN SIGN YAR TSHES */ + 0x0F3F, /* TIBETAN SIGN MAR TSHES */ + 0x0F7F, /* TIBETAN SIGN RNAM BCAD */ + 0x102B, /* MYANMAR VOWEL SIGN TALL AA */ + 0x102C, /* MYANMAR VOWEL SIGN AA */ + 0x1031, /* MYANMAR VOWEL SIGN E */ + 0x1038, /* MYANMAR SIGN VISARGA */ + 0x103B, /* MYANMAR CONSONANT SIGN MEDIAL YA */ + 0x103C, /* MYANMAR CONSONANT SIGN MEDIAL RA */ + 0x1056, /* MYANMAR VOWEL SIGN VOCALIC R */ + 0x1057, /* MYANMAR VOWEL SIGN VOCALIC RR */ + 0x1062, /* MYANMAR VOWEL SIGN SGAW KAREN EU */ + 0x1063, /* MYANMAR TONE MARK SGAW KAREN HATHI */ + 0x1064, /* MYANMAR TONE MARK SGAW KAREN KE PHO */ + 0x1067, /* MYANMAR VOWEL SIGN WESTERN PWO KAREN EU */ + 0x1068, /* MYANMAR VOWEL SIGN WESTERN PWO KAREN UE */ + 0x1069, /* MYANMAR SIGN WESTERN PWO KAREN TONE-1 */ + 0x106A, /* MYANMAR SIGN WESTERN PWO KAREN TONE-2 */ + 0x106B, /* MYANMAR SIGN WESTERN PWO KAREN TONE-3 */ + 0x106C, /* MYANMAR SIGN WESTERN PWO KAREN TONE-4 */ + 0x106D, /* MYANMAR SIGN WESTERN PWO KAREN TONE-5 */ + 0x1083, /* MYANMAR VOWEL SIGN SHAN AA */ + 0x1084, /* MYANMAR VOWEL SIGN SHAN E */ + 0x1087, /* MYANMAR SIGN SHAN TONE-2 */ + 0x1088, /* MYANMAR SIGN SHAN TONE-3 */ + 0x1089, /* MYANMAR SIGN SHAN TONE-5 */ + 0x108A, /* MYANMAR SIGN SHAN TONE-6 */ + 0x108B, /* MYANMAR SIGN SHAN COUNCIL TONE-2 */ + 0x108C, /* MYANMAR SIGN SHAN COUNCIL TONE-3 */ + 0x108F, /* MYANMAR SIGN RUMAI PALAUNG TONE-5 */ + 0x17B6, /* KHMER VOWEL SIGN AA */ + 0x17BE, /* KHMER VOWEL SIGN OE */ + 0x17BF, /* KHMER VOWEL SIGN YA */ + 0x17C0, /* KHMER VOWEL SIGN IE */ + 0x17C1, /* KHMER VOWEL SIGN E */ + 0x17C2, /* KHMER VOWEL SIGN AE */ + 0x17C3, /* KHMER VOWEL SIGN AI */ + 0x17C4, /* KHMER VOWEL SIGN OO */ + 0x17C5, /* KHMER VOWEL SIGN AU */ + 0x17C7, /* KHMER SIGN REAHMUK */ + 0x17C8, /* KHMER SIGN YUUKALEAPINTU */ + 0x1923, /* LIMBU VOWEL SIGN EE */ + 0x1924, /* LIMBU VOWEL SIGN AI */ + 0x1925, /* LIMBU VOWEL SIGN OO */ + 0x1926, /* LIMBU VOWEL SIGN AU */ + 0x1929, /* LIMBU SUBJOINED LETTER YA */ + 0x192A, /* LIMBU SUBJOINED LETTER RA */ + 0x192B, /* LIMBU SUBJOINED LETTER WA */ + 0x1930, /* LIMBU SMALL LETTER KA */ + 0x1931, /* LIMBU SMALL LETTER NGA */ + 0x1933, /* LIMBU SMALL LETTER TA */ + 0x1934, /* LIMBU SMALL LETTER NA */ + 0x1935, /* LIMBU SMALL LETTER PA */ + 0x1936, /* LIMBU SMALL LETTER MA */ + 0x1937, /* LIMBU SMALL LETTER RA */ + 0x1938, /* LIMBU SMALL LETTER LA */ + 0x19B0, /* NEW TAI LUE VOWEL SIGN VOWEL SHORTENER */ + 0x19B1, /* NEW TAI LUE VOWEL SIGN AA */ + 0x19B2, /* NEW TAI LUE VOWEL SIGN II */ + 0x19B3, /* NEW TAI LUE VOWEL SIGN U */ + 0x19B4, /* NEW TAI LUE VOWEL SIGN UU */ + 0x19B5, /* NEW TAI LUE VOWEL SIGN E */ + 0x19B6, /* NEW TAI LUE VOWEL SIGN AE */ + 0x19B7, /* NEW TAI LUE VOWEL SIGN O */ + 0x19B8, /* NEW TAI LUE VOWEL SIGN OA */ + 0x19B9, /* NEW TAI LUE VOWEL SIGN UE */ + 0x19BA, /* NEW TAI LUE VOWEL SIGN AY */ + 0x19BB, /* NEW TAI LUE VOWEL SIGN AAY */ + 0x19BC, /* NEW TAI LUE VOWEL SIGN UY */ + 0x19BD, /* NEW TAI LUE VOWEL SIGN OY */ + 0x19BE, /* NEW TAI LUE VOWEL SIGN OAY */ + 0x19BF, /* NEW TAI LUE VOWEL SIGN UEY */ + 0x19C0, /* NEW TAI LUE VOWEL SIGN IY */ + 0x19C8, /* NEW TAI LUE TONE MARK-1 */ + 0x19C9, /* NEW TAI LUE TONE MARK-2 */ + 0x1A19, /* BUGINESE VOWEL SIGN E */ + 0x1A1A, /* BUGINESE VOWEL SIGN O */ + 0x1A1B, /* BUGINESE VOWEL SIGN AE */ + 0x1B04, /* BALINESE SIGN BISAH */ + 0x1B35, /* BALINESE VOWEL SIGN TEDUNG */ + 0x1B3B, /* BALINESE VOWEL SIGN RA REPA TEDUNG */ + 0x1B3D, /* BALINESE VOWEL SIGN LA LENGA TEDUNG */ + 0x1B3E, /* BALINESE VOWEL SIGN TALING */ + 0x1B3F, /* BALINESE VOWEL SIGN TALING REPA */ + 0x1B40, /* BALINESE VOWEL SIGN TALING TEDUNG */ + 0x1B41, /* BALINESE VOWEL SIGN TALING REPA TEDUNG */ + 0x1B43, /* BALINESE VOWEL SIGN PEPET TEDUNG */ + 0x1B44, /* BALINESE ADEG ADEG */ + 0x1B82, /* SUNDANESE SIGN PANGWISAD */ + 0x1BA1, /* SUNDANESE CONSONANT SIGN PAMINGKAL */ + 0x1BA6, /* SUNDANESE VOWEL SIGN PANAELAENG */ + 0x1BA7, /* SUNDANESE VOWEL SIGN PANOLONG */ + 0x1BAA, /* SUNDANESE SIGN PAMAAEH */ + 0x1C24, /* LEPCHA SUBJOINED LETTER YA */ + 0x1C25, /* LEPCHA SUBJOINED LETTER RA */ + 0x1C26, /* LEPCHA VOWEL SIGN AA */ + 0x1C27, /* LEPCHA VOWEL SIGN I */ + 0x1C28, /* LEPCHA VOWEL SIGN O */ + 0x1C29, /* LEPCHA VOWEL SIGN OO */ + 0x1C2A, /* LEPCHA VOWEL SIGN U */ + 0x1C2B, /* LEPCHA VOWEL SIGN UU */ + 0x1C34, /* LEPCHA CONSONANT SIGN NYIN-DO */ + 0x1C35, /* LEPCHA CONSONANT SIGN KANG */ + 0xA823, /* SYLOTI NAGRI VOWEL SIGN A */ + 0xA824, /* SYLOTI NAGRI VOWEL SIGN I */ + 0xA827, /* SYLOTI NAGRI VOWEL SIGN OO */ + 0xA880, /* SAURASHTRA SIGN ANUSVARA */ + 0xA881, /* SAURASHTRA SIGN VISARGA */ + 0xA8B4, /* SAURASHTRA CONSONANT SIGN HAARU */ + 0xA8B5, /* SAURASHTRA VOWEL SIGN AA */ + 0xA8B6, /* SAURASHTRA VOWEL SIGN I */ + 0xA8B7, /* SAURASHTRA VOWEL SIGN II */ + 0xA8B8, /* SAURASHTRA VOWEL SIGN U */ + 0xA8B9, /* SAURASHTRA VOWEL SIGN UU */ + 0xA8BA, /* SAURASHTRA VOWEL SIGN VOCALIC R */ + 0xA8BB, /* SAURASHTRA VOWEL SIGN VOCALIC RR */ + 0xA8BC, /* SAURASHTRA VOWEL SIGN VOCALIC L */ + 0xA8BD, /* SAURASHTRA VOWEL SIGN VOCALIC LL */ + 0xA8BE, /* SAURASHTRA VOWEL SIGN E */ + 0xA8BF, /* SAURASHTRA VOWEL SIGN EE */ + 0xA8C0, /* SAURASHTRA VOWEL SIGN AI */ + 0xA8C1, /* SAURASHTRA VOWEL SIGN O */ + 0xA8C2, /* SAURASHTRA VOWEL SIGN OO */ + 0xA8C3, /* SAURASHTRA VOWEL SIGN AU */ + 0xA952, /* REJANG CONSONANT SIGN H */ + 0xA953, /* REJANG VIRAMA */ + 0xAA2F, /* CHAM VOWEL SIGN O */ + 0xAA30, /* CHAM VOWEL SIGN AI */ + 0xAA33, /* CHAM CONSONANT SIGN YA */ + 0xAA34, /* CHAM CONSONANT SIGN RA */ + 0xAA4D /* CHAM CONSONANT SIGN FINAL H */ + }; + pg_wchar *StopLow = strange_letter, + *StopHigh = strange_letter + lengthof(strange_letter), + *StopMiddle; pg_wchar c; - if ( prs->pgwstr ) + if (prs->pgwstr) c = *(prs->pgwstr + prs->state->poschar); else c = (pg_wchar) *(prs->wstr + prs->state->poschar); - while( StopLow < StopHigh ) + while (StopLow < StopHigh) { StopMiddle = StopLow + ((StopHigh - StopLow) >> 1); - if ( *StopMiddle == c ) + if (*StopMiddle == c) return 1; - else if ( *StopMiddle < c ) + else if (*StopMiddle < c) StopLow = StopMiddle + 1; else StopHigh = StopMiddle; @@ -1288,7 +1289,7 @@ static const TParserStateActionItem actionTPS_InTagFirst[] = { static const TParserStateActionItem actionTPS_InXMLBegin[] = { {p_isEOF, 0, A_POP, TPS_Null, 0, NULL}, /* <?xml ... */ - /* XXX do we wants states for the m and l ? Right now this accepts <?xZ */ + /* XXX do we wants states for the m and l ? Right now this accepts <?xZ */ {p_iseqC, 'x', A_NEXT, TPS_InTag, 0, NULL}, {NULL, 0, A_POP, TPS_Null, 0, NULL} }; @@ -2004,10 +2005,10 @@ prsd_end(PG_FUNCTION_ARGS) #define COMPLEXTOKEN(x) ( (x)==URL_T || (x)==NUMHWORD || (x)==ASCIIHWORD || (x)==HWORD ) #define ENDPUNCTOKEN(x) ( (x)==SPACE ) -#define TS_IDIGNORE(x) ( (x)==TAG_T || (x)==PROTOCOL || (x)==SPACE || (x)==XMLENTITY ) -#define HLIDREPLACE(x) ( (x)==TAG_T ) -#define HLIDSKIP(x) ( (x)==URL_T || (x)==NUMHWORD || (x)==ASCIIHWORD || (x)==HWORD ) -#define XMLHLIDSKIP(x) ( (x)==URL_T || (x)==NUMHWORD || (x)==ASCIIHWORD || (x)==HWORD ) +#define TS_IDIGNORE(x) ( (x)==TAG_T || (x)==PROTOCOL || (x)==SPACE || (x)==XMLENTITY ) +#define HLIDREPLACE(x) ( (x)==TAG_T ) +#define HLIDSKIP(x) ( (x)==URL_T || (x)==NUMHWORD || (x)==ASCIIHWORD || (x)==HWORD ) +#define XMLHLIDSKIP(x) ( (x)==URL_T || (x)==NUMHWORD || (x)==ASCIIHWORD || (x)==HWORD ) #define NONWORDTOKEN(x) ( (x)==SPACE || HLIDREPLACE(x) || HLIDSKIP(x) ) #define NOENDTOKEN(x) ( NONWORDTOKEN(x) || (x)==SCIENTIFIC || (x)==VERSIONNUMBER || (x)==DECIMAL_T || (x)==SIGNEDINT || (x)==UNSIGNEDINT || TS_IDIGNORE(x) ) @@ -2105,7 +2106,7 @@ hlCover(HeadlineParsedText *prs, TSQuery query, int *p, int *q) static void mark_fragment(HeadlineParsedText *prs, int highlight, int startpos, int endpos) { - int i; + int i; for (i = startpos; i <= endpos; i++) { @@ -2115,7 +2116,7 @@ mark_fragment(HeadlineParsedText *prs, int highlight, int startpos, int endpos) { if (HLIDREPLACE(prs->words[i].type)) prs->words[i].replace = 1; - else if ( HLIDSKIP(prs->words[i].type) ) + else if (HLIDSKIP(prs->words[i].type)) prs->words[i].skip = 1; } else @@ -2130,27 +2131,29 @@ mark_fragment(HeadlineParsedText *prs, int highlight, int startpos, int endpos) typedef struct { - int4 startpos; - int4 endpos; - int4 poslen; - int4 curlen; - int2 in; - int2 excluded; + int4 startpos; + int4 endpos; + int4 poslen; + int4 curlen; + int2 in; + int2 excluded; } CoverPos; static void get_next_fragment(HeadlineParsedText *prs, int *startpos, int *endpos, - int *curlen, int *poslen, int max_words) + int *curlen, int *poslen, int max_words) { - int i; - /* Objective: Generate a fragment of words between startpos and endpos - * such that it has at most max_words and both ends has query words. - * If the startpos and endpos are the endpoints of the cover and the - * cover has fewer words than max_words, then this function should - * just return the cover + int i; + + /* + * Objective: Generate a fragment of words between startpos and endpos + * such that it has at most max_words and both ends has query words. If + * the startpos and endpos are the endpoints of the cover and the cover + * has fewer words than max_words, then this function should just return + * the cover */ /* first move startpos to an item */ - for(i = *startpos; i <= *endpos; i++) + for (i = *startpos; i <= *endpos; i++) { *startpos = i; if (prs->words[i].item && !prs->words[i].repeated) @@ -2159,7 +2162,7 @@ get_next_fragment(HeadlineParsedText *prs, int *startpos, int *endpos, /* cut endpos to have only max_words */ *curlen = 0; *poslen = 0; - for(i = *startpos; i <= *endpos && *curlen < max_words; i++) + for (i = *startpos; i <= *endpos && *curlen < max_words; i++) { if (!NONWORDTOKEN(prs->words[i].type)) *curlen += 1; @@ -2170,7 +2173,7 @@ get_next_fragment(HeadlineParsedText *prs, int *startpos, int *endpos, if (*endpos > i) { *endpos = i; - for(i = *endpos; i >= *startpos; i --) + for (i = *endpos; i >= *startpos; i--) { *endpos = i; if (prs->words[i].item && !prs->words[i].repeated) @@ -2183,22 +2186,30 @@ get_next_fragment(HeadlineParsedText *prs, int *startpos, int *endpos, static void mark_hl_fragments(HeadlineParsedText *prs, TSQuery query, int highlight, - int shortword, int min_words, - int max_words, int max_fragments) + int shortword, int min_words, + int max_words, int max_fragments) { - int4 poslen, curlen, i, f, num_f = 0; - int4 stretch, maxstretch, posmarker; - - int4 startpos = 0, - endpos = 0, - p = 0, - q = 0; + int4 poslen, + curlen, + i, + f, + num_f = 0; + int4 stretch, + maxstretch, + posmarker; + + int4 startpos = 0, + endpos = 0, + p = 0, + q = 0; int4 numcovers = 0, - maxcovers = 32; + maxcovers = 32; - int4 minI, minwords, maxitems; - CoverPos *covers; + int4 minI, + minwords, + maxitems; + CoverPos *covers; covers = palloc(maxcovers * sizeof(CoverPos)); @@ -2206,12 +2217,13 @@ mark_hl_fragments(HeadlineParsedText *prs, TSQuery query, int highlight, while (hlCover(prs, query, &p, &q)) { startpos = p; - endpos = q; + endpos = q; - /* Break the cover into smaller fragments such that each fragment - * has at most max_words. Also ensure that each end of the fragment - * is a query word. This will allow us to stretch the fragment in - * either direction + /* + * Break the cover into smaller fragments such that each fragment has + * at most max_words. Also ensure that each end of the fragment is a + * query word. This will allow us to stretch the fragment in either + * direction */ while (startpos <= endpos) @@ -2220,17 +2232,17 @@ mark_hl_fragments(HeadlineParsedText *prs, TSQuery query, int highlight, if (numcovers >= maxcovers) { maxcovers *= 2; - covers = repalloc(covers, sizeof(CoverPos) * maxcovers); + covers = repalloc(covers, sizeof(CoverPos) * maxcovers); } covers[numcovers].startpos = startpos; - covers[numcovers].endpos = endpos; - covers[numcovers].curlen = curlen; - covers[numcovers].poslen = poslen; - covers[numcovers].in = 0; + covers[numcovers].endpos = endpos; + covers[numcovers].curlen = curlen; + covers[numcovers].poslen = poslen; + covers[numcovers].in = 0; covers[numcovers].excluded = 0; - numcovers ++; + numcovers++; startpos = endpos + 1; - endpos = q; + endpos = q; } /* move p to generate the next cover */ p++; @@ -2242,19 +2254,20 @@ mark_hl_fragments(HeadlineParsedText *prs, TSQuery query, int highlight, maxitems = 0; minwords = 0x7fffffff; minI = -1; - /* Choose the cover that contains max items. - * In case of tie choose the one with smaller - * number of words. + + /* + * Choose the cover that contains max items. In case of tie choose the + * one with smaller number of words. */ - for (i = 0; i < numcovers; i ++) + for (i = 0; i < numcovers; i++) { - if (!covers[i].in && !covers[i].excluded && + if (!covers[i].in && !covers[i].excluded && (maxitems < covers[i].poslen || (maxitems == covers[i].poslen - && minwords > covers[i].curlen))) + && minwords > covers[i].curlen))) { maxitems = covers[i].poslen; minwords = covers[i].curlen; - minI = i; + minI = i; } } /* if a cover was found mark it */ @@ -2263,27 +2276,27 @@ mark_hl_fragments(HeadlineParsedText *prs, TSQuery query, int highlight, covers[minI].in = 1; /* adjust the size of cover */ startpos = covers[minI].startpos; - endpos = covers[minI].endpos; - curlen = covers[minI].curlen; + endpos = covers[minI].endpos; + curlen = covers[minI].curlen; /* stretch the cover if cover size is lower than max_words */ if (curlen < max_words) { /* divide the stretch on both sides of cover */ - maxstretch = (max_words - curlen)/2; - /* first stretch the startpos - * stop stretching if - * 1. we hit the beginning of document - * 2. exceed maxstretch - * 3. we hit an already marked fragment + maxstretch = (max_words - curlen) / 2; + + /* + * first stretch the startpos stop stretching if 1. we hit the + * beginning of document 2. exceed maxstretch 3. we hit an + * already marked fragment */ - stretch = 0; + stretch = 0; posmarker = startpos; for (i = startpos - 1; i >= 0 && stretch < maxstretch && !prs->words[i].in; i--) { if (!NONWORDTOKEN(prs->words[i].type)) { - curlen ++; - stretch ++; + curlen++; + stretch++; } posmarker = i; } @@ -2291,35 +2304,35 @@ mark_hl_fragments(HeadlineParsedText *prs, TSQuery query, int highlight, for (i = posmarker; i < startpos && (NOENDTOKEN(prs->words[i].type) || prs->words[i].len <= shortword); i++) { if (!NONWORDTOKEN(prs->words[i].type)) - curlen --; + curlen--; } startpos = i; - /* now stretch the endpos as much as possible*/ + /* now stretch the endpos as much as possible */ posmarker = endpos; for (i = endpos + 1; i < prs->curwords && curlen < max_words && !prs->words[i].in; i++) { if (!NONWORDTOKEN(prs->words[i].type)) - curlen ++; + curlen++; posmarker = i; } /* cut back endpos till we find a non-short token */ - for ( i = posmarker; i > endpos && (NOENDTOKEN(prs->words[i].type) || prs->words[i].len <= shortword); i--) + for (i = posmarker; i > endpos && (NOENDTOKEN(prs->words[i].type) || prs->words[i].len <= shortword); i--) { if (!NONWORDTOKEN(prs->words[i].type)) - curlen --; + curlen--; } endpos = i; } covers[minI].startpos = startpos; - covers[minI].endpos = endpos; - covers[minI].curlen = curlen; + covers[minI].endpos = endpos; + covers[minI].curlen = curlen; /* Mark the chosen fragments (covers) */ mark_fragment(prs, highlight, startpos, endpos); - num_f ++; + num_f++; /* exclude overlapping covers */ - for (i = 0; i < numcovers; i ++) + for (i = 0; i < numcovers; i++) { - if (i != minI && ( (covers[i].startpos >= covers[minI].startpos && covers[i].startpos <= covers[minI].endpos) || (covers[i].endpos >= covers[minI].startpos && covers[i].endpos <= covers[minI].endpos))) + if (i != minI && ((covers[i].startpos >= covers[minI].startpos && covers[i].startpos <= covers[minI].endpos) || (covers[i].endpos >= covers[minI].startpos && covers[i].endpos <= covers[minI].endpos))) covers[i].excluded = 1; } } @@ -2327,7 +2340,7 @@ mark_hl_fragments(HeadlineParsedText *prs, TSQuery query, int highlight, break; } - /* show at least min_words we have not marked anything*/ + /* show at least min_words we have not marked anything */ if (num_f <= 0) { startpos = endpos = curlen = 0; @@ -2344,7 +2357,7 @@ mark_hl_fragments(HeadlineParsedText *prs, TSQuery query, int highlight, static void mark_hl_words(HeadlineParsedText *prs, TSQuery query, int highlight, - int shortword, int min_words, int max_words) + int shortword, int min_words, int max_words) { int p = 0, q = 0; @@ -2408,7 +2421,7 @@ mark_hl_words(HeadlineParsedText *prs, TSQuery query, int highlight, curlen++; if (prs->words[i].item && !prs->words[i].repeated) poslen++; - if ( curlen >= max_words ) + if (curlen >= max_words) break; if (NOENDTOKEN(prs->words[i].type) || prs->words[i].len <= shortword) continue; @@ -2472,7 +2485,7 @@ mark_hl_words(HeadlineParsedText *prs, TSQuery query, int highlight, { if (HLIDREPLACE(prs->words[i].type)) prs->words[i].replace = 1; - else if ( HLIDSKIP(prs->words[i].type) ) + else if (HLIDSKIP(prs->words[i].type)) prs->words[i].skip = 1; } else @@ -2494,11 +2507,11 @@ prsd_headline(PG_FUNCTION_ARGS) TSQuery query = PG_GETARG_TSQUERY(2); /* from opt + start and and tag */ - int min_words = 15; - int max_words = 35; - int shortword = 3; + int min_words = 15; + int max_words = 35; + int shortword = 3; int max_fragments = 0; - int highlight = 0; + int highlight = 0; ListCell *l; /* config */ diff --git a/src/backend/utils/adt/acl.c b/src/backend/utils/adt/acl.c index 2f27018b256..dc75ad86ce2 100644 --- a/src/backend/utils/adt/acl.c +++ b/src/backend/utils/adt/acl.c @@ -113,7 +113,7 @@ static AclMode convert_role_priv_string(text *priv_type_text); static AclResult pg_role_aclcheck(Oid role_oid, Oid roleid, AclMode mode); static void RoleMembershipCacheCallback(Datum arg, int cacheid, ItemPointer tuplePtr); -static Oid get_role_oid_or_public(const char *rolname); +static Oid get_role_oid_or_public(const char *rolname); /* @@ -4829,7 +4829,7 @@ get_role_oid(const char *rolname, bool missing_ok) /* * get_role_oid_or_public - As above, but return ACL_ID_PUBLIC if the - * role name is "public". + * role name is "public". */ static Oid get_role_oid_or_public(const char *rolname) diff --git a/src/backend/utils/adt/arrayfuncs.c b/src/backend/utils/adt/arrayfuncs.c index e023b2458ed..0869de66cef 100644 --- a/src/backend/utils/adt/arrayfuncs.c +++ b/src/backend/utils/adt/arrayfuncs.c @@ -72,7 +72,7 @@ typedef struct ArrayIteratorData /* current position information, updated on each iteration */ char *data_ptr; /* our current position in the array */ int current_item; /* the item # we're at in the array */ -} ArrayIteratorData; +} ArrayIteratorData; static bool array_isspace(char ch); static int ArrayCount(const char *str, int *dim, char typdelim); @@ -1268,7 +1268,8 @@ array_recv(PG_FUNCTION_ARGS) */ if (dim[i] != 0) { - int ub = lBound[i] + dim[i] - 1; + int ub = lBound[i] + dim[i] - 1; + if (lBound[i] > ub) ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), diff --git a/src/backend/utils/adt/cash.c b/src/backend/utils/adt/cash.c index 4c3279759d5..faef6f83813 100644 --- a/src/backend/utils/adt/cash.c +++ b/src/backend/utils/adt/cash.c @@ -945,11 +945,11 @@ numeric_cash(PG_FUNCTION_ARGS) Datum int4_cash(PG_FUNCTION_ARGS) { - int32 amount = PG_GETARG_INT32(0); - Cash result; - int fpoint; - int64 scale; - int i; + int32 amount = PG_GETARG_INT32(0); + Cash result; + int fpoint; + int64 scale; + int i; struct lconv *lconvert = PGLC_localeconv(); /* see comments about frac_digits in cash_in() */ @@ -964,7 +964,7 @@ int4_cash(PG_FUNCTION_ARGS) /* compute amount * scale, checking for overflow */ result = DatumGetInt64(DirectFunctionCall2(int8mul, Int64GetDatum(amount), - Int64GetDatum(scale))); + Int64GetDatum(scale))); PG_RETURN_CASH(result); } @@ -975,11 +975,11 @@ int4_cash(PG_FUNCTION_ARGS) Datum int8_cash(PG_FUNCTION_ARGS) { - int64 amount = PG_GETARG_INT64(0); - Cash result; - int fpoint; - int64 scale; - int i; + int64 amount = PG_GETARG_INT64(0); + Cash result; + int fpoint; + int64 scale; + int i; struct lconv *lconvert = PGLC_localeconv(); /* see comments about frac_digits in cash_in() */ @@ -994,7 +994,7 @@ int8_cash(PG_FUNCTION_ARGS) /* compute amount * scale, checking for overflow */ result = DatumGetInt64(DirectFunctionCall2(int8mul, Int64GetDatum(amount), - Int64GetDatum(scale))); + Int64GetDatum(scale))); PG_RETURN_CASH(result); } diff --git a/src/backend/utils/adt/date.c b/src/backend/utils/adt/date.c index f96fa6cb72e..e737e720f5b 100644 --- a/src/backend/utils/adt/date.c +++ b/src/backend/utils/adt/date.c @@ -472,7 +472,7 @@ date2timestamptz(DateADT dateVal) double date2timestamp_no_overflow(DateADT dateVal) { - double result; + double result; if (DATE_IS_NOBEGIN(dateVal)) result = -DBL_MAX; diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c index 0410b8384e9..db0a6487acf 100644 --- a/src/backend/utils/adt/datetime.c +++ b/src/backend/utils/adt/datetime.c @@ -2397,7 +2397,7 @@ DecodeTime(char *str, int fmask, int range, /* do a sanity check */ #ifdef HAVE_INT64_TIMESTAMP - if (tm->tm_hour < 0 || tm->tm_min < 0 || tm->tm_min > MINS_PER_HOUR -1 || + if (tm->tm_hour < 0 || tm->tm_min < 0 || tm->tm_min > MINS_PER_HOUR - 1 || tm->tm_sec < 0 || tm->tm_sec > SECS_PER_MINUTE || *fsec < INT64CONST(0) || *fsec > USECS_PER_SEC) diff --git a/src/backend/utils/adt/dbsize.c b/src/backend/utils/adt/dbsize.c index 543a244bf99..73a6ad32808 100644 --- a/src/backend/utils/adt/dbsize.c +++ b/src/backend/utils/adt/dbsize.c @@ -634,7 +634,7 @@ pg_relation_filepath(PG_FUNCTION_ARGS) break; default: elog(ERROR, "invalid relpersistence: %c", relform->relpersistence); - backend = InvalidBackendId; /* placate compiler */ + backend = InvalidBackendId; /* placate compiler */ break; } diff --git a/src/backend/utils/adt/enum.c b/src/backend/utils/adt/enum.c index be4f984ed68..8f65c84d305 100644 --- a/src/backend/utils/adt/enum.c +++ b/src/backend/utils/adt/enum.c @@ -461,7 +461,7 @@ enum_range_internal(Oid enumtypoid, Oid lower, Oid upper) Datum *elems; int max, cnt; - bool left_found; + bool left_found; /* * Scan the enum members in order using pg_enum_typid_sortorder_index. @@ -486,7 +486,7 @@ enum_range_internal(Oid enumtypoid, Oid lower, Oid upper) while (HeapTupleIsValid(enum_tuple = systable_getnext_ordered(enum_scan, ForwardScanDirection))) { - Oid enum_oid = HeapTupleGetOid(enum_tuple); + Oid enum_oid = HeapTupleGetOid(enum_tuple); if (!left_found && lower == enum_oid) left_found = true; diff --git a/src/backend/utils/adt/formatting.c b/src/backend/utils/adt/formatting.c index 45e36f92e50..f895bbbb8b9 100644 --- a/src/backend/utils/adt/formatting.c +++ b/src/backend/utils/adt/formatting.c @@ -662,7 +662,7 @@ typedef enum /* last */ _DCH_last_ -} DCH_poz; +} DCH_poz; typedef enum { @@ -705,7 +705,7 @@ typedef enum /* last */ _NUM_last_ -} NUM_poz; +} NUM_poz; /* ---------- * KeyWords for DATE-TIME version @@ -1497,7 +1497,7 @@ str_tolower(const char *buff, size_t nbytes, Oid collid) #ifdef USE_WIDE_UPPER_LOWER else if (pg_database_encoding_max_length() > 1) { - pg_locale_t mylocale = 0; + pg_locale_t mylocale = 0; wchar_t *workspace; size_t curr_char; size_t result_size; @@ -1549,7 +1549,7 @@ str_tolower(const char *buff, size_t nbytes, Oid collid) #endif /* USE_WIDE_UPPER_LOWER */ else { - pg_locale_t mylocale = 0; + pg_locale_t mylocale = 0; char *p; if (collid != DEFAULT_COLLATION_OID) @@ -1618,7 +1618,7 @@ str_toupper(const char *buff, size_t nbytes, Oid collid) #ifdef USE_WIDE_UPPER_LOWER else if (pg_database_encoding_max_length() > 1) { - pg_locale_t mylocale = 0; + pg_locale_t mylocale = 0; wchar_t *workspace; size_t curr_char; size_t result_size; @@ -1670,7 +1670,7 @@ str_toupper(const char *buff, size_t nbytes, Oid collid) #endif /* USE_WIDE_UPPER_LOWER */ else { - pg_locale_t mylocale = 0; + pg_locale_t mylocale = 0; char *p; if (collid != DEFAULT_COLLATION_OID) @@ -1736,7 +1736,7 @@ str_initcap(const char *buff, size_t nbytes, Oid collid) for (p = result; *p; p++) { - char c; + char c; if (wasalnum) *p = c = pg_ascii_tolower((unsigned char) *p); @@ -1751,7 +1751,7 @@ str_initcap(const char *buff, size_t nbytes, Oid collid) #ifdef USE_WIDE_UPPER_LOWER else if (pg_database_encoding_max_length() > 1) { - pg_locale_t mylocale = 0; + pg_locale_t mylocale = 0; wchar_t *workspace; size_t curr_char; size_t result_size; @@ -1815,7 +1815,7 @@ str_initcap(const char *buff, size_t nbytes, Oid collid) #endif /* USE_WIDE_UPPER_LOWER */ else { - pg_locale_t mylocale = 0; + pg_locale_t mylocale = 0; char *p; if (collid != DEFAULT_COLLATION_OID) @@ -1838,7 +1838,7 @@ str_initcap(const char *buff, size_t nbytes, Oid collid) /* * Note: we assume that toupper_l()/tolower_l() will not be so broken - * as to need guard tests. When using the default collation, we apply + * as to need guard tests. When using the default collation, we apply * the traditional Postgres behavior that forces ASCII-style treatment * of I/i, but in non-default collations you get exactly what the * collation says. @@ -2318,7 +2318,7 @@ DCH_to_char(FormatNode *node, bool is_interval, TmToChar *in, char *out, Oid col * intervals */ sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : 2, - tm->tm_hour % (HOURS_PER_DAY / 2) == 0 ? HOURS_PER_DAY / 2 : + tm->tm_hour % (HOURS_PER_DAY / 2) == 0 ? HOURS_PER_DAY / 2 : tm->tm_hour % (HOURS_PER_DAY / 2)); if (S_THth(n->suffix)) str_numth(s, s, S_TH_TYPE(n->suffix)); @@ -2423,7 +2423,7 @@ DCH_to_char(FormatNode *node, bool is_interval, TmToChar *in, char *out, Oid col strcpy(s, str_toupper_z(localized_full_months[tm->tm_mon - 1], collid)); else sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9, - str_toupper_z(months_full[tm->tm_mon - 1], collid)); + str_toupper_z(months_full[tm->tm_mon - 1], collid)); s += strlen(s); break; case DCH_Month: diff --git a/src/backend/utils/adt/genfile.c b/src/backend/utils/adt/genfile.c index 7c59e9a20ef..6b3f77fec14 100644 --- a/src/backend/utils/adt/genfile.c +++ b/src/backend/utils/adt/genfile.c @@ -56,18 +56,19 @@ convert_and_check_filename(text *arg) /* Disallow '/a/b/data/..' */ if (path_contains_parent_reference(filename)) ereport(ERROR, - (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), - (errmsg("reference to parent directory (\"..\") not allowed")))); + (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), + (errmsg("reference to parent directory (\"..\") not allowed")))); + /* - * Allow absolute paths if within DataDir or Log_directory, even - * though Log_directory might be outside DataDir. + * Allow absolute paths if within DataDir or Log_directory, even + * though Log_directory might be outside DataDir. */ if (!path_is_prefix_of_path(DataDir, filename) && (!is_absolute_path(Log_directory) || !path_is_prefix_of_path(Log_directory, filename))) ereport(ERROR, - (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), - (errmsg("absolute path not allowed")))); + (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), + (errmsg("absolute path not allowed")))); } else if (!path_is_relative_and_below_cwd(filename)) ereport(ERROR, diff --git a/src/backend/utils/adt/like.c b/src/backend/utils/adt/like.c index b060faa6a9b..0934c69ebe5 100644 --- a/src/backend/utils/adt/like.c +++ b/src/backend/utils/adt/like.c @@ -30,19 +30,19 @@ #define LIKE_ABORT (-1) -static int SB_MatchText(char *t, int tlen, char *p, int plen, - pg_locale_t locale, bool locale_is_c); +static int SB_MatchText(char *t, int tlen, char *p, int plen, + pg_locale_t locale, bool locale_is_c); static text *SB_do_like_escape(text *, text *); -static int MB_MatchText(char *t, int tlen, char *p, int plen, - pg_locale_t locale, bool locale_is_c); +static int MB_MatchText(char *t, int tlen, char *p, int plen, + pg_locale_t locale, bool locale_is_c); static text *MB_do_like_escape(text *, text *); -static int UTF8_MatchText(char *t, int tlen, char *p, int plen, - pg_locale_t locale, bool locale_is_c); +static int UTF8_MatchText(char *t, int tlen, char *p, int plen, + pg_locale_t locale, bool locale_is_c); -static int SB_IMatchText(char *t, int tlen, char *p, int plen, - pg_locale_t locale, bool locale_is_c); +static int SB_IMatchText(char *t, int tlen, char *p, int plen, + pg_locale_t locale, bool locale_is_c); static int GenericMatchText(char *s, int slen, char *p, int plen); static int Generic_Text_IC_like(text *str, text *pat, Oid collation); @@ -188,11 +188,11 @@ Generic_Text_IC_like(text *str, text *pat, Oid collation) else { /* - * Here we need to prepare locale information for SB_lower_char. - * This should match the methods used in str_tolower(). + * Here we need to prepare locale information for SB_lower_char. This + * should match the methods used in str_tolower(). */ - pg_locale_t locale = 0; - bool locale_is_c = false; + pg_locale_t locale = 0; + bool locale_is_c = false; if (lc_ctype_is_c(collation)) locale_is_c = true; diff --git a/src/backend/utils/adt/nabstime.c b/src/backend/utils/adt/nabstime.c index 4b61b21cbed..6771e78af8e 100644 --- a/src/backend/utils/adt/nabstime.c +++ b/src/backend/utils/adt/nabstime.c @@ -182,8 +182,8 @@ tm2abstime(struct pg_tm * tm, int tz) tm->tm_mon < 1 || tm->tm_mon > MONTHS_PER_YEAR || tm->tm_mday < 1 || tm->tm_mday > 31 || tm->tm_hour < 0 || - tm->tm_hour > HOURS_PER_DAY || /* test for > 24:00:00 */ - (tm->tm_hour == HOURS_PER_DAY && (tm->tm_min > 0 || tm->tm_sec > 0)) || + tm->tm_hour > HOURS_PER_DAY || /* test for > 24:00:00 */ + (tm->tm_hour == HOURS_PER_DAY && (tm->tm_min > 0 || tm->tm_sec > 0)) || tm->tm_min < 0 || tm->tm_min > MINS_PER_HOUR - 1 || tm->tm_sec < 0 || tm->tm_sec > SECS_PER_MINUTE) return INVALID_ABSTIME; @@ -1163,7 +1163,7 @@ tintervalsame(PG_FUNCTION_ARGS) * 1. The interval length computations overflow at 2^31 seconds, causing * intervals longer than that to sort oddly compared to those shorter. * 2. infinity and minus infinity (NOEND_ABSTIME and NOSTART_ABSTIME) are - * just ordinary integers. Since this code doesn't handle them specially, + * just ordinary integers. Since this code doesn't handle them specially, * it's possible for [a b] to be considered longer than [c infinity] for * finite abstimes a, b, c. In combination with the previous point, the * interval [-infinity infinity] is treated as being shorter than many finite diff --git a/src/backend/utils/adt/network.c b/src/backend/utils/adt/network.c index 8cac11134c4..80e5915b3e5 100644 --- a/src/backend/utils/adt/network.c +++ b/src/backend/utils/adt/network.c @@ -319,7 +319,7 @@ inet_to_cidr(PG_FUNCTION_ARGS) inet *src = PG_GETARG_INET_P(0); inet *dst; int bits; - int byte; + int byte; int nbits; int maxbytes; @@ -340,15 +340,15 @@ inet_to_cidr(PG_FUNCTION_ARGS) /* clear the first byte, this might be a partial byte */ if (nbits != 0) { - ip_addr(dst)[byte] &=~(0xFF >> nbits); - byte ++; + ip_addr(dst)[byte] &= ~(0xFF >> nbits); + byte++; } /* clear remaining bytes */ maxbytes = ip_addrsize(dst); - while (byte <maxbytes) + while (byte < maxbytes) { ip_addr(dst)[byte] = 0; - byte ++; + byte++; } PG_RETURN_INET_P(dst); @@ -384,7 +384,7 @@ cidr_set_masklen(PG_FUNCTION_ARGS) inet *src = PG_GETARG_INET_P(0); int bits = PG_GETARG_INT32(1); inet *dst; - int byte; + int byte; int nbits; int maxbytes; @@ -409,15 +409,15 @@ cidr_set_masklen(PG_FUNCTION_ARGS) /* clear the first byte, this might be a partial byte */ if (nbits != 0) { - ip_addr(dst)[byte] &=~(0xFF >> nbits); - byte ++; + ip_addr(dst)[byte] &= ~(0xFF >> nbits); + byte++; } /* clear remaining bytes */ maxbytes = ip_addrsize(dst); - while (byte <maxbytes) + while (byte < maxbytes) { ip_addr(dst)[byte] = 0; - byte ++; + byte++; } PG_RETURN_INET_P(dst); @@ -716,7 +716,7 @@ network_broadcast(PG_FUNCTION_ARGS) { inet *ip = PG_GETARG_INET_P(0); inet *dst; - int byte; + int byte; int bits; int maxbytes; unsigned char mask; @@ -735,7 +735,7 @@ network_broadcast(PG_FUNCTION_ARGS) a = ip_addr(ip); b = ip_addr(dst); - for (byte = 0; byte <maxbytes; byte ++) + for (byte = 0; byte < maxbytes; byte++) { if (bits >= 8) { @@ -750,7 +750,7 @@ network_broadcast(PG_FUNCTION_ARGS) bits = 0; } - b[byte] = a[byte] |mask; + b[byte] = a[byte] | mask; } ip_family(dst) = ip_family(ip); @@ -765,7 +765,7 @@ network_network(PG_FUNCTION_ARGS) { inet *ip = PG_GETARG_INET_P(0); inet *dst; - int byte; + int byte; int bits; unsigned char mask; unsigned char *a, @@ -793,8 +793,8 @@ network_network(PG_FUNCTION_ARGS) bits = 0; } - b[byte] = a[byte] &mask; - byte ++; + b[byte] = a[byte] & mask; + byte++; } ip_family(dst) = ip_family(ip); @@ -809,7 +809,7 @@ network_netmask(PG_FUNCTION_ARGS) { inet *ip = PG_GETARG_INET_P(0); inet *dst; - int byte; + int byte; int bits; unsigned char mask; unsigned char *b; @@ -836,7 +836,7 @@ network_netmask(PG_FUNCTION_ARGS) } b[byte] = mask; - byte ++; + byte++; } ip_family(dst) = ip_family(ip); @@ -851,7 +851,7 @@ network_hostmask(PG_FUNCTION_ARGS) { inet *ip = PG_GETARG_INET_P(0); inet *dst; - int byte; + int byte; int bits; int maxbytes; unsigned char mask; @@ -884,7 +884,7 @@ network_hostmask(PG_FUNCTION_ARGS) } b[byte] = mask; - byte --; + byte--; } ip_family(dst) = ip_family(ip); @@ -994,7 +994,7 @@ bitncmp(void *l, void *r, int n) static bool addressOK(unsigned char *a, int bits, int family) { - int byte; + int byte; int nbits; int maxbits; int maxbytes; @@ -1022,12 +1022,12 @@ addressOK(unsigned char *a, int bits, int family) if (bits != 0) mask >>= nbits; - while (byte <maxbytes) + while (byte < maxbytes) { - if ((a[byte] &mask) != 0) + if ((a[byte] & mask) != 0) return false; mask = 0xff; - byte ++; + byte++; } return true; @@ -1396,7 +1396,7 @@ inetmi(PG_FUNCTION_ARGS) * two's complement, too bad. */ int nb = ip_addrsize(ip); - int byte = 0; + int byte = 0; unsigned char *pip = ip_addr(ip); unsigned char *pip2 = ip_addr(ip2); int carry = 1; @@ -1407,9 +1407,9 @@ inetmi(PG_FUNCTION_ARGS) carry = pip[nb] + (~pip2[nb] & 0xFF) + carry; lobyte = carry & 0xFF; - if (byte <sizeof(int64)) + if (byte < sizeof(int64)) { - res |= ((int64) lobyte) << (byte *8); + res |= ((int64) lobyte) << (byte * 8); } else { @@ -1424,15 +1424,15 @@ inetmi(PG_FUNCTION_ARGS) errmsg("result is out of range"))); } carry >>= 8; - byte ++; + byte++; } /* * If input is narrower than int64, overflow is not possible, but we * have to do proper sign extension. */ - if (carry == 0 && byte <sizeof(int64)) - res |= ((int64) -1) << (byte *8); + if (carry == 0 && byte < sizeof(int64)) + res |= ((int64) -1) << (byte * 8); } PG_RETURN_INT64(res); diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c index eec89aa54f2..6b60a5c1c78 100644 --- a/src/backend/utils/adt/numeric.c +++ b/src/backend/utils/adt/numeric.c @@ -94,11 +94,11 @@ typedef int16 NumericDigit; * If the high bits of the first word of a NumericChoice (n_header, or * n_short.n_header, or n_long.n_sign_dscale) are NUMERIC_SHORT, then the * numeric follows the NumericShort format; if they are NUMERIC_POS or - * NUMERIC_NEG, it follows the NumericLong format. If they are NUMERIC_NAN, + * NUMERIC_NEG, it follows the NumericLong format. If they are NUMERIC_NAN, * it is a NaN. We currently always store a NaN using just two bytes (i.e. * only n_header), but previous releases used only the NumericLong format, * so we might find 4-byte NaNs on disk if a database has been migrated using - * pg_upgrade. In either case, when the high bits indicate a NaN, the + * pg_upgrade. In either case, when the high bits indicate a NaN, the * remaining bits are never examined. Currently, we always initialize these * to zero, but it might be possible to use them for some other purpose in * the future. @@ -134,14 +134,14 @@ struct NumericLong union NumericChoice { uint16 n_header; /* Header word */ - struct NumericLong n_long; /* Long form (4-byte header) */ - struct NumericShort n_short; /* Short form (2-byte header) */ + struct NumericLong n_long; /* Long form (4-byte header) */ + struct NumericShort n_short; /* Short form (2-byte header) */ }; struct NumericData { int32 vl_len_; /* varlena header (do not touch directly!) */ - union NumericChoice choice; /* choice of format */ + union NumericChoice choice; /* choice of format */ }; @@ -160,7 +160,7 @@ struct NumericData #define NUMERIC_IS_SHORT(n) (NUMERIC_FLAGBITS(n) == NUMERIC_SHORT) #define NUMERIC_HDRSZ (VARHDRSZ + sizeof(uint16) + sizeof(int16)) -#define NUMERIC_HDRSZ_SHORT (VARHDRSZ + sizeof(uint16)) +#define NUMERIC_HDRSZ_SHORT (VARHDRSZ + sizeof(uint16)) /* * If the flag bits are NUMERIC_SHORT or NUMERIC_NAN, we want the short header; @@ -189,7 +189,7 @@ struct NumericData * Extract sign, display scale, weight. */ -#define NUMERIC_DSCALE_MASK 0x3FFF +#define NUMERIC_DSCALE_MASK 0x3FFF #define NUMERIC_SIGN(n) \ (NUMERIC_IS_SHORT(n) ? \ @@ -551,7 +551,7 @@ numeric_out(PG_FUNCTION_ARGS) /* * numeric_is_nan() - * - * Is Numeric value a NaN? + * Is Numeric value a NaN? */ bool numeric_is_nan(Numeric num) @@ -562,13 +562,13 @@ numeric_is_nan(Numeric num) /* * numeric_maximum_size() - * - * Maximum size of a numeric with given typmod, or -1 if unlimited/unknown. + * Maximum size of a numeric with given typmod, or -1 if unlimited/unknown. */ int32 numeric_maximum_size(int32 typmod) { - int precision; - int numeric_digits; + int precision; + int numeric_digits; if (typmod < (int32) (VARHDRSZ)) return -1; @@ -577,23 +577,23 @@ numeric_maximum_size(int32 typmod) precision = ((typmod - VARHDRSZ) >> 16) & 0xffff; /* - * This formula computes the maximum number of NumericDigits we could - * need in order to store the specified number of decimal digits. - * Because the weight is stored as a number of NumericDigits rather - * than a number of decimal digits, it's possible that the first - * NumericDigit will contain only a single decimal digit. Thus, the - * first two decimal digits can require two NumericDigits to store, - * but it isn't until we reach DEC_DIGITS + 2 decimal digits that we - * potentially need a third NumericDigit. + * This formula computes the maximum number of NumericDigits we could need + * in order to store the specified number of decimal digits. Because the + * weight is stored as a number of NumericDigits rather than a number of + * decimal digits, it's possible that the first NumericDigit will contain + * only a single decimal digit. Thus, the first two decimal digits can + * require two NumericDigits to store, but it isn't until we reach + * DEC_DIGITS + 2 decimal digits that we potentially need a third + * NumericDigit. */ numeric_digits = (precision + 2 * (DEC_DIGITS - 1)) / DEC_DIGITS; /* * In most cases, the size of a numeric will be smaller than the value * computed below, because the varlena header will typically get toasted - * down to a single byte before being stored on disk, and it may also - * be possible to use a short numeric header. But our job here is to - * compute the worst case. + * down to a single byte before being stored on disk, and it may also be + * possible to use a short numeric header. But our job here is to compute + * the worst case. */ return NUMERIC_HDRSZ + (numeric_digits * sizeof(NumericDigit)); } @@ -761,12 +761,13 @@ numeric (PG_FUNCTION_ARGS) * If the number is certainly in bounds and due to the target scale no * rounding could be necessary, just make a copy of the input and modify * its scale fields, unless the larger scale forces us to abandon the - * short representation. (Note we assume the existing dscale is honest...) + * short representation. (Note we assume the existing dscale is + * honest...) */ ddigits = (NUMERIC_WEIGHT(num) + 1) * DEC_DIGITS; if (ddigits <= maxdigits && scale >= NUMERIC_DSCALE(num) && (NUMERIC_CAN_BE_SHORT(scale, NUMERIC_WEIGHT(num)) - || !NUMERIC_IS_SHORT(num))) + || !NUMERIC_IS_SHORT(num))) { new = (Numeric) palloc(VARSIZE(num)); memcpy(new, num, VARSIZE(num)); @@ -1427,7 +1428,7 @@ hash_numeric(PG_FUNCTION_ARGS) int end_offset; int i; int hash_len; - NumericDigit *digits; + NumericDigit *digits; /* If it's NaN, don't try to hash the rest of the fields */ if (NUMERIC_IS_NAN(key)) @@ -3727,7 +3728,7 @@ make_result(NumericVar *var) SET_VARSIZE(result, len); result->choice.n_short.n_header = (sign == NUMERIC_NEG ? (NUMERIC_SHORT | NUMERIC_SHORT_SIGN_MASK) - : NUMERIC_SHORT) + : NUMERIC_SHORT) | (var->dscale << NUMERIC_SHORT_DSCALE_SHIFT) | (weight < 0 ? NUMERIC_SHORT_WEIGHT_SIGN_MASK : 0) | (weight & NUMERIC_SHORT_WEIGHT_MASK); diff --git a/src/backend/utils/adt/numutils.c b/src/backend/utils/adt/numutils.c index 38ce38821e1..37d208994c1 100644 --- a/src/backend/utils/adt/numutils.c +++ b/src/backend/utils/adt/numutils.c @@ -136,7 +136,7 @@ pg_ltoa(int32 value, char *a) * Avoid problems with the most negative integer not being representable * as a positive integer. */ - if (value == (-2147483647-1)) + if (value == (-2147483647 - 1)) { memcpy(a, "-2147483648", 12); return; @@ -150,8 +150,8 @@ pg_ltoa(int32 value, char *a) /* Compute the result string backwards. */ do { - int32 remainder; - int32 oldval = value; + int32 remainder; + int32 oldval = value; value /= 10; remainder = oldval - value * 10; @@ -167,7 +167,7 @@ pg_ltoa(int32 value, char *a) /* Reverse string. */ while (start < a) { - char swap = *start; + char swap = *start; *start++ = *a; *a-- = swap; @@ -190,7 +190,7 @@ pg_lltoa(int64 value, char *a) * Avoid problems with the most negative integer not being representable * as a positive integer. */ - if (value == (-INT64CONST(0x7FFFFFFFFFFFFFFF)-1)) + if (value == (-INT64CONST(0x7FFFFFFFFFFFFFFF) - 1)) { memcpy(a, "-9223372036854775808", 21); return; @@ -204,8 +204,8 @@ pg_lltoa(int64 value, char *a) /* Compute the result string backwards. */ do { - int64 remainder; - int64 oldval = value; + int64 remainder; + int64 oldval = value; value /= 10; remainder = oldval - value * 10; @@ -221,7 +221,7 @@ pg_lltoa(int64 value, char *a) /* Reverse string. */ while (start < a) { - char swap = *start; + char swap = *start; *start++ = *a; *a-- = swap; diff --git a/src/backend/utils/adt/pg_locale.c b/src/backend/utils/adt/pg_locale.c index 09ff926cba6..0e6723d4690 100644 --- a/src/backend/utils/adt/pg_locale.c +++ b/src/backend/utils/adt/pg_locale.c @@ -107,7 +107,7 @@ typedef struct bool collate_is_c; /* is collation's LC_COLLATE C? */ bool ctype_is_c; /* is collation's LC_CTYPE C? */ bool flags_valid; /* true if above flags are valid */ - pg_locale_t locale; /* locale_t struct, or 0 if not valid */ + pg_locale_t locale; /* locale_t struct, or 0 if not valid */ } collation_cache_entry; static HTAB *collation_cache = NULL; @@ -242,7 +242,7 @@ check_locale(int category, const char *value) * * For most locale categories, the assign hook doesn't actually set the locale * permanently, just reset flags so that the next use will cache the - * appropriate values. (See explanation at the top of this file.) + * appropriate values. (See explanation at the top of this file.) * * Note: we accept value = "" as selecting the postmaster's environment * value, whatever it was (so long as the environment setting is legal). @@ -728,7 +728,6 @@ IsoLocaleName(const char *winlocname) return NULL; /* Not supported on this version of msvc/mingw */ #endif /* _MSC_VER >= 1400 */ } - #endif /* WIN32 && LC_MESSAGES */ @@ -750,7 +749,7 @@ IsoLocaleName(const char *winlocname) * could fail if the locale is C, so str_tolower() shouldn't call it * in that case. * - * Note that we currently lack any way to flush the cache. Since we don't + * Note that we currently lack any way to flush the cache. Since we don't * support ALTER COLLATION, this is OK. The worst case is that someone * drops a collation, and a useless cache entry hangs around in existing * backends. @@ -826,15 +825,15 @@ bool lc_collate_is_c(Oid collation) { /* - * If we're asked about "collation 0", return false, so that the code - * will go into the non-C path and report that the collation is bogus. + * If we're asked about "collation 0", return false, so that the code will + * go into the non-C path and report that the collation is bogus. */ if (!OidIsValid(collation)) return false; /* - * If we're asked about the default collation, we have to inquire of - * the C library. Cache the result so we only have to compute it once. + * If we're asked about the default collation, we have to inquire of the C + * library. Cache the result so we only have to compute it once. */ if (collation == DEFAULT_COLLATION_OID) { @@ -876,15 +875,15 @@ bool lc_ctype_is_c(Oid collation) { /* - * If we're asked about "collation 0", return false, so that the code - * will go into the non-C path and report that the collation is bogus. + * If we're asked about "collation 0", return false, so that the code will + * go into the non-C path and report that the collation is bogus. */ if (!OidIsValid(collation)) return false; /* - * If we're asked about the default collation, we have to inquire of - * the C library. Cache the result so we only have to compute it once. + * If we're asked about the default collation, we have to inquire of the C + * library. Cache the result so we only have to compute it once. */ if (collation == DEFAULT_COLLATION_OID) { @@ -921,7 +920,7 @@ lc_ctype_is_c(Oid collation) /* - * Create a locale_t from a collation OID. Results are cached for the + * Create a locale_t from a collation OID. Results are cached for the * lifetime of the backend. Thus, do not free the result with freelocale(). * * As a special optimization, the default/database collation returns 0. @@ -987,7 +986,7 @@ pg_newlocale_from_collation(Oid collid) { #ifndef WIN32 /* We need two newlocale() steps */ - locale_t loc1; + locale_t loc1; loc1 = newlocale(LC_COLLATE_MASK, collcollate, NULL); if (!loc1) @@ -1002,10 +1001,11 @@ pg_newlocale_from_collation(Oid collid) errmsg("could not create locale \"%s\": %m", collctype))); #else + /* - * XXX The _create_locale() API doesn't appear to support - * this. Could perhaps be worked around by changing - * pg_locale_t to contain two separate fields. + * XXX The _create_locale() API doesn't appear to support this. + * Could perhaps be worked around by changing pg_locale_t to + * contain two separate fields. */ ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), @@ -1016,8 +1016,7 @@ pg_newlocale_from_collation(Oid collid) cache_entry->locale = result; ReleaseSysCache(tp); - -#else /* not HAVE_LOCALE_T */ +#else /* not HAVE_LOCALE_T */ /* * For platforms that don't support locale_t, we can't do anything @@ -1025,8 +1024,8 @@ pg_newlocale_from_collation(Oid collid) */ ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("nondefault collations are not supported on this platform"))); -#endif /* not HAVE_LOCALE_T */ + errmsg("nondefault collations are not supported on this platform"))); +#endif /* not HAVE_LOCALE_T */ } return cache_entry->locale; diff --git a/src/backend/utils/adt/pgstatfuncs.c b/src/backend/utils/adt/pgstatfuncs.c index 137c811bc3a..f811245cea0 100644 --- a/src/backend/utils/adt/pgstatfuncs.c +++ b/src/backend/utils/adt/pgstatfuncs.c @@ -364,7 +364,7 @@ pg_stat_get_vacuum_count(PG_FUNCTION_ARGS) { Oid relid = PG_GETARG_OID(0); int64 result; - PgStat_StatTabEntry *tabentry; + PgStat_StatTabEntry *tabentry; if ((tabentry = pgstat_fetch_stat_tabentry(relid)) == NULL) result = 0; @@ -379,7 +379,7 @@ pg_stat_get_autovacuum_count(PG_FUNCTION_ARGS) { Oid relid = PG_GETARG_OID(0); int64 result; - PgStat_StatTabEntry *tabentry; + PgStat_StatTabEntry *tabentry; if ((tabentry = pgstat_fetch_stat_tabentry(relid)) == NULL) result = 0; @@ -394,7 +394,7 @@ pg_stat_get_analyze_count(PG_FUNCTION_ARGS) { Oid relid = PG_GETARG_OID(0); int64 result; - PgStat_StatTabEntry *tabentry; + PgStat_StatTabEntry *tabentry; if ((tabentry = pgstat_fetch_stat_tabentry(relid)) == NULL) result = 0; @@ -409,7 +409,7 @@ pg_stat_get_autoanalyze_count(PG_FUNCTION_ARGS) { Oid relid = PG_GETARG_OID(0); int64 result; - PgStat_StatTabEntry *tabentry; + PgStat_StatTabEntry *tabentry; if ((tabentry = pgstat_fetch_stat_tabentry(relid)) == NULL) result = 0; @@ -1263,11 +1263,11 @@ pg_stat_get_db_conflict_all(PG_FUNCTION_ARGS) result = 0; else result = (int64) ( - dbentry->n_conflict_tablespace + - dbentry->n_conflict_lock + - dbentry->n_conflict_snapshot + - dbentry->n_conflict_bufferpin + - dbentry->n_conflict_startup_deadlock); + dbentry->n_conflict_tablespace + + dbentry->n_conflict_lock + + dbentry->n_conflict_snapshot + + dbentry->n_conflict_bufferpin + + dbentry->n_conflict_startup_deadlock); PG_RETURN_INT64(result); } diff --git a/src/backend/utils/adt/ri_triggers.c b/src/backend/utils/adt/ri_triggers.c index 591d2eb16b0..84797191efa 100644 --- a/src/backend/utils/adt/ri_triggers.c +++ b/src/backend/utils/adt/ri_triggers.c @@ -2608,7 +2608,7 @@ RI_FKey_keyequal_upd_fk(Trigger *trigger, Relation fk_rel, * This is not a trigger procedure, but is called during ALTER TABLE * ADD FOREIGN KEY to validate the initial table contents. * - * We expect that the caller has made provision to prevent any problems + * We expect that the caller has made provision to prevent any problems * caused by concurrent actions. This could be either by locking rel and * pkrel at ShareRowExclusiveLock or higher, or by otherwise ensuring * that triggers implementing the checks are already active. @@ -2629,8 +2629,8 @@ RI_Initial_Check(Trigger *trigger, Relation fk_rel, Relation pk_rel) char fkrelname[MAX_QUOTED_REL_NAME_LEN]; char pkattname[MAX_QUOTED_NAME_LEN + 3]; char fkattname[MAX_QUOTED_NAME_LEN + 3]; - RangeTblEntry *pkrte; - RangeTblEntry *fkrte; + RangeTblEntry *pkrte; + RangeTblEntry *fkrte; const char *sep; int i; int old_work_mem; @@ -2662,7 +2662,7 @@ RI_Initial_Check(Trigger *trigger, Relation fk_rel, Relation pk_rel) for (i = 0; i < riinfo.nkeys; i++) { - int attno; + int attno; attno = riinfo.pk_attnums[i] - FirstLowInvalidHeapAttributeNumber; pkrte->selectedCols = bms_add_member(pkrte->selectedCols, attno); @@ -2789,10 +2789,10 @@ RI_Initial_Check(Trigger *trigger, Relation fk_rel, Relation pk_rel) /* * Run the plan. For safety we force a current snapshot to be used. (In - * transaction-snapshot mode, this arguably violates transaction - * isolation rules, but we really haven't got much choice.) - * We don't need to register the snapshot, because SPI_execute_snapshot - * will see to it. We need at most one tuple returned, so pass limit = 1. + * transaction-snapshot mode, this arguably violates transaction isolation + * rules, but we really haven't got much choice.) We don't need to + * register the snapshot, because SPI_execute_snapshot will see to it. We + * need at most one tuple returned, so pass limit = 1. */ spi_result = SPI_execute_snapshot(qplan, NULL, NULL, @@ -3337,8 +3337,8 @@ ri_PerformCheck(RI_QueryKey *qkey, SPIPlanPtr qplan, /* * In READ COMMITTED mode, we just need to use an up-to-date regular * snapshot, and we will see all rows that could be interesting. But in - * transaction-snapshot mode, we can't change the transaction snapshot. - * If the caller passes detectNewRows == false then it's okay to do the query + * transaction-snapshot mode, we can't change the transaction snapshot. If + * the caller passes detectNewRows == false then it's okay to do the query * with the transaction snapshot; otherwise we use a current snapshot, and * tell the executor to error out if it finds any rows under the current * snapshot that wouldn't be visible per the transaction snapshot. Note diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c index 326079a75ba..e436a1ee59f 100644 --- a/src/backend/utils/adt/ruleutils.c +++ b/src/backend/utils/adt/ruleutils.c @@ -169,11 +169,11 @@ static void set_deparse_planstate(deparse_namespace *dpns, PlanState *ps); static void push_child_plan(deparse_namespace *dpns, PlanState *ps, deparse_namespace *save_dpns); static void pop_child_plan(deparse_namespace *dpns, - deparse_namespace *save_dpns); + deparse_namespace *save_dpns); static void push_ancestor_plan(deparse_namespace *dpns, ListCell *ancestor_cell, deparse_namespace *save_dpns); static void pop_ancestor_plan(deparse_namespace *dpns, - deparse_namespace *save_dpns); + deparse_namespace *save_dpns); static void make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, int prettyFlags); static void make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, @@ -948,7 +948,7 @@ pg_get_indexdef_worker(Oid indexrelid, int colno, if (!attrsOnly && (!colno || colno == keyno + 1)) { - Oid indcoll; + Oid indcoll; /* Add collation, if not default for column */ indcoll = indcollation->values[keyno]; @@ -2207,7 +2207,7 @@ set_deparse_planstate(deparse_namespace *dpns, PlanState *ps) * We special-case Append and MergeAppend to pretend that the first child * plan is the OUTER referent; we have to interpret OUTER Vars in their * tlists according to one of the children, and the first one is the most - * natural choice. Likewise special-case ModifyTable to pretend that the + * natural choice. Likewise special-case ModifyTable to pretend that the * first child plan is the OUTER referent; this is to support RETURNING * lists containing references to non-target relations. */ @@ -2263,8 +2263,8 @@ push_child_plan(deparse_namespace *dpns, PlanState *ps, /* * Currently we don't bother to adjust the ancestors list, because an - * OUTER or INNER reference really shouldn't contain any Params that - * would be set by the parent node itself. If we did want to adjust it, + * OUTER or INNER reference really shouldn't contain any Params that would + * be set by the parent node itself. If we did want to adjust it, * lcons'ing dpns->planstate onto dpns->ancestors would be the appropriate * thing --- and pop_child_plan would need to undo the change to the list. */ @@ -3780,8 +3780,8 @@ get_variable(Var *var, int levelsup, bool showstar, deparse_context *context) * subquery's alias, that's not possible for resjunk items since they have * no alias. So in that case, drill down to the subplan and print the * contents of the referenced tlist item. This works because in a plan - * tree, such Vars can only occur in a SubqueryScan or CteScan node, - * and we'll have set dpns->inner_plan to reference the child plan node. + * tree, such Vars can only occur in a SubqueryScan or CteScan node, and + * we'll have set dpns->inner_plan to reference the child plan node. */ if ((rte->rtekind == RTE_SUBQUERY || rte->rtekind == RTE_CTE) && attnum > list_length(rte->eref->colnames) && @@ -4145,7 +4145,7 @@ get_name_for_var_field(Var *var, int fieldno, if (lc != NULL) { Query *ctequery = (Query *) cte->ctequery; - TargetEntry *ste = get_tle_by_resno(GetCTETargetList(cte), + TargetEntry *ste = get_tle_by_resno(GetCTETargetList(cte), attnum); if (ste == NULL || ste->resjunk) @@ -4279,11 +4279,11 @@ static void get_parameter(Param *param, deparse_context *context) { /* - * If it's a PARAM_EXEC parameter, try to locate the expression from - * which the parameter was computed. This will necessarily be in some - * ancestor of the current expression's PlanState. Note that failing - * to find a referent isn't an error, since the Param might well be a - * subplan output rather than an input. + * If it's a PARAM_EXEC parameter, try to locate the expression from which + * the parameter was computed. This will necessarily be in some ancestor + * of the current expression's PlanState. Note that failing to find a + * referent isn't an error, since the Param might well be a subplan output + * rather than an input. */ if (param->paramkind == PARAM_EXEC) { @@ -4302,9 +4302,9 @@ get_parameter(Param *param, deparse_context *context) ListCell *lc2; /* - * NestLoops transmit params to their inner child only; also, - * once we've crawled up out of a subplan, this couldn't - * possibly be the right match. + * NestLoops transmit params to their inner child only; also, once + * we've crawled up out of a subplan, this couldn't possibly be + * the right match. */ if (IsA(ps, NestLoopState) && child_ps == innerPlanState(ps) && @@ -4314,7 +4314,7 @@ get_parameter(Param *param, deparse_context *context) foreach(lc2, nl->nestParams) { - NestLoopParam *nlp = (NestLoopParam *) lfirst(lc2); + NestLoopParam *nlp = (NestLoopParam *) lfirst(lc2); if (nlp->paramno == param->paramid) { @@ -4342,8 +4342,8 @@ get_parameter(Param *param, deparse_context *context) /* Matched subplan, so check its arguments */ forboth(lc3, subplan->parParam, lc4, subplan->args) { - int paramid = lfirst_int(lc3); - Node *arg = (Node *) lfirst(lc4); + int paramid = lfirst_int(lc3); + Node *arg = (Node *) lfirst(lc4); if (paramid == param->paramid) { @@ -4898,7 +4898,7 @@ get_rule_expr(Node *node, deparse_context *context, appendStringInfo(buf, " %s %s (", generate_operator_name(expr->opno, exprType(arg1), - get_base_element_type(exprType(arg2))), + get_base_element_type(exprType(arg2))), expr->useOr ? "ANY" : "ALL"); get_rule_expr_paren(arg2, context, true, node); appendStringInfoChar(buf, ')'); @@ -6126,7 +6126,7 @@ get_const_collation(Const *constval, deparse_context *context) if (OidIsValid(constval->constcollid)) { - Oid typcollation = get_typcollation(constval->consttype); + Oid typcollation = get_typcollation(constval->consttype); if (constval->constcollid != typcollation) { @@ -6384,7 +6384,7 @@ get_from_clause_item(Node *jtnode, Query *query, deparse_context *context) gavealias = true; } else if (rte->rtekind == RTE_RELATION && - strcmp(rte->eref->aliasname, get_relation_name(rte->relid)) != 0) + strcmp(rte->eref->aliasname, get_relation_name(rte->relid)) != 0) { /* * Apparently the rel has been renamed since the rule was made. diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c index 092dc15a02b..41c5202146d 100644 --- a/src/backend/utils/adt/selfuncs.c +++ b/src/backend/utils/adt/selfuncs.c @@ -6329,28 +6329,28 @@ gincostestimate(PG_FUNCTION_ARGS) Cost *indexTotalCost = (Cost *) PG_GETARG_POINTER(6); Selectivity *indexSelectivity = (Selectivity *) PG_GETARG_POINTER(7); double *indexCorrelation = (double *) PG_GETARG_POINTER(8); - ListCell *l; - List *selectivityQuals; - double numPages = index->pages, - numTuples = index->tuples; - double numEntryPages, - numDataPages, - numPendingPages, - numEntries; - bool haveFullScan = false; - double partialEntriesInQuals = 0.0; - double searchEntriesInQuals = 0.0; - double exactEntriesInQuals = 0.0; - double entryPagesFetched, - dataPagesFetched, - dataPagesFetchedBySel; - double qual_op_cost, - qual_arg_cost, - spc_random_page_cost, - num_scans; - QualCost index_qual_cost; - Relation indexRel; - GinStatsData ginStats; + ListCell *l; + List *selectivityQuals; + double numPages = index->pages, + numTuples = index->tuples; + double numEntryPages, + numDataPages, + numPendingPages, + numEntries; + bool haveFullScan = false; + double partialEntriesInQuals = 0.0; + double searchEntriesInQuals = 0.0; + double exactEntriesInQuals = 0.0; + double entryPagesFetched, + dataPagesFetched, + dataPagesFetchedBySel; + double qual_op_cost, + qual_arg_cost, + spc_random_page_cost, + num_scans; + QualCost index_qual_cost; + Relation indexRel; + GinStatsData ginStats; /* * Obtain statistic information from the meta page @@ -6366,7 +6366,7 @@ gincostestimate(PG_FUNCTION_ARGS) /* * nPendingPages can be trusted, but the other fields are as of the last - * VACUUM. Scale them by the ratio numPages / nTotalPages to account for + * VACUUM. Scale them by the ratio numPages / nTotalPages to account for * growth since then. If the fields are zero (implying no VACUUM at all, * and an index created pre-9.1), assume all pages are entry pages. */ @@ -6374,11 +6374,11 @@ gincostestimate(PG_FUNCTION_ARGS) { numEntryPages = numPages; numDataPages = 0; - numEntries = numTuples; /* bogus, but no other info available */ + numEntries = numTuples; /* bogus, but no other info available */ } else { - double scale = numPages / ginStats.nTotalPages; + double scale = numPages / ginStats.nTotalPages; numEntryPages = ceil(numEntryPages * scale); numDataPages = ceil(numDataPages * scale); @@ -6389,7 +6389,8 @@ gincostestimate(PG_FUNCTION_ARGS) } /* - * Include predicate in selectivityQuals (should match genericcostestimate) + * Include predicate in selectivityQuals (should match + * genericcostestimate) */ if (index->indpred != NIL) { @@ -6411,12 +6412,12 @@ gincostestimate(PG_FUNCTION_ARGS) /* Estimate the fraction of main-table tuples that will be visited */ *indexSelectivity = clauselist_selectivity(root, selectivityQuals, - index->rel->relid, - JOIN_INNER, - NULL); + index->rel->relid, + JOIN_INNER, + NULL); /* fetch estimated page cost for schema containing index */ - get_tablespace_page_costs(index->reltablespace, + get_tablespace_page_costs(index->reltablespace, &spc_random_page_cost, NULL); @@ -6430,22 +6431,22 @@ gincostestimate(PG_FUNCTION_ARGS) */ foreach(l, indexQuals) { - RestrictInfo *rinfo = (RestrictInfo *) lfirst(l); - Expr *clause; - Node *leftop, - *rightop, - *operand; - Oid extractProcOid; - Oid clause_op; - int strategy_op; - Oid lefttype, - righttype; - int32 nentries = 0; - bool *partial_matches = NULL; - Pointer *extra_data = NULL; - bool *nullFlags = NULL; - int32 searchMode = GIN_SEARCH_MODE_DEFAULT; - int indexcol; + RestrictInfo *rinfo = (RestrictInfo *) lfirst(l); + Expr *clause; + Node *leftop, + *rightop, + *operand; + Oid extractProcOid; + Oid clause_op; + int strategy_op; + Oid lefttype, + righttype; + int32 nentries = 0; + bool *partial_matches = NULL; + Pointer *extra_data = NULL; + bool *nullFlags = NULL; + int32 searchMode = GIN_SEARCH_MODE_DEFAULT; + int indexcol; Assert(IsA(rinfo, RestrictInfo)); clause = rinfo->clause; @@ -6466,16 +6467,16 @@ gincostestimate(PG_FUNCTION_ARGS) else { elog(ERROR, "could not match index to operand"); - operand = NULL; /* keep compiler quiet */ + operand = NULL; /* keep compiler quiet */ } if (IsA(operand, RelabelType)) operand = (Node *) ((RelabelType *) operand)->arg; /* - * It's impossible to call extractQuery method for unknown operand. - * So unless operand is a Const we can't do much; just assume there - * will be one ordinary search entry from the operand at runtime. + * It's impossible to call extractQuery method for unknown operand. So + * unless operand is a Const we can't do much; just assume there will + * be one ordinary search entry from the operand at runtime. */ if (!IsA(operand, Const)) { @@ -6484,7 +6485,7 @@ gincostestimate(PG_FUNCTION_ARGS) } /* If Const is null, there can be no matches */ - if (((Const*) operand)->constisnull) + if (((Const *) operand)->constisnull) { *indexStartupCost = 0; *indexTotalCost = 0; @@ -6494,9 +6495,9 @@ gincostestimate(PG_FUNCTION_ARGS) /* * Get the operator's strategy number and declared input data types - * within the index opfamily. (We don't need the latter, but we - * use get_op_opfamily_properties because it will throw error if - * it fails to find a matching pg_amop entry.) + * within the index opfamily. (We don't need the latter, but we use + * get_op_opfamily_properties because it will throw error if it fails + * to find a matching pg_amop entry.) */ get_op_opfamily_properties(clause_op, index->opfamily[indexcol], false, &strategy_op, &lefttype, &righttype); @@ -6515,12 +6516,12 @@ gincostestimate(PG_FUNCTION_ARGS) { /* should not happen; throw same error as index_getprocinfo */ elog(ERROR, "missing support function %d for attribute %d of index \"%s\"", - GIN_EXTRACTQUERY_PROC, indexcol+1, + GIN_EXTRACTQUERY_PROC, indexcol + 1, get_rel_name(index->indexoid)); } OidFunctionCall7(extractProcOid, - ((Const*) operand)->constvalue, + ((Const *) operand)->constvalue, PointerGetDatum(&nentries), UInt16GetDatum(strategy_op), PointerGetDatum(&partial_matches), @@ -6538,9 +6539,9 @@ gincostestimate(PG_FUNCTION_ARGS) } else { - int32 i; + int32 i; - for (i=0; i<nentries; i++) + for (i = 0; i < nentries; i++) { /* * For partial match we haven't any information to estimate @@ -6585,32 +6586,30 @@ gincostestimate(PG_FUNCTION_ARGS) num_scans = 1; /* - * cost to begin scan, first of all, pay attention to - * pending list. + * cost to begin scan, first of all, pay attention to pending list. */ entryPagesFetched = numPendingPages; /* * Estimate number of entry pages read. We need to do * searchEntriesInQuals searches. Use a power function as it should be, - * but tuples on leaf pages usually is much greater. - * Here we include all searches in entry tree, including - * search of first entry in partial match algorithm + * but tuples on leaf pages usually is much greater. Here we include all + * searches in entry tree, including search of first entry in partial + * match algorithm */ entryPagesFetched += ceil(searchEntriesInQuals * rint(pow(numEntryPages, 0.15))); /* - * Add an estimate of entry pages read by partial match algorithm. - * It's a scan over leaf pages in entry tree. We haven't any useful stats - * here, so estimate it as proportion. + * Add an estimate of entry pages read by partial match algorithm. It's a + * scan over leaf pages in entry tree. We haven't any useful stats here, + * so estimate it as proportion. */ entryPagesFetched += ceil(numEntryPages * partialEntriesInQuals / numEntries); /* - * Partial match algorithm reads all data pages before - * doing actual scan, so it's a startup cost. Again, - * we havn't any useful stats here, so, estimate it as - * proportion + * Partial match algorithm reads all data pages before doing actual scan, + * so it's a startup cost. Again, we havn't any useful stats here, so, + * estimate it as proportion */ dataPagesFetched = ceil(numDataPages * partialEntriesInQuals / numEntries); @@ -6626,8 +6625,8 @@ gincostestimate(PG_FUNCTION_ARGS) } /* - * Here we use random page cost because logically-close pages could be - * far apart on disk. + * Here we use random page cost because logically-close pages could be far + * apart on disk. */ *indexStartupCost = (entryPagesFetched + dataPagesFetched) * spc_random_page_cost; @@ -6639,16 +6638,16 @@ gincostestimate(PG_FUNCTION_ARGS) * capacity of data page. */ dataPagesFetchedBySel = ceil(*indexSelectivity * - (numTuples / (BLCKSZ/SizeOfIptrData))); + (numTuples / (BLCKSZ / SizeOfIptrData))); if (dataPagesFetchedBySel > dataPagesFetched) { /* - * At least one of entries is very frequent and, unfortunately, - * we couldn't get statistic about entries (only tsvector has - * such statistics). So, we obviously have too small estimation of - * pages fetched from data tree. Re-estimate it from known - * capacity of data pages + * At least one of entries is very frequent and, unfortunately, we + * couldn't get statistic about entries (only tsvector has such + * statistics). So, we obviously have too small estimation of pages + * fetched from data tree. Re-estimate it from known capacity of data + * pages */ dataPagesFetched = dataPagesFetchedBySel; } @@ -6670,7 +6669,7 @@ gincostestimate(PG_FUNCTION_ARGS) qual_op_cost = cpu_operator_cost * (list_length(indexQuals) + list_length(indexOrderBys)); qual_arg_cost -= qual_op_cost; - if (qual_arg_cost < 0) /* just in case... */ + if (qual_arg_cost < 0) /* just in case... */ qual_arg_cost = 0; *indexStartupCost += qual_arg_cost; diff --git a/src/backend/utils/adt/tsginidx.c b/src/backend/utils/adt/tsginidx.c index 41700bfcf15..4cb961146b8 100644 --- a/src/backend/utils/adt/tsginidx.c +++ b/src/backend/utils/adt/tsginidx.c @@ -95,10 +95,12 @@ gin_extract_tsquery(PG_FUNCTION_ARGS) { TSQuery query = PG_GETARG_TSQUERY(0); int32 *nentries = (int32 *) PG_GETARG_POINTER(1); + /* StrategyNumber strategy = PG_GETARG_UINT16(2); */ bool **ptr_partialmatch = (bool **) PG_GETARG_POINTER(3); Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4); - /* bool **nullFlags = (bool **) PG_GETARG_POINTER(5); */ + + /* bool **nullFlags = (bool **) PG_GETARG_POINTER(5); */ int32 *searchMode = (int32 *) PG_GETARG_POINTER(6); Datum *entries = NULL; @@ -114,8 +116,8 @@ gin_extract_tsquery(PG_FUNCTION_ARGS) /* * If the query doesn't have any required positive matches (for - * instance, it's something like '! foo'), we have to do a full - * index scan. + * instance, it's something like '! foo'), we have to do a full index + * scan. */ if (tsquery_requires_match(item)) *searchMode = GIN_SEARCH_MODE_DEFAULT; @@ -235,7 +237,7 @@ gin_tsquery_consistent(PG_FUNCTION_ARGS) * Formerly, gin_extract_tsvector had only two arguments. Now it has three, * but we still need a pg_proc entry with two args to support reloading * pre-9.1 contrib/tsearch2 opclass declarations. This compatibility - * function should go away eventually. (Note: you might say "hey, but the + * function should go away eventually. (Note: you might say "hey, but the * code above is only *using* two args, so let's just declare it that way". * If you try that you'll find the opr_sanity regression test complains.) */ diff --git a/src/backend/utils/adt/tsvector_op.c b/src/backend/utils/adt/tsvector_op.c index b7a822d3544..66674917f0d 100644 --- a/src/backend/utils/adt/tsvector_op.c +++ b/src/backend/utils/adt/tsvector_op.c @@ -711,6 +711,7 @@ tsquery_requires_match(QueryItem *curitem) switch (curitem->qoperator.oper) { case OP_NOT: + /* * Assume there are no required matches underneath a NOT. For * some cases with nested NOTs, we could prove there's a required diff --git a/src/backend/utils/adt/varbit.c b/src/backend/utils/adt/varbit.c index 0eb6071e123..3fa81175fd8 100644 --- a/src/backend/utils/adt/varbit.c +++ b/src/backend/utils/adt/varbit.c @@ -237,6 +237,7 @@ bit_out(PG_FUNCTION_ARGS) /* same as varbit output */ return varbit_out(fcinfo); #else + /* * This is how one would print a hex string, in case someone wants to * write a formatting function. diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c index 7a545214755..9d96013d57e 100644 --- a/src/backend/utils/adt/varlena.c +++ b/src/backend/utils/adt/varlena.c @@ -81,7 +81,7 @@ void text_format_string_conversion(StringInfo buf, char conversion, static Datum text_to_array_internal(PG_FUNCTION_ARGS); static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v, - char *fldsep, char *null_string); + char *fldsep, char *null_string); /***************************************************************************** @@ -1299,7 +1299,7 @@ varstr_cmp(char *arg1, int len1, char *arg2, int len2, Oid collid) char a2buf[STACKBUFLEN]; char *a1p, *a2p; - pg_locale_t mylocale = 0; + pg_locale_t mylocale = 0; if (collid != DEFAULT_COLLATION_OID) { @@ -1379,7 +1379,7 @@ varstr_cmp(char *arg1, int len1, char *arg2, int len2, Oid collid) result = wcscoll_l((LPWSTR) a1p, (LPWSTR) a2p, mylocale); else #endif - result = wcscoll((LPWSTR) a1p, (LPWSTR) a2p); + result = wcscoll((LPWSTR) a1p, (LPWSTR) a2p); if (result == 2147483647) /* _NLSCMPERROR; missing from mingw * headers */ ereport(ERROR, @@ -1426,7 +1426,7 @@ varstr_cmp(char *arg1, int len1, char *arg2, int len2, Oid collid) result = strcoll_l(a1p, a2p, mylocale); else #endif - result = strcoll(a1p, a2p); + result = strcoll(a1p, a2p); /* * In some locales strcoll() can claim that nonidentical strings are @@ -1487,10 +1487,10 @@ texteq(PG_FUNCTION_ARGS) /* * Since we only care about equality or not-equality, we can avoid all the - * expense of strcoll() here, and just do bitwise comparison. In fact, - * we don't even have to do a bitwise comparison if we can show the - * lengths of the strings are unequal; which might save us from having - * to detoast one or both values. + * expense of strcoll() here, and just do bitwise comparison. In fact, we + * don't even have to do a bitwise comparison if we can show the lengths + * of the strings are unequal; which might save us from having to detoast + * one or both values. */ len1 = toast_raw_datum_size(arg1); len2 = toast_raw_datum_size(arg2); @@ -2031,7 +2031,7 @@ byteaGetByte(PG_FUNCTION_ARGS) bytea *v = PG_GETARG_BYTEA_PP(0); int32 n = PG_GETARG_INT32(1); int len; - int byte; + int byte; len = VARSIZE_ANY_EXHDR(v); @@ -2062,7 +2062,7 @@ byteaGetBit(PG_FUNCTION_ARGS) int byteNo, bitNo; int len; - int byte; + int byte; len = VARSIZE_ANY_EXHDR(v); @@ -2077,7 +2077,7 @@ byteaGetBit(PG_FUNCTION_ARGS) byte = ((unsigned char *) VARDATA_ANY(v))[byteNo]; - if (byte &(1 << bitNo)) + if (byte & (1 << bitNo)) PG_RETURN_INT32(1); else PG_RETURN_INT32(0); @@ -3144,7 +3144,7 @@ text_to_array_internal(PG_FUNCTION_ARGS) /* single element can be a NULL too */ is_null = null_string ? text_isequal(inputstring, null_string) : false; PG_RETURN_ARRAYTYPE_P(create_singleton_array(fcinfo, TEXTOID, - PointerGetDatum(inputstring), + PointerGetDatum(inputstring), is_null, 1)); } @@ -3152,7 +3152,7 @@ text_to_array_internal(PG_FUNCTION_ARGS) /* start_ptr points to the start_posn'th character of inputstring */ start_ptr = VARDATA_ANY(inputstring); - for (fldnum = 1;; fldnum++) /* field number is 1 based */ + for (fldnum = 1;; fldnum++) /* field number is 1 based */ { CHECK_FOR_INTERRUPTS(); @@ -3197,8 +3197,8 @@ text_to_array_internal(PG_FUNCTION_ARGS) { /* * When fldsep is NULL, each character in the inputstring becomes an - * element in the result array. The separator is effectively the space - * between characters. + * element in the result array. The separator is effectively the + * space between characters. */ inputstring_len = VARSIZE_ANY_EXHDR(inputstring); @@ -3210,7 +3210,7 @@ text_to_array_internal(PG_FUNCTION_ARGS) while (inputstring_len > 0) { - int chunk_len = pg_mblen(start_ptr); + int chunk_len = pg_mblen(start_ptr); CHECK_FOR_INTERRUPTS(); @@ -3625,9 +3625,9 @@ string_agg_finalfn(PG_FUNCTION_ARGS) static text * concat_internal(const char *sepstr, int seplen, int argidx, FunctionCallInfo fcinfo) { - StringInfoData str; - text *result; - int i; + StringInfoData str; + text *result; + int i; initStringInfo(&str); @@ -3635,10 +3635,10 @@ concat_internal(const char *sepstr, int seplen, int argidx, FunctionCallInfo fci { if (!PG_ARGISNULL(i)) { - Oid valtype; - Datum value; - Oid typOutput; - bool typIsVarlena; + Oid valtype; + Datum value; + Oid typOutput; + bool typIsVarlena; if (i > argidx) appendBinaryStringInfo(&str, sepstr, seplen); @@ -3648,7 +3648,7 @@ concat_internal(const char *sepstr, int seplen, int argidx, FunctionCallInfo fci valtype = get_fn_expr_argtype(fcinfo->flinfo, i); getTypeOutputInfo(valtype, &typOutput, &typIsVarlena); appendStringInfoString(&str, - OidOutputFunctionCall(typOutput, value)); + OidOutputFunctionCall(typOutput, value)); } } @@ -3674,7 +3674,7 @@ text_concat(PG_FUNCTION_ARGS) Datum text_concat_ws(PG_FUNCTION_ARGS) { - text *sep; + text *sep; /* return NULL when separator is NULL */ if (PG_ARGISNULL(0)) @@ -3683,7 +3683,7 @@ text_concat_ws(PG_FUNCTION_ARGS) sep = PG_GETARG_TEXT_PP(0); PG_RETURN_TEXT_P(concat_internal( - VARDATA_ANY(sep), VARSIZE_ANY_EXHDR(sep), 1, fcinfo)); + VARDATA_ANY(sep), VARSIZE_ANY_EXHDR(sep), 1, fcinfo)); } /* @@ -3734,15 +3734,15 @@ text_right(PG_FUNCTION_ARGS) Datum text_reverse(PG_FUNCTION_ARGS) { - text *str = PG_GETARG_TEXT_PP(0); - const char *p = VARDATA_ANY(str); - int len = VARSIZE_ANY_EXHDR(str); - const char *endp = p + len; - text *result; - char *dst; + text *str = PG_GETARG_TEXT_PP(0); + const char *p = VARDATA_ANY(str); + int len = VARSIZE_ANY_EXHDR(str); + const char *endp = p + len; + text *result; + char *dst; result = palloc(len + VARHDRSZ); - dst = (char*) VARDATA(result) + len; + dst = (char *) VARDATA(result) + len; SET_VARSIZE(result, len + VARHDRSZ); if (pg_database_encoding_max_length() > 1) @@ -3750,7 +3750,7 @@ text_reverse(PG_FUNCTION_ARGS) /* multibyte version */ while (p < endp) { - int sz; + int sz; sz = pg_mblen(p); dst -= sz; @@ -3775,7 +3775,7 @@ Datum text_format(PG_FUNCTION_ARGS) { text *fmt; - StringInfoData str; + StringInfoData str; const char *cp; const char *start_ptr; const char *end_ptr; @@ -3795,9 +3795,9 @@ text_format(PG_FUNCTION_ARGS) /* Scan format string, looking for conversion specifiers. */ for (cp = start_ptr; cp < end_ptr; cp++) { - Datum value; - bool isNull; - Oid typid; + Datum value; + bool isNull; + Oid typid; /* * If it's not the start of a conversion specifier, just copy it to @@ -3830,11 +3830,12 @@ text_format(PG_FUNCTION_ARGS) ++arg; else { - bool unterminated = false; + bool unterminated = false; /* Parse digit string. */ arg = 0; - do { + do + { /* Treat overflowing arg position as unterminated. */ if (arg > INT_MAX / 10) break; @@ -3863,8 +3864,8 @@ text_format(PG_FUNCTION_ARGS) /* There's no argument 0. */ if (arg == 0) ereport(ERROR, - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("conversion specifies argument 0, but arguments are numbered from 1"))); + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("conversion specifies argument 0, but arguments are numbered from 1"))); } /* Not enough arguments? Deduct 1 to avoid counting format string. */ @@ -3874,9 +3875,9 @@ text_format(PG_FUNCTION_ARGS) errmsg("too few arguments for format conversion"))); /* - * At this point, we should see the main conversion specifier. - * Whether or not an argument position was present, it's known - * that at least one character remains in the string at this point. + * At this point, we should see the main conversion specifier. Whether + * or not an argument position was present, it's known that at least + * one character remains in the string at this point. */ value = PG_GETARG_DATUM(arg); isNull = PG_ARGISNULL(arg); @@ -3893,7 +3894,7 @@ text_format(PG_FUNCTION_ARGS) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unrecognized conversion specifier: %c", - *cp))); + *cp))); } } @@ -3907,11 +3908,11 @@ text_format(PG_FUNCTION_ARGS) /* Format a %s, %I, or %L conversion. */ void text_format_string_conversion(StringInfo buf, char conversion, - Oid typid, Datum value, bool isNull) + Oid typid, Datum value, bool isNull) { - Oid typOutput; - bool typIsVarlena; - char *str; + Oid typOutput; + bool typIsVarlena; + char *str; /* Handle NULL arguments before trying to stringify the value. */ if (isNull) @@ -3919,7 +3920,7 @@ text_format_string_conversion(StringInfo buf, char conversion, if (conversion == 'L') appendStringInfoString(buf, "NULL"); else if (conversion == 'I') - ereport(ERROR, + ereport(ERROR, (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED), errmsg("NULL cannot be escaped as an SQL identifier"))); return; @@ -3937,7 +3938,8 @@ text_format_string_conversion(StringInfo buf, char conversion, } else if (conversion == 'L') { - char *qstr = quote_literal_cstr(str); + char *qstr = quote_literal_cstr(str); + appendStringInfoString(buf, qstr); /* quote_literal_cstr() always allocates a new string */ pfree(qstr); @@ -3951,7 +3953,7 @@ text_format_string_conversion(StringInfo buf, char conversion, /* * text_format_nv - nonvariadic wrapper for text_format function. - * + * * note: this wrapper is necessary to be sanity_checks test ok */ Datum diff --git a/src/backend/utils/adt/xml.c b/src/backend/utils/adt/xml.c index c175e4f4cac..ee82d4616c6 100644 --- a/src/backend/utils/adt/xml.c +++ b/src/backend/utils/adt/xml.c @@ -1200,9 +1200,10 @@ xml_parse(text *data, XmlOptionType xmloption_arg, bool preserve_whitespace, { /* * Note, that here we try to apply DTD defaults - * (XML_PARSE_DTDATTR) according to SQL/XML:2008 GR 10.16.7.d: 'Default - * values defined by internal DTD are applied'. As for external - * DTDs, we try to support them too, (see SQL/XML:2008 GR 10.16.7.e) + * (XML_PARSE_DTDATTR) according to SQL/XML:2008 GR 10.16.7.d: + * 'Default values defined by internal DTD are applied'. As for + * external DTDs, we try to support them too, (see SQL/XML:2008 GR + * 10.16.7.e) */ doc = xmlCtxtReadDoc(ctxt, utf8string, NULL, @@ -3435,10 +3436,10 @@ xpath_internal(text *xpath_expr_text, xmltype *data, ArrayType *namespaces, /* * Version 2.6.27 introduces a function named - * xmlXPathCompiledEvalToBoolean, which would be enough for - * xmlexists, but we can derive the existence by whether any - * nodes are returned, thereby preventing a library version - * upgrade and keeping the code the same. + * xmlXPathCompiledEvalToBoolean, which would be enough for xmlexists, + * but we can derive the existence by whether any nodes are returned, + * thereby preventing a library version upgrade and keeping the code + * the same. */ xpathobj = xmlXPathCompiledEval(xpathcomp, xpathctx); if (xpathobj == NULL) /* TODO: reason? */ @@ -3488,7 +3489,7 @@ xpath_internal(text *xpath_expr_text, xmltype *data, ArrayType *namespaces, xmlFreeDoc(doc); xmlFreeParserCtxt(ctxt); } -#endif /* USE_LIBXML */ +#endif /* USE_LIBXML */ /* * Evaluate XPath expression and return array of XML values. @@ -3524,7 +3525,8 @@ xpath(PG_FUNCTION_ARGS) * Determines if the node specified by the supplied XPath exists * in a given XML document, returning a boolean. */ -Datum xmlexists(PG_FUNCTION_ARGS) +Datum +xmlexists(PG_FUNCTION_ARGS) { #ifdef USE_LIBXML text *xpath_expr_text = PG_GETARG_TEXT_P(0); diff --git a/src/backend/utils/cache/inval.c b/src/backend/utils/cache/inval.c index fe89b71df2d..ebc83440dea 100644 --- a/src/backend/utils/cache/inval.c +++ b/src/backend/utils/cache/inval.c @@ -514,7 +514,8 @@ LocalExecuteInvalidationMessage(SharedInvalidationMessage *msg) * We could have smgr entries for relations of other databases, so no * short-circuit test is possible here. */ - RelFileNodeBackend rnode; + RelFileNodeBackend rnode; + rnode.node = msg->sm.rnode; rnode.backend = (msg->sm.backend_hi << 16) | (int) msg->sm.backend_lo; smgrclosenode(rnode); diff --git a/src/backend/utils/cache/lsyscache.c b/src/backend/utils/cache/lsyscache.c index 877e50d8737..d3b2a5a5572 100644 --- a/src/backend/utils/cache/lsyscache.c +++ b/src/backend/utils/cache/lsyscache.c @@ -1122,7 +1122,7 @@ op_input_types(Oid opno, Oid *lefttype, Oid *righttype) * * In some cases (currently only array_eq), mergejoinability depends on the * specific input data type the operator is invoked for, so that must be - * passed as well. We currently assume that only one input's type is needed + * passed as well. We currently assume that only one input's type is needed * to check this --- by convention, pass the left input's data type. */ bool @@ -1172,7 +1172,7 @@ op_mergejoinable(Oid opno, Oid inputtype) * * In some cases (currently only array_eq), hashjoinability depends on the * specific input data type the operator is invoked for, so that must be - * passed as well. We currently assume that only one input's type is needed + * passed as well. We currently assume that only one input's type is needed * to check this --- by convention, pass the left input's data type. */ bool @@ -2709,9 +2709,9 @@ get_attstatsslot(HeapTuple statstuple, /* * Need to get info about the array element type. We look at the * actual element type embedded in the array, which might be only - * binary-compatible with the passed-in atttype. The info we - * extract here should be the same either way, but deconstruct_array - * is picky about having an exact type OID match. + * binary-compatible with the passed-in atttype. The info we extract + * here should be the same either way, but deconstruct_array is picky + * about having an exact type OID match. */ arrayelemtype = ARR_ELEMTYPE(statarray); typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(arrayelemtype)); diff --git a/src/backend/utils/cache/plancache.c b/src/backend/utils/cache/plancache.c index 949608001ea..08ddfa9bcba 100644 --- a/src/backend/utils/cache/plancache.c +++ b/src/backend/utils/cache/plancache.c @@ -512,8 +512,8 @@ RevalidateCachedPlan(CachedPlanSource *plansource, bool useResOwner) TupleDesc resultDesc; /* - * Restore the search_path that was in use when the plan was made. - * See comments for PushOverrideSearchPath about limitations of this. + * Restore the search_path that was in use when the plan was made. See + * comments for PushOverrideSearchPath about limitations of this. * * (XXX is there anything else we really need to restore?) */ diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 274b48c8951..d7e94ffc125 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -1070,9 +1070,9 @@ RelationInitIndexAccessInfo(Relation relation) MemoryContextAllocZero(indexcxt, natts * sizeof(int16)); /* - * indcollation cannot be referenced directly through the C struct, because it - * comes after the variable-width indkey field. Must extract the datum - * the hard way... + * indcollation cannot be referenced directly through the C struct, + * because it comes after the variable-width indkey field. Must extract + * the datum the hard way... */ indcollDatum = fastgetattr(relation->rd_indextuple, Anum_pg_index_indcollation, @@ -1096,7 +1096,7 @@ RelationInitIndexAccessInfo(Relation relation) /* * Fill the support procedure OID array, as well as the info about - * opfamilies and opclass input types. (aminfo and supportinfo are left + * opfamilies and opclass input types. (aminfo and supportinfo are left * as zeroes, and are filled on-the-fly when used) */ IndexSupportInitialize(indclass, relation->rd_support, diff --git a/src/backend/utils/cache/syscache.c b/src/backend/utils/cache/syscache.c index 715341f8420..2b5e37e2f05 100644 --- a/src/backend/utils/cache/syscache.c +++ b/src/backend/utils/cache/syscache.c @@ -422,7 +422,7 @@ static const struct cachedesc cacheinfo[] = { }, 32 }, - {ForeignTableRelationId, /* FOREIGNTABLEREL */ + {ForeignTableRelationId, /* FOREIGNTABLEREL */ ForeignTableRelidIndexId, 1, { diff --git a/src/backend/utils/cache/ts_cache.c b/src/backend/utils/cache/ts_cache.c index fc93551d069..a8c4d76565a 100644 --- a/src/backend/utils/cache/ts_cache.c +++ b/src/backend/utils/cache/ts_cache.c @@ -582,7 +582,7 @@ getTSCurrentConfig(bool emitError) /* Look up the config */ TSCurrentConfigCache = get_ts_config_oid(stringToQualifiedNameList(TSCurrentConfig), - !emitError); + !emitError); return TSCurrentConfigCache; } diff --git a/src/backend/utils/cache/typcache.c b/src/backend/utils/cache/typcache.c index 54e1942c319..2769a30acd8 100644 --- a/src/backend/utils/cache/typcache.c +++ b/src/backend/utils/cache/typcache.c @@ -77,7 +77,7 @@ typedef struct TypeCacheEnumData Oid bitmap_base; /* OID corresponding to bit 0 of bitmapset */ Bitmapset *sorted_values; /* Set of OIDs known to be in order */ int num_values; /* total number of values in enum */ - EnumItem enum_values[1]; /* VARIABLE LENGTH ARRAY */ + EnumItem enum_values[1]; /* VARIABLE LENGTH ARRAY */ } TypeCacheEnumData; /* @@ -227,10 +227,10 @@ lookup_type_cache(Oid type_id, int flags) { /* * In case we find a btree opclass where previously we only found - * a hash opclass, reset eq_opr and derived information so that - * we can fetch the btree equality operator instead of the hash - * equality operator. (They're probably the same operator, but - * we don't assume that here.) + * a hash opclass, reset eq_opr and derived information so that we + * can fetch the btree equality operator instead of the hash + * equality operator. (They're probably the same operator, but we + * don't assume that here.) */ typentry->eq_opr = InvalidOid; typentry->eq_opr_finfo.fn_oid = InvalidOid; @@ -612,7 +612,8 @@ TypeCacheRelCallback(Datum arg, Oid relid) while ((typentry = (TypeCacheEntry *) hash_seq_search(&status)) != NULL) { if (typentry->tupDesc == NULL) - continue; /* not composite, or tupdesc hasn't been requested */ + continue; /* not composite, or tupdesc hasn't been + * requested */ /* Delete if match, or if we're zapping all composite types */ if (relid == typentry->typrelid || relid == InvalidOid) @@ -671,8 +672,8 @@ compare_values_of_enum(TypeCacheEntry *tcache, Oid arg1, Oid arg2) EnumItem *item2; /* - * Equal OIDs are certainly equal --- this case was probably handled - * by our caller, but we may as well check. + * Equal OIDs are certainly equal --- this case was probably handled by + * our caller, but we may as well check. */ if (arg1 == arg2) return 0; @@ -704,8 +705,8 @@ compare_values_of_enum(TypeCacheEntry *tcache, Oid arg1, Oid arg2) { /* * We couldn't find one or both values. That means the enum has - * changed under us, so re-initialize the cache and try again. - * We don't bother retrying the known-sorted case in this path. + * changed under us, so re-initialize the cache and try again. We + * don't bother retrying the known-sorted case in this path. */ load_enum_cache_data(tcache); enumdata = tcache->enumData; @@ -714,8 +715,8 @@ compare_values_of_enum(TypeCacheEntry *tcache, Oid arg1, Oid arg2) item2 = find_enumitem(enumdata, arg2); /* - * If we still can't find the values, complain: we must have - * corrupt data. + * If we still can't find the values, complain: we must have corrupt + * data. */ if (item1 == NULL) elog(ERROR, "enum value %u not found in cache for enum %s", @@ -761,21 +762,21 @@ load_enum_cache_data(TypeCacheEntry *tcache) format_type_be(tcache->type_id)))); /* - * Read all the information for members of the enum type. We collect - * the info in working memory in the caller's context, and then transfer - * it to permanent memory in CacheMemoryContext. This minimizes the risk - * of leaking memory from CacheMemoryContext in the event of an error - * partway through. + * Read all the information for members of the enum type. We collect the + * info in working memory in the caller's context, and then transfer it to + * permanent memory in CacheMemoryContext. This minimizes the risk of + * leaking memory from CacheMemoryContext in the event of an error partway + * through. */ maxitems = 64; items = (EnumItem *) palloc(sizeof(EnumItem) * maxitems); numitems = 0; /* - * Scan pg_enum for the members of the target enum type. We use a - * current MVCC snapshot, *not* SnapshotNow, so that we see a consistent - * set of rows even if someone commits a renumbering of the enum meanwhile. - * See comments for RenumberEnumType in catalog/pg_enum.c for more info. + * Scan pg_enum for the members of the target enum type. We use a current + * MVCC snapshot, *not* SnapshotNow, so that we see a consistent set of + * rows even if someone commits a renumbering of the enum meanwhile. See + * comments for RenumberEnumType in catalog/pg_enum.c for more info. */ ScanKeyInit(&skey, Anum_pg_enum_enumtypid, @@ -817,8 +818,8 @@ load_enum_cache_data(TypeCacheEntry *tcache) * and we'd rather not do binary searches unnecessarily. * * This is somewhat heuristic, and might identify a subset of OIDs that - * isn't exactly what the type started with. That's okay as long as - * the subset is correctly sorted. + * isn't exactly what the type started with. That's okay as long as the + * subset is correctly sorted. */ bitmap_base = InvalidOid; bitmap = NULL; @@ -829,15 +830,15 @@ load_enum_cache_data(TypeCacheEntry *tcache) /* * Identify longest sorted subsequence starting at start_pos */ - Bitmapset *this_bitmap = bms_make_singleton(0); - int this_bm_size = 1; - Oid start_oid = items[start_pos].enum_oid; - float4 prev_order = items[start_pos].sort_order; - int i; + Bitmapset *this_bitmap = bms_make_singleton(0); + int this_bm_size = 1; + Oid start_oid = items[start_pos].enum_oid; + float4 prev_order = items[start_pos].sort_order; + int i; for (i = start_pos + 1; i < numitems; i++) { - Oid offset; + Oid offset; offset = items[i].enum_oid - start_oid; /* quit if bitmap would be too large; cutoff is arbitrary */ @@ -864,10 +865,10 @@ load_enum_cache_data(TypeCacheEntry *tcache) bms_free(this_bitmap); /* - * Done if it's not possible to find a longer sequence in the rest - * of the list. In typical cases this will happen on the first - * iteration, which is why we create the bitmaps on the fly instead - * of doing a second pass over the list. + * Done if it's not possible to find a longer sequence in the rest of + * the list. In typical cases this will happen on the first + * iteration, which is why we create the bitmaps on the fly instead of + * doing a second pass over the list. */ if (bm_size >= (numitems - start_pos - 1)) break; diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c index 9e58735aeec..337b875fe20 100644 --- a/src/backend/utils/error/elog.c +++ b/src/backend/utils/error/elog.c @@ -5,7 +5,7 @@ * * Because of the extremely high rate at which log messages can be generated, * we need to be mindful of the performance cost of obtaining any information - * that may be logged. Also, it's important to keep in mind that this code may + * that may be logged. Also, it's important to keep in mind that this code may * get called from within an aborted transaction, in which case operations * such as syscache lookups are unsafe. * @@ -1175,7 +1175,7 @@ elog_finish(int elevel, const char *fmt,...) * The result of format_elog_string() is stored in ErrorContext, and will * therefore survive until FlushErrorState() is called. */ -static int save_format_errnumber; +static int save_format_errnumber; static const char *save_format_domain; void @@ -1188,7 +1188,7 @@ pre_format_elog_string(int errnumber, const char *domain) } char * -format_elog_string(const char *fmt, ...) +format_elog_string(const char *fmt,...) { ErrorData errdata; ErrorData *edata; @@ -1725,8 +1725,9 @@ write_console(const char *line, int len) * WriteConsoleW() will fail of stdout is redirected, so just fall through * to writing unconverted to the logfile in this case. * - * Since we palloc the structure required for conversion, also fall through - * to writing unconverted if we have not yet set up CurrentMemoryContext. + * Since we palloc the structure required for conversion, also fall + * through to writing unconverted if we have not yet set up + * CurrentMemoryContext. */ if (GetDatabaseEncoding() != GetPlatformEncoding() && !in_error_recursion_trouble() && diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c index e193e560eab..0288fbab4bc 100644 --- a/src/backend/utils/fmgr/fmgr.c +++ b/src/backend/utils/fmgr/fmgr.c @@ -34,7 +34,7 @@ * Hooks for function calls */ PGDLLIMPORT needs_fmgr_hook_type needs_fmgr_hook = NULL; -PGDLLIMPORT fmgr_hook_type fmgr_hook = NULL; +PGDLLIMPORT fmgr_hook_type fmgr_hook = NULL; /* * Declaration for old-style function pointer type. This is now used only @@ -192,7 +192,7 @@ fmgr_info_cxt_security(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt, * elogs. */ finfo->fn_oid = InvalidOid; - finfo->fn_collation = InvalidOid; /* caller may set this later */ + finfo->fn_collation = InvalidOid; /* caller may set this later */ finfo->fn_extra = NULL; finfo->fn_mcxt = mcxt; finfo->fn_expr = NULL; /* caller may set this later */ @@ -951,7 +951,7 @@ fmgr_security_definer(PG_FUNCTION_ARGS) /* function manager hook */ if (fmgr_hook) - (*fmgr_hook)(FHET_START, &fcache->flinfo, &fcache->arg); + (*fmgr_hook) (FHET_START, &fcache->flinfo, &fcache->arg); /* * We don't need to restore GUC or userid settings on error, because the @@ -982,7 +982,7 @@ fmgr_security_definer(PG_FUNCTION_ARGS) { fcinfo->flinfo = save_flinfo; if (fmgr_hook) - (*fmgr_hook)(FHET_ABORT, &fcache->flinfo, &fcache->arg); + (*fmgr_hook) (FHET_ABORT, &fcache->flinfo, &fcache->arg); PG_RE_THROW(); } PG_END_TRY(); @@ -994,7 +994,7 @@ fmgr_security_definer(PG_FUNCTION_ARGS) if (OidIsValid(fcache->userid)) SetUserIdAndSecContext(save_userid, save_sec_context); if (fmgr_hook) - (*fmgr_hook)(FHET_END, &fcache->flinfo, &fcache->arg); + (*fmgr_hook) (FHET_END, &fcache->flinfo, &fcache->arg); return result; } @@ -1278,7 +1278,7 @@ DirectFunctionCall9(PGFunction func, Datum arg1, Datum arg2, /* * These are the same as DirectFunctionCallN except that a nonzero - * collation can be specified. No other fields of FmgrInfo are made valid. + * collation can be specified. No other fields of FmgrInfo are made valid. */ Datum DirectFunctionCall1WithCollation(PGFunction func, Oid collation, Datum arg1) diff --git a/src/backend/utils/fmgr/funcapi.c b/src/backend/utils/fmgr/funcapi.c index cad4a371b7d..aa249fabfe8 100644 --- a/src/backend/utils/fmgr/funcapi.c +++ b/src/backend/utils/fmgr/funcapi.c @@ -489,8 +489,8 @@ resolve_polymorphic_tupdesc(TupleDesc tupdesc, oidvector *declared_args, return false; /* - * Identify the collation to use for polymorphic OUT parameters. - * (It'll necessarily be the same for both anyelement and anyarray.) + * Identify the collation to use for polymorphic OUT parameters. (It'll + * necessarily be the same for both anyelement and anyarray.) */ anycollation = get_typcollation(OidIsValid(anyelement_type) ? anyelement_type : anyarray_type); if (OidIsValid(anycollation)) @@ -500,7 +500,7 @@ resolve_polymorphic_tupdesc(TupleDesc tupdesc, oidvector *declared_args, * collation. We do so if we can identify the input collation used * for the function. */ - Oid inputcollation = exprInputCollation(call_expr); + Oid inputcollation = exprInputCollation(call_expr); if (OidIsValid(inputcollation)) anycollation = inputcollation; diff --git a/src/backend/utils/init/miscinit.c b/src/backend/utils/init/miscinit.c index ef6422e75c3..347a777da99 100644 --- a/src/backend/utils/init/miscinit.c +++ b/src/backend/utils/init/miscinit.c @@ -394,8 +394,8 @@ SetUserIdAndContext(Oid userid, bool sec_def_context) bool is_authenticated_user_replication_role(void) { - bool result = false; - HeapTuple utup; + bool result = false; + HeapTuple utup; utup = SearchSysCache1(AUTHOID, ObjectIdGetDatum(AuthenticatedUserId)); if (HeapTupleIsValid(utup)) @@ -866,7 +866,7 @@ CreateLockFile(const char *filename, bool amPostmaster, "(key %lu, ID %lu) is still in use", id1, id2), errhint("If you're sure there are no old " - "server processes still running, remove " + "server processes still running, remove " "the shared memory block " "or just delete the file \"%s\".", filename))); @@ -889,8 +889,8 @@ CreateLockFile(const char *filename, bool amPostmaster, } /* - * Successfully created the file, now fill it. See comment in miscadmin.h - * about the contents. Note that we write the same info into both datadir + * Successfully created the file, now fill it. See comment in miscadmin.h + * about the contents. Note that we write the same info into both datadir * and socket lockfiles; although more stuff may get added to the datadir * lockfile later. */ @@ -904,7 +904,7 @@ CreateLockFile(const char *filename, bool amPostmaster, #else "" #endif - ); + ); errno = 0; if (write(fd, buffer, strlen(buffer)) != strlen(buffer)) diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c index f3ca5a5cd6a..a4c5d4c69ab 100644 --- a/src/backend/utils/init/postinit.c +++ b/src/backend/utils/init/postinit.c @@ -222,8 +222,8 @@ PerformAuthentication(Port *port) { if (am_walsender) ereport(LOG, - (errmsg("replication connection authorized: user=%s", - port->user_name))); + (errmsg("replication connection authorized: user=%s", + port->user_name))); else ereport(LOG, (errmsg("connection authorized: user=%s database=%s", @@ -639,9 +639,9 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username, errmsg("remaining connection slots are reserved for non-replication superuser connections"))); /* - * If walsender, we don't want to connect to any particular database. - * Just finish the backend startup by processing any options from the - * startup packet, and we're done. + * If walsender, we don't want to connect to any particular database. Just + * finish the backend startup by processing any options from the startup + * packet, and we're done. */ if (am_walsender) { diff --git a/src/backend/utils/mb/mbutils.c b/src/backend/utils/mb/mbutils.c index b1281778036..234bb0cf6e8 100644 --- a/src/backend/utils/mb/mbutils.c +++ b/src/backend/utils/mb/mbutils.c @@ -77,7 +77,7 @@ static int cliplen(const char *str, int len, int limit); /* - * Prepare for a future call to SetClientEncoding. Success should mean + * Prepare for a future call to SetClientEncoding. Success should mean * that SetClientEncoding is guaranteed to succeed for this encoding request. * * (But note that success before backend_startup_complete does not guarantee @@ -149,7 +149,7 @@ PrepareClientEncoding(int encoding) /* * We cannot yet remove any older entry for the same encoding pair, - * since it could still be in use. SetClientEncoding will clean up. + * since it could still be in use. SetClientEncoding will clean up. */ return 0; /* success */ @@ -218,8 +218,8 @@ SetClientEncoding(int encoding) /* * Search the cache for the entry previously prepared by * PrepareClientEncoding; if there isn't one, we lose. While at it, - * release any duplicate entries so that repeated Prepare/Set cycles - * don't leak memory. + * release any duplicate entries so that repeated Prepare/Set cycles don't + * leak memory. */ found = false; foreach(lc, ConvProcList) @@ -591,7 +591,7 @@ pg_any_to_server(const char *s, int len, int encoding) return perform_default_encoding_conversion(s, len, true); else return (char *) pg_do_encoding_conversion( - (unsigned char *) s, len, encoding, DatabaseEncoding->encoding); + (unsigned char *) s, len, encoding, DatabaseEncoding->encoding); } /* @@ -626,7 +626,7 @@ pg_server_to_any(const char *s, int len, int encoding) return perform_default_encoding_conversion(s, len, false); else return (char *) pg_do_encoding_conversion( - (unsigned char *) s, len, DatabaseEncoding->encoding, encoding); + (unsigned char *) s, len, DatabaseEncoding->encoding, encoding); } /* diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c index 5e4904aeb7f..738e2152ba8 100644 --- a/src/backend/utils/misc/guc.c +++ b/src/backend/utils/misc/guc.c @@ -146,23 +146,23 @@ extern bool optimize_bounded_sort; static int GUC_check_errcode_value; /* global variables for check hook support */ -char *GUC_check_errmsg_string; -char *GUC_check_errdetail_string; -char *GUC_check_errhint_string; +char *GUC_check_errmsg_string; +char *GUC_check_errdetail_string; +char *GUC_check_errhint_string; static void set_config_sourcefile(const char *name, char *sourcefile, int sourceline); -static bool call_bool_check_hook(struct config_bool *conf, bool *newval, - void **extra, GucSource source, int elevel); -static bool call_int_check_hook(struct config_int *conf, int *newval, - void **extra, GucSource source, int elevel); -static bool call_real_check_hook(struct config_real *conf, double *newval, - void **extra, GucSource source, int elevel); -static bool call_string_check_hook(struct config_string *conf, char **newval, - void **extra, GucSource source, int elevel); -static bool call_enum_check_hook(struct config_enum *conf, int *newval, - void **extra, GucSource source, int elevel); +static bool call_bool_check_hook(struct config_bool * conf, bool *newval, + void **extra, GucSource source, int elevel); +static bool call_int_check_hook(struct config_int * conf, int *newval, + void **extra, GucSource source, int elevel); +static bool call_real_check_hook(struct config_real * conf, double *newval, + void **extra, GucSource source, int elevel); +static bool call_string_check_hook(struct config_string * conf, char **newval, + void **extra, GucSource source, int elevel); +static bool call_enum_check_hook(struct config_enum * conf, int *newval, + void **extra, GucSource source, int elevel); static bool check_log_destination(char **newval, void **extra, GucSource source); static void assign_log_destination(const char *newval, void *extra); @@ -1571,7 +1571,7 @@ static struct config_int ConfigureNamesInt[] = GUC_UNIT_S }, &wal_receiver_status_interval, - 10, 0, INT_MAX/1000, + 10, 0, INT_MAX / 1000, NULL, NULL, NULL }, @@ -1878,7 +1878,7 @@ static struct config_int ConfigureNamesInt[] = {"max_pred_locks_per_transaction", PGC_POSTMASTER, LOCK_MANAGEMENT, gettext_noop("Sets the maximum number of predicate locks per transaction."), gettext_noop("The shared predicate lock table is sized on the assumption that " - "at most max_pred_locks_per_transaction * max_connections distinct " + "at most max_pred_locks_per_transaction * max_connections distinct " "objects will need to be locked at any one time.") }, &max_predicate_locks_per_xact, @@ -3165,9 +3165,10 @@ static struct config_enum ConfigureNamesEnum[] = " the level, the fewer messages are sent.") }, &trace_recovery_messages, + /* - * client_message_level_options allows too many values, really, - * but it's not worth having a separate options array for this. + * client_message_level_options allows too many values, really, but + * it's not worth having a separate options array for this. */ LOG, client_message_level_options, NULL, NULL, NULL @@ -5100,8 +5101,8 @@ set_config_option(const char *name, const char *value, { /* * Historically we've just silently ignored attempts to set - * PGC_INTERNAL variables from the config file. Maybe it'd - * be better to use the prohibitValueChange logic for this? + * PGC_INTERNAL variables from the config file. Maybe it'd be + * better to use the prohibitValueChange logic for this? */ return true; } @@ -5559,8 +5560,8 @@ set_config_option(const char *name, const char *value, if (value) { /* - * The value passed by the caller could be transient, - * so we always strdup it. + * The value passed by the caller could be transient, so + * we always strdup it. */ newval = guc_strdup(elevel, value); if (newval == NULL) @@ -7922,7 +7923,7 @@ validate_option_array_item(const char *name, const char *value, * ERRCODE_INVALID_PARAMETER_VALUE SQLSTATE for check hook failures. * * Note that GUC_check_errmsg() etc are just macros that result in a direct - * assignment to the associated variables. That is ugly, but forced by the + * assignment to the associated variables. That is ugly, but forced by the * limitations of C's macro mechanisms. */ void @@ -7939,7 +7940,7 @@ GUC_check_errcode(int sqlerrcode) */ static bool -call_bool_check_hook(struct config_bool *conf, bool *newval, void **extra, +call_bool_check_hook(struct config_bool * conf, bool *newval, void **extra, GucSource source, int elevel) { /* Quick success if no hook */ @@ -7973,7 +7974,7 @@ call_bool_check_hook(struct config_bool *conf, bool *newval, void **extra, } static bool -call_int_check_hook(struct config_int *conf, int *newval, void **extra, +call_int_check_hook(struct config_int * conf, int *newval, void **extra, GucSource source, int elevel) { /* Quick success if no hook */ @@ -8007,7 +8008,7 @@ call_int_check_hook(struct config_int *conf, int *newval, void **extra, } static bool -call_real_check_hook(struct config_real *conf, double *newval, void **extra, +call_real_check_hook(struct config_real * conf, double *newval, void **extra, GucSource source, int elevel) { /* Quick success if no hook */ @@ -8041,7 +8042,7 @@ call_real_check_hook(struct config_real *conf, double *newval, void **extra, } static bool -call_string_check_hook(struct config_string *conf, char **newval, void **extra, +call_string_check_hook(struct config_string * conf, char **newval, void **extra, GucSource source, int elevel) { /* Quick success if no hook */ @@ -8075,7 +8076,7 @@ call_string_check_hook(struct config_string *conf, char **newval, void **extra, } static bool -call_enum_check_hook(struct config_enum *conf, int *newval, void **extra, +call_enum_check_hook(struct config_enum * conf, int *newval, void **extra, GucSource source, int elevel) { /* Quick success if no hook */ @@ -8365,9 +8366,9 @@ static bool check_canonical_path(char **newval, void **extra, GucSource source) { /* - * Since canonicalize_path never enlarges the string, we can just - * modify newval in-place. But watch out for NULL, which is the - * default value for external_pid_file. + * Since canonicalize_path never enlarges the string, we can just modify + * newval in-place. But watch out for NULL, which is the default value + * for external_pid_file. */ if (*newval) canonicalize_path(*newval); @@ -8378,12 +8379,12 @@ static bool check_timezone_abbreviations(char **newval, void **extra, GucSource source) { /* - * The boot_val given above for timezone_abbreviations is NULL. - * When we see this we just do nothing. If this value isn't overridden - * from the config file then pg_timezone_abbrev_initialize() will - * eventually replace it with "Default". This hack has two purposes: to - * avoid wasting cycles loading values that might soon be overridden from - * the config file, and to avoid trying to read the timezone abbrev files + * The boot_val given above for timezone_abbreviations is NULL. When we + * see this we just do nothing. If this value isn't overridden from the + * config file then pg_timezone_abbrev_initialize() will eventually + * replace it with "Default". This hack has two purposes: to avoid + * wasting cycles loading values that might soon be overridden from the + * config file, and to avoid trying to read the timezone abbrev files * during InitializeGUCOptions(). The latter doesn't work in an * EXEC_BACKEND subprocess because my_exec_path hasn't been set yet and so * we can't locate PGSHAREDIR. @@ -8443,15 +8444,15 @@ static void assign_tcp_keepalives_idle(int newval, void *extra) { /* - * The kernel API provides no way to test a value without setting it; - * and once we set it we might fail to unset it. So there seems little - * point in fully implementing the check-then-assign GUC API for these + * The kernel API provides no way to test a value without setting it; and + * once we set it we might fail to unset it. So there seems little point + * in fully implementing the check-then-assign GUC API for these * variables. Instead we just do the assignment on demand. pqcomm.c * reports any problems via elog(LOG). * - * This approach means that the GUC value might have little to do with - * the actual kernel value, so we use a show_hook that retrieves the - * kernel value rather than trusting GUC's copy. + * This approach means that the GUC value might have little to do with the + * actual kernel value, so we use a show_hook that retrieves the kernel + * value rather than trusting GUC's copy. */ (void) pq_setkeepalivesidle(newval, MyProcPort); } @@ -8574,7 +8575,7 @@ check_effective_io_concurrency(int *newval, void **extra, GucSource source) /* This range check shouldn't fail, but let's be paranoid */ if (new_prefetch_pages >= 0.0 && new_prefetch_pages < (double) INT_MAX) { - int *myextra = (int *) guc_malloc(ERROR, sizeof(int)); + int *myextra = (int *) guc_malloc(ERROR, sizeof(int)); *myextra = (int) rint(new_prefetch_pages); *extra = (void *) myextra; diff --git a/src/backend/utils/misc/rbtree.c b/src/backend/utils/misc/rbtree.c index 7a8ddf0a17e..f8143724d0a 100644 --- a/src/backend/utils/misc/rbtree.c +++ b/src/backend/utils/misc/rbtree.c @@ -75,7 +75,7 @@ struct RBTree */ #define RBNIL (&sentinel) -static RBNode sentinel = {InitialState, RBBLACK, RBNIL, RBNIL, NULL}; +static RBNode sentinel = {InitialState, RBBLACK, RBNIL, RBNIL, NULL}; /* @@ -99,10 +99,10 @@ static RBNode sentinel = {InitialState, RBBLACK, RBNIL, RBNIL, NULL}; * * The freefunc should just be pfree or equivalent; it should NOT attempt * to free any subsidiary data, because the node passed to it may not contain - * valid data! freefunc can be NULL if caller doesn't require retail + * valid data! freefunc can be NULL if caller doesn't require retail * space reclamation. * - * The RBTree node is palloc'd in the caller's memory context. Note that + * The RBTree node is palloc'd in the caller's memory context. Note that * all contents of the tree are actually allocated by the caller, not here. * * Since tree contents are managed by the caller, there is currently not @@ -130,6 +130,7 @@ rb_create(Size node_size, tree->combiner = combiner; tree->allocfunc = allocfunc; tree->freefunc = freefunc; + tree->arg = arg; return tree; @@ -161,7 +162,7 @@ rb_find(RBTree *rb, const RBNode *data) while (node != RBNIL) { - int cmp = rb->comparator(data, node, rb->arg); + int cmp = rb->comparator(data, node, rb->arg); if (cmp == 0) return node; @@ -434,10 +435,11 @@ rb_insert(RBTree *rb, const RBNode *data, bool *isNew) */ *isNew = true; - x = rb->allocfunc(rb->arg); + x = rb->allocfunc (rb->arg); x->iteratorState = InitialState; x->color = RBRED; + x->left = RBNIL; x->right = RBNIL; x->parent = parent; @@ -629,7 +631,7 @@ rb_delete_node(RBTree *rb, RBNode *z) /* Now we can recycle the y node */ if (rb->freefunc) - rb->freefunc(y, rb->arg); + rb->freefunc (y, rb->arg); } /* diff --git a/src/backend/utils/misc/tzparser.c b/src/backend/utils/misc/tzparser.c index b2f6dd3a2bb..b52942db721 100644 --- a/src/backend/utils/misc/tzparser.c +++ b/src/backend/utils/misc/tzparser.c @@ -4,7 +4,7 @@ * Functions for parsing timezone offset files * * Note: this code is invoked from the check_hook for the GUC variable - * timezone_abbreviations. Therefore, it should report problems using + * timezone_abbreviations. Therefore, it should report problems using * GUC_check_errmsg() and related functions, and try to avoid throwing * elog(ERROR). This is not completely bulletproof at present --- in * particular out-of-memory will throw an error. Could probably fix with diff --git a/src/backend/utils/mmgr/aset.c b/src/backend/utils/mmgr/aset.c index b28dc474203..e95dcb6b7cf 100644 --- a/src/backend/utils/mmgr/aset.c +++ b/src/backend/utils/mmgr/aset.c @@ -165,7 +165,7 @@ typedef struct AllocBlockData AllocBlock next; /* next block in aset's blocks list */ char *freeptr; /* start of free space in this block */ char *endptr; /* end of space in this block */ -} AllocBlockData; +} AllocBlockData; /* * AllocChunk @@ -184,7 +184,7 @@ typedef struct AllocChunkData /* this is zero in a free chunk */ Size requested_size; #endif -} AllocChunkData; +} AllocChunkData; /* * AllocPointerIsValid diff --git a/src/backend/utils/mmgr/portalmem.c b/src/backend/utils/mmgr/portalmem.c index 7fa66b42212..186548dcba5 100644 --- a/src/backend/utils/mmgr/portalmem.c +++ b/src/backend/utils/mmgr/portalmem.c @@ -413,8 +413,8 @@ MarkPortalDone(Portal portal) portal->status = PORTAL_DONE; /* - * Allow portalcmds.c to clean up the state it knows about. We might - * as well do that now, since the portal can't be executed any more. + * Allow portalcmds.c to clean up the state it knows about. We might as + * well do that now, since the portal can't be executed any more. * * In some cases involving execution of a ROLLBACK command in an already * aborted transaction, this prevents an assertion failure from reaching @@ -449,7 +449,7 @@ PortalDrop(Portal portal, bool isTopCommit) /* * Allow portalcmds.c to clean up the state it knows about, in particular - * shutting down the executor if still active. This step potentially runs + * shutting down the executor if still active. This step potentially runs * user-defined code so failure has to be expected. It's the cleanup * hook's responsibility to not try to do that more than once, in the case * that failure occurs and then we come back to drop the portal again @@ -577,7 +577,7 @@ PortalHashTableDeleteAll(void) * Holdable cursors created in this transaction need to be converted to * materialized form, since we are going to close down the executor and * release locks. Non-holdable portals created in this transaction are - * simply removed. Portals remaining from prior transactions should be + * simply removed. Portals remaining from prior transactions should be * left untouched. * * Returns TRUE if any portals changed state (possibly causing user-defined @@ -678,9 +678,9 @@ PreCommit_Portals(bool isPrepare) } /* - * After either freezing or dropping a portal, we have to restart - * the iteration, because we could have invoked user-defined code - * that caused a drop of the next portal in the hash chain. + * After either freezing or dropping a portal, we have to restart the + * iteration, because we could have invoked user-defined code that + * caused a drop of the next portal in the hash chain. */ hash_seq_term(&status); hash_seq_init(&status, PortalHashTable); diff --git a/src/backend/utils/resowner/resowner.c b/src/backend/utils/resowner/resowner.c index c1ba5ad8e64..e5461e660ef 100644 --- a/src/backend/utils/resowner/resowner.c +++ b/src/backend/utils/resowner/resowner.c @@ -78,7 +78,7 @@ typedef struct ResourceOwnerData int nfiles; /* number of owned temporary files */ File *files; /* dynamically allocated array */ int maxfiles; /* currently allocated array size */ -} ResourceOwnerData; +} ResourceOwnerData; /***************************************************************************** diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c index a1850b83c5e..bd5b4b0a7d7 100644 --- a/src/backend/utils/sort/tuplesort.c +++ b/src/backend/utils/sort/tuplesort.c @@ -351,7 +351,7 @@ struct Tuplesortstate * indexScanKey. */ IndexInfo *indexInfo; /* info about index being used for reference */ - EState *estate; /* for evaluating index expressions */ + EState *estate; /* for evaluating index expressions */ /* * These variables are specific to the IndexTuple case; they are set by @@ -469,12 +469,12 @@ static void readtup_heap(Tuplesortstate *state, SortTuple *stup, int tapenum, unsigned int len); static void reversedirection_heap(Tuplesortstate *state); static int comparetup_cluster(const SortTuple *a, const SortTuple *b, - Tuplesortstate *state); + Tuplesortstate *state); static void copytup_cluster(Tuplesortstate *state, SortTuple *stup, void *tup); static void writetup_cluster(Tuplesortstate *state, int tapenum, - SortTuple *stup); + SortTuple *stup); static void readtup_cluster(Tuplesortstate *state, SortTuple *stup, - int tapenum, unsigned int len); + int tapenum, unsigned int len); static int comparetup_index_btree(const SortTuple *a, const SortTuple *b, Tuplesortstate *state); static int comparetup_index_hash(const SortTuple *a, const SortTuple *b, @@ -582,7 +582,7 @@ tuplesort_begin_common(int workMem, bool randomAccess) Tuplesortstate * tuplesort_begin_heap(TupleDesc tupDesc, int nkeys, AttrNumber *attNums, - Oid *sortOperators, Oid *collations, bool *nullsFirstFlags, + Oid *sortOperators, Oid *collations, bool *nullsFirstFlags, int workMem, bool randomAccess) { Tuplesortstate *state = tuplesort_begin_common(workMem, randomAccess); @@ -699,7 +699,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc, if (state->indexInfo->ii_Expressions != NULL) { TupleTableSlot *slot; - ExprContext *econtext; + ExprContext *econtext; /* * We will need to use FormIndexDatum to evaluate the index @@ -796,7 +796,7 @@ tuplesort_begin_index_hash(Relation indexRel, Tuplesortstate * tuplesort_begin_datum(Oid datumType, - Oid sortOperator, Oid sortCollation, bool nullsFirstFlag, + Oid sortOperator, Oid sortCollation, bool nullsFirstFlag, int workMem, bool randomAccess) { Tuplesortstate *state = tuplesort_begin_common(workMem, randomAccess); @@ -945,7 +945,7 @@ tuplesort_end(Tuplesortstate *state) /* Free any execution state created for CLUSTER case */ if (state->estate != NULL) { - ExprContext *econtext = GetPerTupleExprContext(state->estate); + ExprContext *econtext = GetPerTupleExprContext(state->estate); ExecDropSingleTupleTableSlot(econtext->ecxt_scantuple); FreeExecutorState(state->estate); @@ -1546,7 +1546,7 @@ tuplesort_gettupleslot(Tuplesortstate *state, bool forward, /* * Fetch the next tuple in either forward or back direction. - * Returns NULL if no more tuples. If *should_free is set, the + * Returns NULL if no more tuples. If *should_free is set, the * caller must pfree the returned tuple when done with it. */ HeapTuple diff --git a/src/backend/utils/time/snapmgr.c b/src/backend/utils/time/snapmgr.c index 9100c818f89..ef66466baf1 100644 --- a/src/backend/utils/time/snapmgr.c +++ b/src/backend/utils/time/snapmgr.c @@ -41,7 +41,7 @@ * CurrentSnapshot points to the only snapshot taken in transaction-snapshot * mode, and to the latest one taken in a read-committed transaction. * SecondarySnapshot is a snapshot that's always up-to-date as of the current - * instant, even in transaction-snapshot mode. It should only be used for + * instant, even in transaction-snapshot mode. It should only be used for * special-purpose code (say, RI checking.) * * These SnapshotData structs are static to simplify memory allocation @@ -533,8 +533,8 @@ void AtEarlyCommit_Snapshot(void) { /* - * In transaction-snapshot mode we must unregister our private refcount - * to the transaction-snapshot. + * In transaction-snapshot mode we must unregister our private refcount to + * the transaction-snapshot. */ if (registered_xact_snapshot) UnregisterSnapshotFromOwner(CurrentSnapshot, |