From a2788b2f7dcceeeaa9229bfbf1ba2e5c413afb99 Mon Sep 17 00:00:00 2001 From: Tomas Vondra Date: Sun, 9 Jun 2024 13:41:54 +0200 Subject: [PATCH v20240609 4/4] fix: pgindent --- src/backend/utils/sort/mk_qsort_tuple.c | 121 ++++++++++---------- src/backend/utils/sort/tuplesort.c | 26 ++--- src/backend/utils/sort/tuplesortvariants.c | 125 ++++++++++----------- src/include/utils/tuplesort.h | 34 +++--- 4 files changed, 152 insertions(+), 154 deletions(-) diff --git a/src/backend/utils/sort/mk_qsort_tuple.c b/src/backend/utils/sort/mk_qsort_tuple.c index 9c5715380aa..e44bc50d652 100644 --- a/src/backend/utils/sort/mk_qsort_tuple.c +++ b/src/backend/utils/sort/mk_qsort_tuple.c @@ -22,11 +22,11 @@ /* Swap two tuples in sort tuple array */ static inline void -mkqs_swap(int a, - int b, +mkqs_swap(int a, + int b, SortTuple *x) { - SortTuple t; + SortTuple t; if (a == b) return; @@ -37,9 +37,9 @@ mkqs_swap(int a, /* Swap tuples by batch in sort tuple array */ static inline void -mkqs_vec_swap(int a, - int b, - int size, +mkqs_vec_swap(int a, + int b, + int size, SortTuple *x) { while (size-- > 0) @@ -56,12 +56,12 @@ mkqs_vec_swap(int a, * a tuple array, so tupleIndex is unnecessary */ static inline bool -check_datum_null(SortTuple *x, - int depth, +check_datum_null(SortTuple *x, + int depth, Tuplesortstate *state) { - Datum datum; - bool isNull; + Datum datum; + bool isNull; Assert(depth < state->base.nKeys); @@ -94,15 +94,17 @@ check_datum_null(SortTuple *x, * See comparetup_heap() for details. */ static inline int -mkqs_compare_datum(SortTuple *tuple1, - SortTuple *tuple2, - int depth, +mkqs_compare_datum(SortTuple *tuple1, + SortTuple *tuple2, + int depth, Tuplesortstate *state) { - Datum datum1, datum2; - bool isNull1, isNull2; + Datum datum1, + datum2; + bool isNull1, + isNull2; SortSupport sortKey; - int ret = 0; + int ret = 0; Assert(state->base.mkqsGetDatumFunc); Assert(depth < state->base.nKeys); @@ -120,10 +122,10 @@ mkqs_compare_datum(SortTuple *tuple1, sortKey); /* - * If "abbreviated key" is enabled, and we are in the first depth, it means - * only "abbreviated keys" are compared. If the two datums are determined to - * be equal by ApplySortComparator(), we need to perform an extra "full" - * comparing by ApplySortAbbrevFullComparator(). + * If "abbreviated key" is enabled, and we are in the first depth, it + * means only "abbreviated keys" are compared. If the two datums are + * determined to be equal by ApplySortComparator(), we need to perform an + * extra "full" comparing by ApplySortAbbrevFullComparator(). */ if (sortKey->abbrev_converter && depth == 0 && @@ -150,14 +152,14 @@ mkqs_compare_datum(SortTuple *tuple1, * Verify whether the SortTuple list is ordered or not at specified depth */ static void -mkqs_verify(SortTuple *x, - int n, - int depth, +mkqs_verify(SortTuple *x, + int n, + int depth, Tuplesortstate *state) { - int ret; + int ret; - for (int i = 0;i < n - 1;i++) + for (int i = 0; i < n - 1; i++) { ret = mkqs_compare_datum(x + i, x + i + 1, @@ -174,27 +176,31 @@ mkqs_verify(SortTuple *x, * seenNull indicates whether we have seen NULL in any datum we checked */ static void -mk_qsort_tuple(SortTuple *x, - size_t n, - int depth, - Tuplesortstate *state, - bool seenNull) +mk_qsort_tuple(SortTuple *x, + size_t n, + int depth, + Tuplesortstate *state, + bool seenNull) { /* - * In the process, the tuple array consists of five parts: - * left equal, less, not-processed, greater, right equal + * In the process, the tuple array consists of five parts: left equal, + * less, not-processed, greater, right equal * - * lessStart indicates the first position of less part - * lessEnd indicates the next position after less part - * greaterStart indicates the prior position before greater part - * greaterEnd indicates the latest position of greater part - * the range between lessEnd and greaterStart (inclusive) is not-processed + * lessStart indicates the first position of less part lessEnd indicates + * the next position after less part greaterStart indicates the prior + * position before greater part greaterEnd indicates the latest position + * of greater part the range between lessEnd and greaterStart (inclusive) + * is not-processed */ - int lessStart, lessEnd, greaterStart, greaterEnd, tupCount; - int32 dist; - SortTuple *pivot; - bool isDatumNull; - bool strictOrdered = true; + int lessStart, + lessEnd, + greaterStart, + greaterEnd, + tupCount; + int32 dist; + SortTuple *pivot; + bool isDatumNull; + bool strictOrdered = true; Assert(depth <= state->base.nKeys); Assert(state->base.sortKeys); @@ -212,12 +218,12 @@ mk_qsort_tuple(SortTuple *x, /* * Check if the array is ordered already. If yes, return immediately. * Different from qsort_tuple(), the array must be strict ordered (no - * equal datums). If there are equal datums, we must continue the mk - * qsort process to check datums on lower depth. + * equal datums). If there are equal datums, we must continue the mk qsort + * process to check datums on lower depth. */ - for (int i = 0;i < n - 1;i++) + for (int i = 0; i < n - 1; i++) { - int ret; + int ret; CHECK_FOR_INTERRUPTS(); ret = mkqs_compare_datum(x + i, @@ -299,8 +305,7 @@ mk_qsort_tuple(SortTuple *x, } /* - * Now the array has four parts: - * left equal, lesser, greater, right equal + * Now the array has four parts: left equal, lesser, greater, right equal * Note greaterStart is less than lessEnd now */ @@ -313,9 +318,8 @@ mk_qsort_tuple(SortTuple *x, mkqs_vec_swap(lessEnd, n - dist, dist, x); /* - * Now the array has three parts: - * lesser, equal, greater - * Note that one or two parts may have no element at all. + * Now the array has three parts: lesser, equal, greater Note that one or + * two parts may have no element at all. */ /* Recursively sort the lesser part */ @@ -331,9 +335,9 @@ mk_qsort_tuple(SortTuple *x, /* Recursively sort the equal part */ /* - * (x + dist) means the first tuple in the equal part - * Since all tuples have equal datums at current depth, we just check any one - * of them to determine whether we have seen null datum. + * (x + dist) means the first tuple in the equal part Since all tuples + * have equal datums at current depth, we just check any one of them to + * determine whether we have seen null datum. */ isDatumNull = check_datum_null(x + dist, depth, state); @@ -347,7 +351,9 @@ mk_qsort_tuple(SortTuple *x, depth + 1, state, seenNull || isDatumNull); - } else { + } + else + { /* * We have reach the max depth: Call mkqsHandleDupFunc to handle * duplicated tuples if necessary, e.g. checking uniqueness or extra @@ -355,9 +361,8 @@ mk_qsort_tuple(SortTuple *x, */ /* - * Call mkqsHandleDupFunc if: - * 1. mkqsHandleDupFunc is filled - * 2. the size of equal part > 1 + * Call mkqsHandleDupFunc if: 1. mkqsHandleDupFunc is filled 2. the + * size of equal part > 1 */ if (state->base.mkqsHandleDupFunc && (tupCount > 1)) diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c index 5718911eb9b..d51d97b1136 100644 --- a/src/backend/utils/sort/tuplesort.c +++ b/src/backend/utils/sort/tuplesort.c @@ -340,7 +340,7 @@ struct Tuplesortstate #endif /* Whether multi-key quick sort is used */ - bool mkqsUsed; + bool mkqsUsed; }; /* @@ -2729,23 +2729,19 @@ tuplesort_sort_memtuples(Tuplesortstate *state) if (state->memtupcount > 1) { /* - * Apply multi-key quick sort when: - * 1. enable_mk_sort is set - * 2. There are multiple keys available - * 3. mkqsGetDatumFunc is filled, which implies that current tuple - * type is supported by mk qsort. (By now only Heap tuple and Btree - * Index tuple are supported, and more types may be supported in - * future.) + * Apply multi-key quick sort when: 1. enable_mk_sort is set 2. There + * are multiple keys available 3. mkqsGetDatumFunc is filled, which + * implies that current tuple type is supported by mk qsort. (By now + * only Heap tuple and Btree Index tuple are supported, and more types + * may be supported in future.) * * A summary of tuple types supported by mk qsort: * - * HeapTuple: supported - * IndexTuple(btree): supported - * IndexTuple(hash): not supported because there is only one key - * DatumTuple: not supported because there is only one key - * HeapTuple(for cluster): not supported yet - * IndexTuple(gist): not supported yet - * IndexTuple(brin): not supported yet + * HeapTuple: supported IndexTuple(btree): supported IndexTuple(hash): + * not supported because there is only one key DatumTuple: not + * supported because there is only one key HeapTuple(for cluster): not + * supported yet IndexTuple(gist): not supported yet IndexTuple(brin): + * not supported yet */ if (enable_mk_sort && state->base.nKeys > 1 && diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c index 412e5b9b588..a41d4daa4b3 100644 --- a/src/backend/utils/sort/tuplesortvariants.c +++ b/src/backend/utils/sort/tuplesortvariants.c @@ -93,40 +93,40 @@ static void readtup_datum(Tuplesortstate *state, SortTuple *stup, LogicalTape *tape, unsigned int len); static void freestate_cluster(Tuplesortstate *state); -static Datum mkqs_get_datum_heap(SortTuple *x, - const int tupleIndex, - const int depth, +static Datum mkqs_get_datum_heap(SortTuple *x, + const int tupleIndex, + const int depth, Tuplesortstate *state, - Datum *datum, - bool *isNull, - bool useFullKey); + Datum *datum, + bool *isNull, + bool useFullKey); -static Datum mkqs_get_datum_index_btree(SortTuple *x, - const int tupleIndex, - const int depth, +static Datum mkqs_get_datum_index_btree(SortTuple *x, + const int tupleIndex, + const int depth, Tuplesortstate *state, - Datum *datum, - bool *isNull, - bool useFullKey); + Datum *datum, + bool *isNull, + bool useFullKey); static void -mkqs_handle_dup_index_btree(SortTuple *x, - const int tupleCount, - const bool seenNull, - Tuplesortstate *state); + mkqs_handle_dup_index_btree(SortTuple *x, + const int tupleCount, + const bool seenNull, + Tuplesortstate *state); static int -mkqs_compare_equal_index_btree(const SortTuple *a, - const SortTuple *b, - Tuplesortstate *state); + mkqs_compare_equal_index_btree(const SortTuple *a, + const SortTuple *b, + Tuplesortstate *state); static inline int -tuplesort_compare_by_item_pointer(const IndexTuple tuple1, - const IndexTuple tuple2); + tuplesort_compare_by_item_pointer(const IndexTuple tuple1, + const IndexTuple tuple2); static inline void -raise_error_of_dup_index(IndexTuple x, - Tuplesortstate *state); + raise_error_of_dup_index(IndexTuple x, + Tuplesortstate *state); /* * Data structure pointed by "TuplesortPublic.arg" for the CLUSTER case. Set by @@ -1918,18 +1918,18 @@ readtup_datum(Tuplesortstate *state, SortTuple *stup, * See comparetup_heap() for details. */ static Datum -mkqs_get_datum_heap(SortTuple *x, - int tupleIndex, - int depth, +mkqs_get_datum_heap(SortTuple *x, + int tupleIndex, + int depth, Tuplesortstate *state, - Datum *datum, - bool *isNull, - bool useFullKey) + Datum *datum, + bool *isNull, + bool useFullKey) { - TupleDesc tupDesc = NULL; + TupleDesc tupDesc = NULL; HeapTupleData heapTuple; - AttrNumber attno; - SortTuple *sortTuple = x + tupleIndex; + AttrNumber attno; + SortTuple *sortTuple = x + tupleIndex; TuplesortPublic *base = TuplesortstateGetPublic(state); SortSupport sortKey = base->sortKeys + depth;; @@ -1942,7 +1942,7 @@ mkqs_get_datum_heap(SortTuple *x, */ AssertImply(useFullKey, depth == 0); - tupDesc = (TupleDesc)base->arg; + tupDesc = (TupleDesc) base->arg; /* * When useFullKey is false, and the first datum is requested, return the @@ -1979,16 +1979,16 @@ mkqs_get_datum_heap(SortTuple *x, * See comparetup_index_btree() for details. */ static Datum -mkqs_get_datum_index_btree(SortTuple *x, - const int tupleIndex, - const int depth, +mkqs_get_datum_index_btree(SortTuple *x, + const int tupleIndex, + const int depth, Tuplesortstate *state, - Datum *datum, - bool *isNull, - bool useFullKey) + Datum *datum, + bool *isNull, + bool useFullKey) { - TupleDesc tupDesc; - IndexTuple indexTuple; + TupleDesc tupDesc; + IndexTuple indexTuple; SortTuple *sortTuple = x + tupleIndex; TuplesortPublic *base = TuplesortstateGetPublic(state); TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg; @@ -2031,9 +2031,9 @@ mkqs_get_datum_index_btree(SortTuple *x, * tupleCount: count of the tuples */ static void -mkqs_handle_dup_index_btree(SortTuple *x, - const int tupleCount, - const bool seenNull, +mkqs_handle_dup_index_btree(SortTuple *x, + const int tupleCount, + const bool seenNull, Tuplesortstate *state) { TuplesortPublic *base = TuplesortstateGetPublic(state); @@ -2043,11 +2043,10 @@ mkqs_handle_dup_index_btree(SortTuple *x, if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && seenNull)) { /* - * x means the first tuple of duplicated tuple list - * Since they are duplicated, simply pick up the first one - * to raise error + * x means the first tuple of duplicated tuple list Since they are + * duplicated, simply pick up the first one to raise error */ - raise_error_of_dup_index((IndexTuple)(x->tuple), state); + raise_error_of_dup_index((IndexTuple) (x->tuple), state); } /* @@ -2069,10 +2068,10 @@ mkqs_handle_dup_index_btree(SortTuple *x, static int mkqs_compare_equal_index_btree(const SortTuple *a, const SortTuple *b, - Tuplesortstate *state) + Tuplesortstate *state) { - IndexTuple tuple1; - IndexTuple tuple2; + IndexTuple tuple1; + IndexTuple tuple2; tuple1 = (IndexTuple) a->tuple; tuple2 = (IndexTuple) b->tuple; @@ -2108,26 +2107,26 @@ tuplesort_compare_by_item_pointer(const IndexTuple tuple1, /* Raise error for duplicated tuple when creating unique index */ static inline void -raise_error_of_dup_index(IndexTuple x, +raise_error_of_dup_index(IndexTuple x, Tuplesortstate *state) { - Datum values[INDEX_MAX_KEYS]; - bool isnull[INDEX_MAX_KEYS]; - TupleDesc tupDesc; - char *key_desc; + Datum values[INDEX_MAX_KEYS]; + bool isnull[INDEX_MAX_KEYS]; + TupleDesc tupDesc; + char *key_desc; TuplesortPublic *base = TuplesortstateGetPublic(state); TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg; tupDesc = RelationGetDescr(arg->index.indexRel); - index_deform_tuple((IndexTuple)x, tupDesc, values, isnull); + index_deform_tuple((IndexTuple) x, tupDesc, values, isnull); key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull); ereport(ERROR, (errcode(ERRCODE_UNIQUE_VIOLATION), - errmsg("could not create unique index \"%s\"", - RelationGetRelationName(arg->index.indexRel)), - key_desc ? errdetail("Key %s is duplicated.", key_desc) : - errdetail("Duplicate keys exist."), - errtableconstraint(arg->index.heapRel, - RelationGetRelationName(arg->index.indexRel)))); + errmsg("could not create unique index \"%s\"", + RelationGetRelationName(arg->index.indexRel)), + key_desc ? errdetail("Key %s is duplicated.", key_desc) : + errdetail("Duplicate keys exist."), + errtableconstraint(arg->index.heapRel, + RelationGetRelationName(arg->index.indexRel)))); } diff --git a/src/include/utils/tuplesort.h b/src/include/utils/tuplesort.h index 74a6a5ae5ce..380a106789c 100644 --- a/src/include/utils/tuplesort.h +++ b/src/include/utils/tuplesort.h @@ -158,19 +158,19 @@ typedef int (*SortTupleComparator) (const SortTuple *a, const SortTuple *b, /* Multi-key quick sort */ typedef Datum -(*MkqsGetDatumFunc) (SortTuple *x, - const int tupleIndex, - const int depth, - Tuplesortstate *state, - Datum *datum, - bool *isNull, - bool useFullKey); + (*MkqsGetDatumFunc) (SortTuple *x, + const int tupleIndex, + const int depth, + Tuplesortstate *state, + Datum *datum, + bool *isNull, + bool useFullKey); typedef void -(*MkqsHandleDupFunc) (SortTuple *x, - const int tupleCount, - const bool seenNull, - Tuplesortstate *state); + (*MkqsHandleDupFunc) (SortTuple *x, + const int tupleCount, + const bool seenNull, + Tuplesortstate *state); /* * The public part of a Tuple sort operation state. This data structure @@ -269,17 +269,15 @@ typedef struct /* * Function pointer, referencing a function to get specified datum from - * SortTuple list with multi-key. - * Used by mk_qsort_tuple(). - */ + * SortTuple list with multi-key. Used by mk_qsort_tuple(). + */ MkqsGetDatumFunc mkqsGetDatumFunc; /* * Function pointer, referencing a function to handle duplicated tuple - * from SortTuple list with multi-key. - * Used by mk_qsort_tuple(). - * For now, the function pointer is filled for only btree index tuple. - */ + * from SortTuple list with multi-key. Used by mk_qsort_tuple(). For now, + * the function pointer is filled for only btree index tuple. + */ MkqsHandleDupFunc mkqsHandleDupFunc; } TuplesortPublic; -- 2.45.1