1
0
mirror of https://github.com/postgres/postgres.git synced 2025-07-11 10:01:57 +03:00

pgindent run on all C files. Java run to follow. initdb/regression

tests pass.
This commit is contained in:
Bruce Momjian
2001-10-25 05:50:21 +00:00
parent 59da2105d8
commit b81844b173
818 changed files with 21684 additions and 20491 deletions

View File

@ -64,7 +64,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/sort/logtape.c,v 1.6 2001/01/24 19:43:17 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/sort/logtape.c,v 1.7 2001/10/25 05:49:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -224,7 +224,6 @@ ltsReadBlock(LogicalTapeSet *lts, long blocknum, void *buffer)
static long
ltsGetFreeBlock(LogicalTapeSet *lts)
{
/*
* If there are multiple free blocks, we select the one appearing last
* in freeBlocks[]. If there are none, assign the next block at the
@ -286,7 +285,6 @@ ltsRecordBlockNum(LogicalTapeSet *lts, IndirectBlock *indirect,
{
if (indirect->nextSlot >= BLOCKS_PER_INDIR_BLOCK)
{
/*
* This indirect block is full, so dump it out and recursively
* save its address in the next indirection level. Create a new
@ -365,7 +363,6 @@ static long
ltsRewindFrozenIndirectBlock(LogicalTapeSet *lts,
IndirectBlock *indirect)
{
/*
* If block is not topmost, recurse to obtain address of first block
* in this hierarchy level. Read that one in.
@ -612,7 +609,6 @@ LogicalTapeRewind(LogicalTapeSet *lts, int tapenum, bool forWrite)
{
if (lt->writing)
{
/*
* Completion of a write phase. Flush last partial data
* block, flush any partial indirect blocks, rewind for normal
@ -626,7 +622,6 @@ LogicalTapeRewind(LogicalTapeSet *lts, int tapenum, bool forWrite)
}
else
{
/*
* This is only OK if tape is frozen; we rewind for (another)
* read pass.
@ -649,7 +644,6 @@ LogicalTapeRewind(LogicalTapeSet *lts, int tapenum, bool forWrite)
}
else
{
/*
* Completion of a read phase. Rewind and prepare for write.
*

View File

@ -78,7 +78,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/sort/tuplesort.c,v 1.18 2001/08/21 16:36:05 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/sort/tuplesort.c,v 1.19 2001/10/25 05:49:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -104,12 +104,13 @@
*/
typedef enum
{
TSS_INITIAL, /* Loading tuples; still within memory
TSS_INITIAL, /* Loading tuples; still within memory
* limit */
TSS_BUILDRUNS, /* Loading tuples; writing to tape */
TSS_SORTEDINMEM, /* Sort completed entirely in memory */
TSS_SORTEDONTAPE, /* Sort completed, final run is on tape */
TSS_FINALMERGE /* Performing final merge on-the-fly */
TSS_BUILDRUNS, /* Loading tuples; writing to tape */
TSS_SORTEDINMEM,/* Sort completed entirely in memory */
TSS_SORTEDONTAPE, /* Sort completed, final run is on
* tape */
TSS_FINALMERGE /* Performing final merge on-the-fly */
} TupSortStatus;
/*
@ -135,10 +136,9 @@ struct Tuplesortstate
* kind of tuple we are sorting from the routines that don't need to
* know it. They are set up by the tuplesort_begin_xxx routines.
*
* Function to compare two tuples; result is per qsort() convention,
* ie:
* Function to compare two tuples; result is per qsort() convention, ie:
*
* <0, 0, >0 according as a<b, a=b, a>b.
* <0, 0, >0 according as a<b, a=b, a>b.
*/
int (*comparetup) (Tuplesortstate *state, const void *a, const void *b);
@ -584,7 +584,10 @@ tuplesort_end(Tuplesortstate *state)
if (state->memtupindex)
pfree(state->memtupindex);
/* this stuff might better belong in a variant-specific shutdown routine */
/*
* this stuff might better belong in a variant-specific shutdown
* routine
*/
if (state->scanKeys)
pfree(state->scanKeys);
if (state->sortFnKinds)
@ -601,7 +604,6 @@ tuplesort_end(Tuplesortstate *state)
void
tuplesort_puttuple(Tuplesortstate *state, void *tuple)
{
/*
* Copy the given tuple into memory we control, and decrease availMem.
* Then call the code shared with the Datum case.
@ -660,7 +662,7 @@ puttuple_common(Tuplesortstate *state, void *tuple)
{
switch (state->status)
{
case TSS_INITIAL:
case TSS_INITIAL:
/*
* Save the copied tuple into the unsorted array.
@ -732,7 +734,7 @@ tuplesort_performsort(Tuplesortstate *state)
{
switch (state->status)
{
case TSS_INITIAL:
case TSS_INITIAL:
/*
* We were able to accumulate all the tuples within the
@ -843,7 +845,6 @@ tuplesort_gettuple(Tuplesortstate *state, bool forward,
*/
if (state->eof_reached)
{
/*
* Seek position is pointing just past the zero tuplen at
* the end of file; back up to fetch last tuple's ending
@ -858,7 +859,6 @@ tuplesort_gettuple(Tuplesortstate *state, bool forward,
}
else
{
/*
* Back up and fetch previously-returned tuple's ending
* length word. If seek fails, assume we are at start of
@ -877,7 +877,6 @@ tuplesort_gettuple(Tuplesortstate *state, bool forward,
state->result_tape,
tuplen + 2 * sizeof(unsigned int)))
{
/*
* If that fails, presumably the prev tuple is the
* first in the file. Back up so that it becomes next
@ -928,7 +927,6 @@ tuplesort_gettuple(Tuplesortstate *state, bool forward,
tuplesort_heap_siftup(state, false);
if ((tupIndex = state->mergenext[srcTape]) == 0)
{
/*
* out of preloaded data on this tape, try to read
* more
@ -1457,7 +1455,6 @@ dumptuples(Tuplesortstate *state, bool alltuples)
while (alltuples ||
(LACKMEM(state) && state->memtupcount > 1))
{
/*
* Dump the heap's frontmost entry, and sift up to remove it from
* the heap.
@ -2037,10 +2034,10 @@ tuplesize_datum(Tuplesortstate *state, void *tup)
/*
* This routine selects an appropriate sorting function to implement
* a sort operator as efficiently as possible. The straightforward
* a sort operator as efficiently as possible. The straightforward
* method is to use the operator's implementation proc --- ie, "<"
* comparison. However, that way often requires two calls of the function
* per comparison. If we can find a btree three-way comparator function
* comparison. However, that way often requires two calls of the function
* per comparison. If we can find a btree three-way comparator function
* associated with the operator, we can use it to do the comparisons
* more efficiently. We also support the possibility that the operator
* is ">" (descending sort), in which case we have to reverse the output
@ -2061,12 +2058,12 @@ SelectSortFunction(Oid sortOperator,
Oid opclass = InvalidOid;
/*
* Scan pg_amop to see if the target operator is registered as the
* "<" or ">" operator of any btree opclass. It's possible that it
* might be registered both ways (eg, if someone were to build a
* "reverse sort" opclass for some reason); prefer the "<" case if so.
* If the operator is registered the same way in multiple opclasses,
* assume we can use the associated comparator function from any one.
* Scan pg_amop to see if the target operator is registered as the "<"
* or ">" operator of any btree opclass. It's possible that it might
* be registered both ways (eg, if someone were to build a "reverse
* sort" opclass for some reason); prefer the "<" case if so. If the
* operator is registered the same way in multiple opclasses, assume
* we can use the associated comparator function from any one.
*/
ScanKeyEntryInitialize(&skey[0], 0x0,
Anum_pg_amop_amopopr,
@ -2109,6 +2106,7 @@ SelectSortFunction(Oid sortOperator,
if (HeapTupleIsValid(tuple))
{
Form_pg_amproc aform = (Form_pg_amproc) GETSTRUCT(tuple);
*sortFunction = aform->amproc;
ReleaseSysCache(tuple);
Assert(RegProcedureIsValid(*sortFunction));
@ -2119,7 +2117,8 @@ SelectSortFunction(Oid sortOperator,
/*
* Can't find a comparator, so use the operator as-is. Decide whether
* it is forward or reverse sort by looking at its name (grotty, but
* this only matters for deciding which end NULLs should get sorted to).
* this only matters for deciding which end NULLs should get sorted
* to).
*/
tuple = SearchSysCache(OPEROID,
ObjectIdGetDatum(sortOperator),
@ -2202,8 +2201,8 @@ ApplySortFunction(FmgrInfo *sortFunction, SortFunctionKind kind,
}
if (isNull2)
return 1;
return - DatumGetInt32(FunctionCall2(sortFunction,
datum1, datum2));
return -DatumGetInt32(FunctionCall2(sortFunction,
datum1, datum2));
default:
elog(ERROR, "Invalid SortFunctionKind %d", (int) kind);

View File

@ -26,7 +26,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/sort/tuplestore.c,v 1.3 2001/03/22 04:00:10 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/sort/tuplestore.c,v 1.4 2001/10/25 05:49:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -43,11 +43,11 @@
*/
typedef enum
{
TSS_INITIAL, /* Loading tuples; still within memory
TSS_INITIAL, /* Loading tuples; still within memory
* limit */
TSS_WRITEFILE, /* Loading tuples; writing to temp file */
TSS_READMEM, /* Reading tuples; entirely in memory */
TSS_READFILE /* Reading tuples from temp file */
TSS_WRITEFILE, /* Loading tuples; writing to temp file */
TSS_READMEM, /* Reading tuples; entirely in memory */
TSS_READFILE /* Reading tuples from temp file */
} TupStoreStatus;
/*
@ -271,7 +271,6 @@ tuplestore_end(Tuplestorestate *state)
void
tuplestore_puttuple(Tuplestorestate *state, void *tuple)
{
/*
* Copy the tuple. (Must do this even in WRITEFILE case.)
*/
@ -324,7 +323,7 @@ tuplestore_donestoring(Tuplestorestate *state)
{
switch (state->status)
{
case TSS_INITIAL:
case TSS_INITIAL:
/*
* We were able to accumulate all the tuples within the
@ -432,7 +431,6 @@ tuplestore_gettuple(Tuplestorestate *state, bool forward,
*/
if (state->eof_reached)
{
/*
* Seek position is pointing just past the zero tuplen at
* the end of file; back up to fetch last tuple's ending
@ -447,7 +445,6 @@ tuplestore_gettuple(Tuplestorestate *state, bool forward,
}
else
{
/*
* Back up and fetch previously-returned tuple's ending
* length word. If seek fails, assume we are at start of
@ -466,7 +463,6 @@ tuplestore_gettuple(Tuplestorestate *state, bool forward,
-(long) (tuplen + 2 * sizeof(unsigned int)),
SEEK_CUR) != 0)
{
/*
* If that fails, presumably the prev tuple is the
* first in the file. Back up so that it becomes next